@bolloon/bolloon-agent 0.4.21 → 0.4.23

package/dist/agents/gateway-join.js

@@ -0,0 +1,271 @@
+/**
+ * gateway-join.ts — 文档驱动的「加入全球智能体网络」编排 (2026-09-15)
+ *
+ * 背景: 手机端 / PC 端的人类入口只有一句话 —— `read https://bolloon.cn/bolloon-gateway-join.md`
+ * (默认 prompt, 见 src/web/mobile.js DEFAULT_JOIN_PROMPT)。文档本身是 SKILL.md 形状的入网说明,
+ * 但文档第 1-8 节写的是 SDK 伪码 (KeyManager / p2pNetwork.createNode / buildManifestRequest),
+ * 智能体手里只有工具, 照抄不了 → 需要一个工具把整条链路真正串起来。
+ *
+ * 本模块把「读文档 → 入网」收成一个可验证的闭环:
+ *   ① 读入网说明 (http(s), 校验 frontmatter 是 bolloon-gateway-join)
+ *   ② 确保 DID 身份
+ *   ③ 确保 P2P 节点 (拿 peerId)
+ *   ④ 注册本地 manifest (文档第 3 节 /api/agent/register 的等效物: setLocalManifest)
+ *   ⑤ 建成可分享的网络 (orbitdb registry 链接) + 登记到本机 Agent 服务注册表
+ *   ⑥ 落盘入网态 (幂等: 同 url 重复入网 → already)
+ *
+ * 诚实原则: 每一步都记 step.note; 拿不到的 (文档不可达 / 非入网说明 / 节点未就绪 / registry 离线)
+ * 一律如实报 ok=false 或 step.ok=false, 不假装入网成功。
+ */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+export const DEFAULT_GATEWAY_JOIN_DOC = 'https://bolloon.cn/bolloon-gateway-join.md';
+/** 入网说明文档的识别名 (frontmatter name) / 能力标记 */
+export const GATEWAY_JOIN_DOC_NAME = 'bolloon-gateway-join';
+export const GATEWAY_JOIN_CAPABILITY = 'gateway-join';
+const home = () => process.env.HOME || os.homedir() || '/tmp';
+const STATE_FILE = () => path.join(home(), '.bolloon', 'gateway-join.json');
+/** 极简 frontmatter 解析 (只认 name/version/capabilities 三个键, 够用且不引 yaml 依赖) */
+export function parseSkillFrontmatter(text) {
+    const raw = String(text || '');
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(raw);
+    if (!m)
+        return { body: raw };
+    const head = m[1];
+    const body = raw.slice(m[0].length);
+    const out = {};
+    for (const line of head.split(/\r?\n/)) {
+        const kv = /^([A-Za-z_][\w-]*)\s*:\s*(.*)$/.exec(line.trim());
+        if (!kv)
+            continue;
+        const key = kv[1].toLowerCase();
+        const val = kv[2].trim();
+        if (key === 'name')
+            out.name = val.replace(/^["']|["']$/g, '');
+        else if (key === 'version')
+            out.version = val.replace(/^["']|["']$/g, '');
+        else if (key === 'capabilities') {
+            out.capabilities = val.replace(/^\[|\]$/g, '').split(',').map((s) => s.trim().replace(/^["']|["']$/g, '')).filter(Boolean);
+        }
+    }
+    return { ...out, body };
+}
+/** 从文档文本判定「这是不是入网说明」 */
+export function isGatewayJoinDoc(text) {
+    const fm = parseSkillFrontmatter(text);
+    if (fm.name === GATEWAY_JOIN_DOC_NAME)
+        return true;
+    if (fm.capabilities?.includes(GATEWAY_JOIN_CAPABILITY))
+        return true;
+    // 没有 frontmatter 也允许 (纯正文版本): 标题 + 关键步骤同时出现才算
+    return /加入网关|加入 Bolloon|bolloon-gateway-join/.test(text) && /api\/agent\/register/.test(text);
+}
+export async function readGatewaySkillDoc(url, opts = {}) {
+    const u = String(url || '').trim();
+    if (!/^https?:\/\//i.test(u))
+        return { ok: false, url: u, error: `url 必须以 http(s):// 开头 (收到: ${u.slice(0, 60)})` };
+    let text = opts.text;
+    if (text === undefined) {
+        const f = opts.fetchImpl || fetch;
+        try {
+            const r = await f(u, { signal: AbortSignal.timeout(opts.timeoutMs ?? 15000) });
+            if (!r.ok)
+                return { ok: false, url: u, error: `文档不可达 (HTTP ${r.status})` };
+            text = await r.text();
+        }
+        catch (e) {
+            return { ok: false, url: u, error: `文档不可达: ${String(e?.message || e).slice(0, 140)}` };
+        }
+    }
+    const raw = String(text || '');
+    if (!raw.trim())
+        return { ok: false, url: u, error: '文档为空' };
+    const fm = parseSkillFrontmatter(raw);
+    if (!isGatewayJoinDoc(raw)) {
+        return { ok: false, url: u, name: fm.name, error: '这不是 Bolloon 网关入网说明 (缺 name: bolloon-gateway-join), 拒绝据此入网' };
+    }
+    return { ok: true, url: u, name: fm.name, version: fm.version, capabilities: fm.capabilities, body: fm.body };
+}
+export async function getGatewayJoinState() {
+    try {
+        const raw = fs.readFileSync(STATE_FILE(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeGatewayJoinState(state) {
+    try {
+        const f = STATE_FILE();
+        fs.mkdirSync(path.dirname(f), { recursive: true });
+        fs.writeFileSync(f, JSON.stringify(state, null, 2), { mode: 0o600 });
+    }
+    catch { /* 落盘失败不影响本次入网, 只影响幂等/重启恢复 */ }
+}
+/** 节点初始化并发去重 (同一进程内只起一次 libp2p 节点) */
+let nodeInitPromise = null;
+/**
+ * 确保本机 libp2p 节点在跑 (文档第 2 节 p2pNetwork.createNode 的等价物)。
+ * p2pNetwork.createNode 不是幂等的, 所以先用 getNodePeerId() 探测 + 单飞 promise 兜住并发。
+ */
+export async function ensureGatewayNode(deps = {}) {
+    if (deps.peerId)
+        return { ok: true, peerId: deps.peerId, started: false };
+    try {
+        const { p2pNetwork } = await import('../network/p2p.js');
+        const existing = String(p2pNetwork.getNodePeerId?.() || '');
+        if (existing)
+            return { ok: true, peerId: existing, multiaddrs: p2pNetwork.getWsMultiaddrs?.() || [], started: false };
+        if (!nodeInitPromise) {
+            const timeoutMs = deps.nodeTimeoutMs ?? 25_000;
+            nodeInitPromise = (async () => {
+                try {
+                    const info = await Promise.race([
+                        p2pNetwork.createNode({
+                            enableRelay: true,
+                            enableRelayServer: true,
+                            enableAutoNat: deps.enableAutoNat ?? false,
+                            enableUPnP: deps.enableUPnP ?? false,
+                        }),
+                        new Promise((_, rej) => setTimeout(() => rej(new Error(`节点初始化超时 (${timeoutMs}ms)`)), timeoutMs)),
+                    ]);
+                    const peerId = String(info?.peerId || p2pNetwork.getNodePeerId?.() || '');
+                    return peerId
+                        ? { ok: true, peerId, multiaddrs: (info?.multiaddrs || []) }
+                        : { ok: false, error: '节点起来了但拿不到 peerId' };
+                }
+                catch (e) {
+                    return { ok: false, error: String(e?.message || e).slice(0, 160) };
+                }
+                finally {
+                    // 失败也允许下次重试 (成功时后续调用被 getNodePeerId 分支短路)
+                    setTimeout(() => { nodeInitPromise = null; }, 1000);
+                }
+            })();
+        }
+        const r = await nodeInitPromise;
+        return { ...r, started: !!r.ok };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e).slice(0, 160) };
+    }
+}
+function readUserDid() {
+    try {
+        const f = path.join(home(), '.bolloon', 'identity', 'user.json');
+        const parsed = JSON.parse(fs.readFileSync(f, 'utf-8'));
+        return String(parsed?.did || '');
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * 文档驱动入网: 读说明 → DID → 节点 → manifest → 建网 → 落盘。
+ * 核心三步 (文档/DID/manifest) 任一失败 → ok=false; 网络/服务登记失败只记 note (部分成功不谎报)。
+ */
+export async function joinGlobalGateway(opts = {}) {
+    const url = String(opts.url || DEFAULT_GATEWAY_JOIN_DOC).trim();
+    const deps = opts.deps || {};
+    const steps = [];
+    // 幂等: 已经按同一文档入过网 → already (不重复建, 但仍返回既有信息)
+    const prev = await getGatewayJoinState();
+    if (prev && prev.url === url && prev.did && !opts.force) {
+        return {
+            ok: true, already: true, url, did: prev.did, peerId: prev.peerId,
+            networkLink: prev.networkLink, networkId: prev.networkId,
+            steps: [{ step: '幂等', ok: true, note: `已于 ${prev.joinedAt} 入网 (${prev.did.slice(0, 24)}…)` }],
+        };
+    }
+    // ① 读入网说明
+    const doc = await readGatewaySkillDoc(url, { fetchImpl: deps.fetchImpl, text: deps.docText });
+    steps.push({ step: '读入网说明', ok: doc.ok, note: doc.ok ? `${doc.name || 'doc'} v${doc.version || '?'} (${(doc.body || '').length} 字符)` : (doc.error || '') });
+    if (!doc.ok)
+        return { ok: false, url, error: doc.error, steps };
+    // ② DID 身份
+    const did = String(opts.did || deps.did || readUserDid() || '');
+    steps.push({ step: 'DID 身份', ok: !!did, note: did ? `${did.slice(0, 30)}…` : '本机无 DID (先运行 bolloon 让 server 生成 ~/.bolloon/identity/user.json)' });
+    if (!did)
+        return { ok: false, url, error: '缺少 DID 身份, 无法入网', steps };
+    const name = String(opts.name || 'bolloon-agent');
+    // ③ P2P 节点 (文档第 2 节: p2pNetwork.createNode) — 起不来的话如实在 note 里说
+    const node = await ensureGatewayNode(deps);
+    const peerId = String(node.peerId || '');
+    const multiaddrs = node.multiaddrs || [];
+    steps.push({
+        step: 'P2P 节点',
+        ok: !!peerId,
+        note: peerId ? `peerId=${peerId.slice(0, 16)}…${node.started ? ' (本次启动)' : ' (已在跑)'}` : `节点未就绪: ${node.error || '未知原因'}`,
+    });
+    // ③b 登记节点端点 + 广播地址 (文档第 2/7 节) — 非致命
+    if (peerId) {
+        try {
+            const { initializeAgentNetwork, broadcastOwnAddress } = await import('../network/agent-network.js');
+            await initializeAgentNetwork(did, name, peerId, multiaddrs);
+            await broadcastOwnAddress().catch(() => { });
+            steps.push({ step: '登记节点端点 + 广播地址', ok: true, note: `multiaddrs=${multiaddrs.length} 条` });
+        }
+        catch (e) {
+            steps.push({ step: '登记节点端点 + 广播地址', ok: false, note: `失败: ${String(e?.message || e).slice(0, 120)}` });
+        }
+    }
+    // ④ 注册本地 manifest (文档第 3 节)
+    const capabilities = (opts.capabilities && opts.capabilities.length ? opts.capabilities : ['chat', 'gateway-join']).map(String);
+    const entry = { id: `${name}-main`.replace(/\s+/g, '-'), name, capabilities, status: 'active', ...(peerId ? { peerId } : {}) };
+    let registered = false;
+    try {
+        if (deps.registerManifest) {
+            deps.registerManifest({ ownerName: name, ownerPublicKey: did, agents: [entry] });
+            registered = true;
+        }
+        else {
+            const { setLocalManifest, getLocalManifest } = await import('./agent-manifest-protocol.js');
+            setLocalManifest({ ownerName: name, ownerPublicKey: did, agents: [entry] });
+            registered = (getLocalManifest().agents || []).some((a) => a.id === entry.id);
+        }
+    }
+    catch (e) {
+        steps.push({ step: '注册 manifest', ok: false, note: `注册失败: ${String(e?.message || e).slice(0, 120)}` });
+        return { ok: false, url, did, error: 'manifest 注册失败', steps };
+    }
+    steps.push({ step: '注册 manifest', ok: registered, note: registered ? `agents=[${entry.id}] capabilities=[${capabilities.join(',')}]` : 'register 后读回为空' });
+    if (!registered)
+        return { ok: false, url, did, error: 'manifest 注册后读回为空', steps };
+    // ⑤ 建网 (可分享的 orbitdb 网络链接) — 离线/registry 未就绪时如实记 note
+    let networkLink;
+    let networkId;
+    try {
+        const share = deps.shareLink
+            ? await deps.shareLink({ name })
+            : await (await import('./gateway-network.js')).shareNetworkLink({ name });
+        if (share.ok && share.link) {
+            networkLink = share.link;
+            networkId = new URLSearchParams(share.link.split('?')[1] || '').get('name') || undefined;
+            steps.push({ step: '建成网络 (可分享链接)', ok: true, note: share.link.slice(0, 72) });
+        }
+        else {
+            steps.push({ step: '建成网络 (可分享链接)', ok: false, note: `未建成: ${share.error || 'registry 未就绪 (离线模式)'}` });
+        }
+    }
+    catch (e) {
+        steps.push({ step: '建成网络 (可分享链接)', ok: false, note: `异常: ${String(e?.message || e).slice(0, 120)}` });
+    }
+    // ⑥ 登记到本机 Agent 服务注册表 (让他方按能力发现/委派)
+    try {
+        const r = deps.registerService
+            ? await deps.registerService({ capability: capabilities[0], did, name })
+            : await (await import('./agent-gateway.js')).gatewayRegisterAgent({ capability: capabilities[0], description: `${name} 入网节点`, price: '0', per: 'task' }, { did, name, wallet: '' });
+        steps.push({ step: '服务登记 (可被发现)', ok: !!r?.ok, note: r?.ok ? '已写入本机 registry' : (r?.error || '未写入') });
+    }
+    catch (e) {
+        steps.push({ step: '服务登记 (可被发现)', ok: false, note: `异常: ${String(e?.message || e).slice(0, 120)}` });
+    }
+    // ⑦ 落盘入网态 (幂等 + 重启恢复)
+    writeGatewayJoinState({ url, did, name, capabilities, peerId: peerId || undefined, networkLink, networkId, joinedAt: new Date().toISOString() });
+    steps.push({ step: '落盘入网态', ok: (await getGatewayJoinState())?.url === url, note: STATE_FILE() });
+    return { ok: true, url, did, peerId: peerId || undefined, networkLink, networkId, docVersion: doc.version, steps };
+}
+export default { DEFAULT_GATEWAY_JOIN_DOC, readGatewaySkillDoc, isGatewayJoinDoc, parseSkillFrontmatter, joinGlobalGateway, getGatewayJoinState, writeGatewayJoinState };

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

@@ -1031,12 +1031,23 @@ export function registerBuiltinTools(ctx) {
     // 通用文件读取 (M4)
     ctx.tools.set('read_file', {
         name: 'read_file',
-        description: '读取任意文件内容 (相对 cwd). 只读操作, 无白名单限制.',
-        parameters: { path: '相对路径 (必填)', startLine: '起始行号 (可选, 默认 0)', maxLines: '最大行数 (可选, 默认 500)' },
+        description: '读取任意文件内容 (相对 cwd); 也支持 http(s) URL (如 "read https://…/doc.md" 这种口令 → 直接给 URL 即可). 只读操作, 无白名单限制.',
+        parameters: { path: '相对路径或 http(s) URL (必填)', startLine: '起始行号 (可选, 默认 0)', maxLines: '最大行数 (可选, 默认 500)' },
         execute: async (args) => {
             const relPath = String(args.path || '').trim();
             if (!relPath)
                 return { success: false, error: 'path 必填' };
+            // 2026-09-15: URL 直读 — 人类口令 "read <url>" 落到的就是本工具, 之前会 ENOENT (当成相对路径)
+            if (/^https?:\/\//i.test(relPath)) {
+                const r = await readUrlAsText(relPath);
+                if (!r.ok)
+                    return { success: false, error: `读取 URL 失败: ${r.error}` };
+                const start = Math.max(0, parseInt(String(args.startLine || '0')) || 0);
+                const max = parseInt(String(args.maxLines || '500')) || 500;
+                const lines = String(r.text || '').split('\n');
+                const slice = lines.slice(start, start + max);
+                return { success: true, output: `🌐 ${relPath} (第 ${start + 1}-${start + slice.length} 行, 共 ${lines.length} 行):\n${slice.map((l, i) => `${String(start + i + 1).padStart(4)} | ${l}`).join('\n')}` };
+            }
             try {
                 const absPath = path.resolve(ctx.cwd, relPath);
                 const content = fsSync.readFileSync(absPath, 'utf-8');
@@ -1175,6 +1186,25 @@ export function registerBuiltinTools(ctx) {
     // Web 上网工具 (2026-08-04) — fetch_url + web_search
     // 用 undici request (独立连接池, 与 pi-ai 一致, 避开全局 fetch 僵尸连接问题)
     // ============================================================
+    /** 读一个 http(s) URL 的正文 (curl, 兼容 TLS 指纹风控). read_file 的 URL 分支复用. 函数声明提升, 上面可调用. */
+    async function readUrlAsText(url, maxChars = 60_000) {
+        try {
+            const { execFile } = await import('child_process');
+            const { promisify } = await import('util');
+            const pExecFile = promisify(execFile);
+            const { stdout, stderr } = await pExecFile('curl', [
+                '-sL', '--max-time', '25',
+                '-A', 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36',
+                url,
+            ], { maxBuffer: 4 * 1024 * 1024, timeout: 30_000 });
+            if (!stdout)
+                return { ok: false, error: String(stderr || '空响应').slice(0, 200) };
+            return { ok: true, text: String(stdout).slice(0, maxChars) };
+        }
+        catch (e) {
+            return { ok: false, error: String(e?.message || e).slice(0, 200) };
+        }
+    }
     ctx.tools.set('fetch_url', {
         name: 'fetch_url',
         description: '抓取一个 URL 的网页内容并转成纯文本. 适合查文档/新闻/API 页面. 返回前 4000 字符. HTML 自动去标签, JSON/文本原样返回. (走 curl, 兼容 TLS 指纹风控)',
@@ -2835,6 +2865,10 @@ export function registerBuiltinTools(ctx) {
             const link = String(args.link || '').trim();
             if (!link)
                 return { success: false, error: 'link 必填 (ipns:// / orbitdb:// / https://)' };
+            // 2026-09-15: 入网说明文档 (.md) 不是 registry 链接 — 别静默当 registry 拉, 指到正确工具
+            if (/^https?:\/\//i.test(link) && (/\.md(\?|#|$)/i.test(link) || /gateway-join/i.test(link))) {
+                return { success: false, error: `这是一个「入网说明文档」而不是网络链接。请改用 join_global_gateway (url=${link}) 走文档驱动入网。` };
+            }
             try {
                 const { joinNetwork } = await import('./gateway-network.js');
                 const r = await joinNetwork(link);
@@ -2847,6 +2881,45 @@ export function registerBuiltinTools(ctx) {
             }
         },
     });
+    // ============================================================
+    // join_global_gateway (2026-09-15) — 文档驱动的「加入全球智能体网络」
+    // 人类口令只有一句: `read https://bolloon.cn/bolloon-gateway-join.md`
+    // 文档写的是 SDK 伪码, agent 手里只有工具 → 本工具把整条链路串成闭环:
+    // 读说明 → DID → P2P 节点 → 注册 manifest → 建成可分享网络 → 服务登记 → 落盘(幂等)
+    // ============================================================
+    ctx.tools.set('join_global_gateway', {
+        name: 'join_global_gateway',
+        description: '按「入网说明文档」加入全球智能体网络 (完整闭环: 读文档 → DID 身份 → P2P 节点 → 注册本地 manifest → 建成可分享的网络 → 服务登记 → 落盘). 默认文档即 https://bolloon.cn/bolloon-gateway-join.md (人类口令 "read <该文档>" 时用本工具)。幂等: 重复入网返回 already。文档不可达或不是入网说明 → 如实失败, 不假装入网。',
+        parameters: {
+            url: '入网说明文档 URL (可选, 默认 https://bolloon.cn/bolloon-gateway-join.md)',
+            name: '本智能体名字 (可选, 默认取当前身份名)',
+            capabilities: '声明能力, 逗号分隔 (可选, 默认 chat,gateway-join)',
+            force: 'true = 忽略幂等重新入网 (可选)',
+        },
+        execute: async (args) => {
+            try {
+                const { joinGlobalGateway } = await import('./gateway-join.js');
+                const caps = String(args.capabilities || '').split(',').map((s) => s.trim()).filter(Boolean);
+                const r = await joinGlobalGateway({
+                    url: String(args.url || '').trim() || undefined,
+                    did: ctx.identity?.did || undefined,
+                    name: String(args.name || '').trim() || ctx.identity?.name || undefined,
+                    capabilities: caps.length ? caps : undefined,
+                    force: String(args.force || '') === 'true',
+                });
+                const lines = r.steps.map((s) => `${s.ok ? '✓' : '✗'} ${s.step}: ${s.note}`);
+                if (!r.ok)
+                    return { success: false, error: `${r.error}\n${lines.join('\n')}` };
+                return {
+                    success: true,
+                    output: `🌐 已加入全球智能体网络${r.already ? ' (已在网, 幂等)' : ''}\nDID: ${r.did}\npeerId: ${r.peerId || '(节点后台启动中)'}${r.networkLink ? `\n可分享网络链接: ${r.networkLink}` : ''}\n${lines.join('\n')}`,
+                };
+            }
+            catch (e) {
+                return { success: false, error: `join_global_gateway 失败: ${String(e?.message || e).slice(0, 200)}` };
+            }
+        },
+    });
     ctx.tools.set('gateway_status', {
         name: 'gateway_status',
         description: '查看 Agent 网络状态 (已注册服务 + 信誉 + 已加入的网络).',

package/dist/agents/pi-sdk.js

@@ -1473,6 +1473,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     role: 'assistant',
                     content: reply,
                     toolCalls: toolCalls.length > 1 ? toolCalls : [toolCalls[0]],
+                    // 2026-09-15: 思考模式思维链原样存回 (下一轮带 tools 的请求必须回带, 否则 deepseek 400)
+                    reasoningContent: response?.reasoningContent,
                 });
                 // 2026-08-09: 并发执行本轮所有工具 (Hermes 式 Agent Runtime: 一轮内多工具并行,
                 //   一轮没跑完之前不中断 — 工具执行不检查 abort, 全部完成才 continue 下一轮)
@@ -1747,7 +1749,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                 // LLM 返回的不是 tool call 格式
                 this.messageHistory.push({
                     role: 'assistant',
-                    content: reply
+                    content: reply,
+                    reasoningContent: response?.reasoningContent,
                 });
                 // 通知前端收到非工具调用回复 (2026-08-09: 完整内容, 不再截断 150)
                 if (onStream) {
@@ -1979,7 +1982,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                         continue;
                     }
                     if (r === 'assistant') {
-                        out.push({ role: 'assistant', content: (m.content || '').slice(0, 4000) });
+                        out.push({ role: 'assistant', content: (m.content || '').slice(0, 4000), reasoningContent: m.reasoningContent });
                         continue;
                     }
                     if (r === 'user') {
@@ -2001,7 +2004,7 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
                     continue;
                 }
                 if (r === 'assistant') {
-                    out.push({ role: 'assistant', content: m.content || '' });
+                    out.push({ role: 'assistant', content: m.content || '', reasoningContent: m.reasoningContent });
                     continue;
                 }
                 if (r === 'user') {

package/dist/llm/pi-ai.js

@@ -303,6 +303,28 @@ export class PiAIModel {
         };
         return modelMap[this.provider];
     }
+    /**
+     * 2026-09-15: 出网前把 messages 规整成 wire 形状.
+     *
+     * 背景 (真跑复现 + 逐项对照, 见 wiki log 2026-09-15): DeepSeek 思考模式 (deepseek-v4-*)
+     * 在**请求带 tools** 时, 任何 assistant 消息缺 `reasoning_content` 字段 →
+     * HTTP 400 "The `reasoning_content` in the thinking mode must be passed back to the API".
+     * 复现: 同一个 17 条消息的真实请求体, 不带 tools → 200; 带上 tools → 400;
+     *       给每条 assistant 补 `reasoning_content:""` → 带 tools 也 200。
+     * 表现: 多轮工具循环 (第 2 轮起) 直接断, 用户看到 "AI 服务调用失败"。
+     *
+     * 处置: 只对 deepseek 生效 (唯一实测过的 provider); 有原文用原文, 没有就补空串 —
+     *   空串已被官方接受, 且不改变语义 (思维链不是给模型看的历史内容)。
+     * 其他 provider 原样透传 (OpenAI 系对未知字段更敏感, 不做无证据的改动)。
+     */
+    prepareWireMessages(messages) {
+        const echoReasoning = this.provider === 'deepseek';
+        if (!echoReasoning)
+            return messages;
+        return messages.map((m) => m.role === 'assistant'
+            ? { role: 'assistant', content: m.content ?? '', reasoning_content: m.reasoningContent ?? '' }
+            : m);
+    }
     async callOpenAI(messages, temperature, maxTokens, signal, tools) {
         const apiKey = this.getApiKey();
         if (!apiKey) {
@@ -310,7 +332,7 @@ export class PiAIModel {
         }
         const requestBody = {
             model: this.mapModel(),
-            messages,
+            messages: this.prepareWireMessages(messages),
             temperature,
             max_tokens: maxTokens
         };
@@ -370,6 +392,15 @@ export class PiAIModel {
                 const errBody = await body.text().catch(() => '(no body)');
                 console.log(`[pi-ai DEBUG] OpenAI 错误 ${statusCode}: ${String(errBody).slice(0, 500)}`);
                 console.log(`[pi-ai DEBUG] 请求体: model=${requestBody.model}, messages=${requestBody.messages?.length}, max_tokens=${requestBody.max_tokens}, baseUrl=${this.getBaseUrl()}`);
+                if (process.env.BOLLOON_DUMP_BODY === '1') {
+                    try {
+                        const fsx = await import('fs');
+                        const p = `/tmp/bolloon-req-${Date.now()}.json`;
+                        fsx.writeFileSync(p, JSON.stringify(requestBody, null, 2));
+                        console.log(`[pi-ai DEBUG] 失败请求体已落盘: ${p}`);
+                    }
+                    catch { /* 调试用, 失败忽略 */ }
+                }
                 retryAgent?.destroy().catch(() => { });
                 throw new Error(`OpenAI API error: ${statusCode} ${String(errBody).slice(0, 300)}`);
             }
@@ -378,6 +409,8 @@ export class PiAIModel {
             const choice = data.choices?.[0];
             const content = choice?.message?.content || '';
             const toolCalls = choice?.message?.tool_calls;
+            // 2026-09-15: 思考模式思维链 — 原样存回 history, 下一轮必须回带 (见 prepareWireMessages)
+            const reasoningContent = choice?.message?.reasoning_content || undefined;
             lastFinishReason = choice?.finish_reason || '';
             // Bug 7: tool_calls 存在时不走重试 — LLM 选工具时 content 空是合法的
             if (content || (toolCalls && toolCalls.length > 0)) {
@@ -388,7 +421,7 @@ export class PiAIModel {
                 const promptBytes = JSON.stringify(messages).length;
                 console.log(`[pi-ai timing] total=${_tAfter - _t0}ms attempt=${attempt + 1} fetch=${_tResp - _tFetch}ms parse=${_tParse - _tResp}ms reply=${content.length}B toolCalls=${toolCalls?.length ?? 0} model=${this.mapModel()} prompt=${promptBytes}B`);
                 retryAgent?.destroy().catch(() => { });
-                return { reply: content, toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined };
+                return { reply: content, toolCalls: toolCalls && toolCalls.length > 0 ? toolCalls : undefined, reasoningContent };
             }
             console.warn(`[pi-ai] attempt ${attempt + 1}/3: 空 content (finish_reason=${lastFinishReason}), 退避 1.5s 重试`);
             const _tSleep = Date.now();

package/dist/network/agent-network.js

@@ -10,6 +10,33 @@ const RELAY_RETRY_INTERVAL = 30000;
 const MAX_RELAY_HOPS = 3;
 const MESSAGE_TIMESTAMP_TOLERANCE = 24 * 60 * 60 * 1000;
 const SIGNED_MESSAGE_TYPES = ['task', 'response', 'discovery', 'address_broadcast'];
+/**
+ * 2026-09-15: did:key:z6Mk… 与 Ed25519 公钥字节是否一致。
+ *
+ * DID 由公钥派生 (did:key 规范: multibase base58btc of 0xed01 || rawKey), 所以首次接触时
+ * 自携公钥**无法伪造**: 冒充者换了公钥就解码不出同一个 DID。
+ * 返回: true 一致 / false 不一致 (疑似冒充) / null 非 did:key 形态 (无法判定, 不阻断, 交给签名验证)。
+ */
+export async function didKeyMatchesPublicKey(did, publicKeyHex) {
+    if (!/^did:key:z/.test(did))
+        return null;
+    try {
+        const { base58btc } = await import('multiformats/bases/base58');
+        const decoded = base58btc.decode(did.slice('did:key:'.length));
+        // 34 字节 = 2 字节 multicodec 前缀 (0xed01 = ed25519-pub) + 32 字节公钥
+        if (decoded.length !== 34)
+            return false;
+        if (decoded[0] !== 0xed || decoded[1] !== 0x01)
+            return false;
+        const claimed = Buffer.from(publicKeyHex, 'hex');
+        if (claimed.length !== 32)
+            return false;
+        return Buffer.compare(Buffer.from(decoded.slice(2)), claimed) === 0;
+    }
+    catch {
+        return null; // 解码失败 → 不判定 (不当成冒充, 也不放行: 签名仍要过)
+    }
+}
 export class AgentRegistry {
     agents = new Map();
     registryPath;
@@ -192,6 +219,7 @@ export class AgentRegistry {
             return null;
         }
         const relayAddr = p2pNetwork.getRelayAddress?.() || null;
+        const ownPublicKeyHex = Buffer.from(this.keyPair.publicKey).toString('hex');
         const broadcastData = JSON.stringify({
             type: 'address_broadcast',
             from: this.keyPair.did,
@@ -200,6 +228,7 @@ export class AgentRegistry {
             multiaddrs: this.ownEndpoint.multiaddrs,
             relayAddr: relayAddr || undefined,
             canRelay: relayAddr ? true : false,
+            publicKey: ownPublicKeyHex,
             timestamp: now
         });
         const signature = await this.signMessage(broadcastData);
@@ -213,6 +242,7 @@ export class AgentRegistry {
             multiaddrs: this.ownEndpoint.multiaddrs,
             relayAddr: relayAddr || undefined,
             canRelay: relayAddr ? true : false,
+            publicKey: ownPublicKeyHex,
             timestamp: now,
             signature: Buffer.from(signature).toString('hex')
         };
@@ -237,10 +267,35 @@ export class AgentRegistry {
             multiaddrs: broadcast.multiaddrs,
             relayAddr: broadcast.relayAddr,
             canRelay: broadcast.canRelay,
+            publicKey: broadcast.publicKey,
             timestamp: broadcast.timestamp
         });
         const signature = Buffer.from(broadcast.signature, 'hex');
-        const isValid = await this.verifySignature(broadcast.from, broadcastData, signature);
+        const known = this.agents.get(broadcast.from);
+        // 2026-09-15: 首次接触 (全球化去中心网络里全是陌生人) —— 原来只认「registry 里已有的公钥」,
+        //   陌生人第一次广播必然验签失败 → 广播被丢弃 → 陌生人永远发现不了彼此 (入网文档 §7 的链路实际不通).
+        //   现在: 未知 DID 时用广播自带 publicKey 自证 (TOFU: 首次接触信任自携公钥);
+        //   did:key 额外做 DID↔公钥 派生一致性检查 (DID 本身就是公钥, 自携公钥无法伪造).
+        let verifyKeyHex = known?.publicKey || undefined;
+        if (!verifyKeyHex) {
+            const claimed = String(broadcast.publicKey || '');
+            if (!claimed) {
+                console.warn(`[Registry] Unknown agent ${broadcast.from.substring(0, 20)}… 且广播未携带 publicKey → 无法验证, 拒收`);
+                return false;
+            }
+            const binding = await didKeyMatchesPublicKey(broadcast.from, claimed);
+            if (binding === false) {
+                console.warn(`[Registry] did:key 与自带公钥不匹配 (疑似冒充) from=${broadcast.from.substring(0, 24)}… → 拒收`);
+                return false;
+            }
+            verifyKeyHex = claimed;
+        }
+        else if (broadcast.publicKey && broadcast.publicKey !== verifyKeyHex) {
+            // 已认识这个 DID, 却报出另一把公钥 → 身份接管尝试, 拒收 (不覆盖已存公钥)
+            console.warn(`[Registry] ${broadcast.from.substring(0, 20)}… 广播的公钥与已知公钥不一致 → 拒收 (不覆盖)`);
+            return false;
+        }
+        const isValid = await this.verifySignatureWithKey(broadcast.from, verifyKeyHex, broadcastData, signature);
         if (!isValid) {
             console.warn(`[Registry] Invalid broadcast signature from ${broadcast.from.substring(0, 20)}`);
             return false;
@@ -253,7 +308,9 @@ export class AgentRegistry {
             registeredAt: Date.now(),
             lastSeen: broadcast.timestamp,
             lastBroadcast: 0,
-            publicKey: Buffer.from(this.keyPair.publicKey).toString('hex'),
+            // 2026-09-15 修复: 原来写的是**自己**的公钥 (this.keyPair.publicKey) →
+            //   对端后续任何签名消息都验不过 (拿我方公钥去验对方签名), 属于把对端身份写坏.
+            publicKey: verifyKeyHex,
             relayAddr: broadcast.relayAddr,
             canRelay: broadcast.canRelay
         };
@@ -261,15 +318,30 @@ export class AgentRegistry {
         if (existing) {
             entry.registeredAt = existing.registeredAt;
             entry.lastBroadcast = existing.lastBroadcast;
-            if (!existing.publicKey) {
-                existing.publicKey = entry.publicKey;
-            }
+            if (existing.publicKey)
+                entry.publicKey = existing.publicKey; // 已有公钥永不覆盖
         }
         this.agents.set(broadcast.from, entry);
         this.saveRegistry();
-        console.log(`[Registry] Verified broadcast from: ${broadcast.name} (${broadcast.from.substring(0, 20)}...) ${broadcast.canRelay ? '[Relay Capable]' : ''}`);
+        console.log(`[Registry] Verified broadcast from: ${broadcast.name} (${broadcast.from.substring(0, 20)}...) ${broadcast.canRelay ? '[Relay Capable]' : ''}${known ? '' : ' [首次接触 TOFU]'}`);
         return true;
     }
+    /** 用给定公钥 (hex) 验签 — 首次接触路径用 (未知 DID 时 registry 里没公钥) */
+    async verifySignatureWithKey(did, publicKeyHex, data, signature) {
+        try {
+            const publicKey = Buffer.from(publicKeyHex, 'hex');
+            if (publicKey.length !== 32) {
+                console.warn(`[Registry] publicKey 长度非法 (${publicKey.length} 字节, 期望 32): ${did.substring(0, 20)}…`);
+                return false;
+            }
+            const keyPair = { privateKey: new Uint8Array(32), publicKey, did };
+            return await KeyManager.verify(keyPair, new TextEncoder().encode(data), signature);
+        }
+        catch (e) {
+            console.warn(`[Registry] Verification with provided key failed:`, e);
+            return false;
+        }
+    }
     async createSignedMessage(type, payload) {
         if (!this.keyPair || !this.ownEndpoint)
             return null;