@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/agents/pi-sdk-tools.js

@@ -13,6 +13,7 @@ import { checkWritePath } from './shell-guard.js';
 import { p2pDocumentTools } from './p2p-document-tools.js';
 import { runSelfImproveLoop } from './pi-sdk-session-factory.js';
 import { getMinimax } from '../constraints/index.js';
+import { llmConfigStore } from '../llm/config-store.js';
 import { delegateToEngine, buildDelegateCommand } from '../external-engines/delegate.js';
 import { spawnBackground } from './process-runner.js';
 import { DELEGATE_ENV_MARK } from './background-notices.js';
@@ -858,11 +859,9 @@ export function registerBuiltinTools(ctx) {
     //   与 shell_exec 的区别: 直接接受完整 shell 命令字符串, 更适合模型自主写命令.
     // 2026-10-01 (优化 #2 v1): **工具发现** —— 125 个工具不可能都记住, 给一个"按关键词找工具"的入口。
     // 空关键词只回**分类索引**(名称清单), 有关键词才回"名称+用途摘要" ⇒ 不刷屏。
-    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗, 从 hermes 触发的方法是什么, 学一下」):
-    //   **实测缺口**: `skill-loader` 把 1300 个技能**注册**进注册表 ✓, 但 `describeSkill` 只 import 从没调用 ✗
-    //   ⇒ 技能**描述从不进提示** ⇒ 模型不知道它们存在 ⇒ 技能触发链**断在这里** ✗。
-    //   她那边的做法: 启动自动装载 + 按**描述**在提示里露面 + 需要时用 `skill_view` 读全文 ✓。
-    //   bolloon 有 1300 个(她百来号) ⇒ 全量注入会撑爆提示 ✗ ⇒ 改成**两个发现工具**(和 `list_tools` 同一思路 ✓)。
+    // 2026-10-01 (用户: 「skills 教训学习, bolloon 有吗」): 技能发现 = 两个工具而非全量注入 —
+    //   技能库上千个, 全量注入会撑爆提示 (历史: 19 个 skill 曾把 systemPrompt 顶到 22K 导致模型不输出)。
+    //   做法同 `list_tools`: 按关键词找 (`list_skills`) → 读全文 (`read_skill`)。
     ctx.tools.set('list_skills', {
         name: 'list_skills',
         description: '用于**找技能**: 给关键词(中文/英文都行)⇒ 返回已装载技能的名字+说明(≤20 条); 不给关键词 ⇒ 先给总数与前若干条. 找到后用 read_skill 读全文再照做.',
@@ -4445,6 +4444,182 @@ export function registerWalletTools(ctx) {
             }
         }
     });
+    // 2026-10-14 (leo: 「需要向量记忆和去中心化记忆」, P0): 结构化记忆工具
+    //  —— MemoryEntry 本地 JSONL 持久化; embedding 向量 (P1) / OrbitDB 复制 (P3) 后续接
+    const memoryAgentId = () => ctx.identity?.did || String(ctx.cwd || '');
+    /**
+     * P1: 记忆 embedding 配置。读 llm-config 的 `embedding` 段:
+     *   { embedding: { provider, model, baseUrl?, apiKey?, groupId? } }
+     * 未配置 / provider 不可用 → { provider: 'none' } (记忆层回退关键词, 行为不变)。
+     * 诚实边界: 本仓现有 provider (glm 中转 / minimax 订阅 key) 实测无可用 embedding,
+     * 故默认 none; 将来任一供应商 key 就绪, 在此配置段填上即可, 记忆层零改动。
+     */
+    const getMemoryEmbeddingConfig = () => {
+        try {
+            const cfg = llmConfigStore?.config;
+            const emb = cfg?.embedding;
+            if (emb && typeof emb === 'object' && emb.provider && emb.provider !== 'none') {
+                return {
+                    provider: String(emb.provider),
+                    model: emb.model ? String(emb.model) : undefined,
+                    baseUrl: emb.baseUrl ? String(emb.baseUrl) : undefined,
+                    apiKey: emb.apiKey ? String(emb.apiKey) : undefined,
+                    groupId: emb.groupId ? String(emb.groupId) : undefined,
+                };
+            }
+        }
+        catch { /* 配置读取失败 → none */ }
+        return { provider: 'none' };
+    };
+    ctx.tools.set('memory_save', {
+        name: 'memory_save',
+        description: '保存一条**结构化长期记忆** (事实/偏好/洞察/事件/关系/技能反馈)。用于: 用户明确说"记住 X"、反复出现的偏好、值得跨会话保留的事实。自动去重 (同内容不重复), 自动打分重要性。',
+        parameters: {
+            content: '记忆内容 (必填, ≥2 字符)',
+            kind: '类型: fact | insight | preference | event | relationship | skill-feedback (默认 fact)',
+            importance: '手动重要性 0-1 (可选, 缺省自动启发式打分)',
+            refs: '关联证据 JSON 数组 (可选, 如 goalId/runId)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                // P1: 有 embedding adapter 时 save 顺便向量化 (存 vec, 供语义召回)
+                let adapter;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const a = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (a.provider !== 'none')
+                        adapter = a;
+                }
+                catch { /* 无向量能力 → 只存文本 */ }
+                const entry = await store.save({
+                    content: String(args.content || '').trim(),
+                    kind: args.kind || 'fact',
+                    importance: args.importance !== undefined ? Number(args.importance) : undefined,
+                    refs: Array.isArray(args.refs) ? args.refs.map(String) : undefined,
+                    source: 'tool',
+                }, adapter);
+                // P3: 条目级 OrbitDB 同步 (失败静默 — 本地记忆仍权威)
+                try {
+                    const { syncMemoryEntryToOrbit } = await import('../orbitdb/memory-sync.js');
+                    await syncMemoryEntryToOrbit(entry);
+                }
+                catch { /* 同步失败不阻塞保存 */ }
+                return { success: true, output: `✅ 已保存记忆 #${entry.id.slice(0, 8)} (${entry.kind}, 重要性 ${entry.importance.toFixed(2)})` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_save 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_recall', {
+        name: 'memory_recall',
+        description: '按查询关键词**召回长期记忆** (事实/偏好/洞察)。每轮对话已自动做记忆召回, 这里用于显式深挖: 用户说"你还记得我之前说的 X"、或当前任务需要历史上下文时调用。',
+        parameters: {
+            query: '查询内容 (必填, 用关键词)',
+            limit: '返回条数 (默认 3)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore, formatRecallBlock } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                // P3: 召回前先拉远端条目合并 (LWW, updatedAt 大者胜; 网络不可用静默)
+                try {
+                    const { fetchRemoteEntries } = await import('../orbitdb/memory-sync.js');
+                    const remote = await fetchRemoteEntries(memoryAgentId());
+                    if (remote.length > 0)
+                        await store.mergeRemote(remote);
+                }
+                catch { /* 远端拉取失败 → 只用本地 */ }
+                const query = String(args.query || '');
+                // P1: 有 embedding adapter 时走向量召回; 无 → 关键词回退 (P0 行为不变)
+                let queryVec;
+                try {
+                    const { createEmbeddingAdapter } = await import('../llm/embedding-adapter.js');
+                    const adapter = createEmbeddingAdapter(getMemoryEmbeddingConfig());
+                    if (adapter.provider !== 'none' && query.trim()) {
+                        queryVec = await adapter.embed(query);
+                    }
+                }
+                catch { /* vector 不可用 → 关键词回退 */ }
+                const hits = await store.recall({
+                    query,
+                    limit: args.limit ? Number(args.limit) : 3,
+                    queryVec,
+                });
+                if (!hits.length)
+                    return { success: true, output: '📭 没有找到相关记忆 (可能是新话题或记忆未保存)' };
+                return { success: true, output: formatRecallBlock(hits) };
+            }
+            catch (e) {
+                return { success: false, error: `memory_recall 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    // P2: 价值分层工具 — 固化 / 遗忘 / 统计 (2026-10-11, decentralized-memory-design §2.7)
+    ctx.tools.set('memory_crystallize', {
+        name: 'memory_crystallize',
+        description: '固化一条记忆 (crystallize): 标记为「重要, 不淡忘」+ importance 加成。用于: 用户明确说"这个要记住"、反复确认的重要约定、多次命中的核心事实。返回固化后的条目。',
+        parameters: {
+            entryId: '记忆 ID (从 memory_recall 的返回里拿, 形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const e = await store.crystallize(id);
+                if (!e)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `✅ 已固化记忆 #${e.id.slice(0, 8)} (${e.kind}, importance ${e.importance.toFixed(2)}, 不再淡忘)` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_crystallize 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_forget', {
+        name: 'memory_forget',
+        description: '删除一条记忆 (entryId 从 memory_recall 返回拿)。用于: 用户说"忘掉这个/删掉这条记忆"、记忆过时/错误。删除不可恢复。',
+        parameters: {
+            entryId: '记忆 ID (形如 #xxxxxxxx)',
+        },
+        execute: async (args) => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const id = String(args.entryId || '').replace(/^#/, '');
+                const ok = await store.remove(id);
+                if (!ok)
+                    return { success: false, error: `未找到记忆 #${id}` };
+                return { success: true, output: `🗑️ 已删除记忆 #${id.slice(0, 8)}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_forget 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
+    ctx.tools.set('memory_stats', {
+        name: 'memory_stats',
+        description: '查看记忆库统计: 总条数 / 已固化 / 已淡化 (decay)。用于: 用户问"我存了多少记忆"、诊断记忆衰减是否生效。',
+        parameters: {},
+        execute: async () => {
+            try {
+                const { getMemoryStore } = await import('./memory-store.js');
+                const store = getMemoryStore(memoryAgentId());
+                await store.load();
+                const s = store.stats();
+                return { success: true, output: `📊 记忆统计: 共 ${s.total} 条 · 已固化 ${s.crystallized} · 已淡化 ${s.decayed}` };
+            }
+            catch (e) {
+                return { success: false, error: `memory_stats 失败: ${String(e.message || e)}` };
+            }
+        }
+    });
     // 2026-07-28: 注册 LSP 工具 (代码智能)
     // registerBuiltinTools 不是 async, 用同步 import 兜底
     try {