@bolloon/bolloon-agent 0.1.12 → 0.1.13

package/dist/agents/p2p-chat-tools.js

@@ -0,0 +1,321 @@
+/**
+ * p2p-chat-tools — 异步 chat 通道 + 持久化 inbox + 判断力外包 (draft)
+ *
+ * 解决痛点: 两个节点的智能体代替各自人类主人做异步判断
+ *
+ * 流程:
+ *   1. A 节点 (人类在线) 通过 sendChat(peerDID, text) 发消息 → iroh 'agent_chat'
+ *   2. B 节点 (人类可能离线):
+ *        - onMessage('agent_chat') → 落 ~/.bolloon/inbox/<peerDID>.jsonl
+ *        - 状态 = 'received' (未处理)
+ *   3. B 节点 wake-up (processPendingInbox) → 扫描 status='received' 的消息
+ *        - 调 LLM 生成 draft (注入主人历史判断 + ValueProfile)
+ *        - 写 status='drafted', draft 落盘
+ *        - 通过 'agent_chat' 消息类型回送 draft (前缀 [DRAFT] 表明是代回)
+ *   4. A 节点收到 draft → 写到 A 的 outbox (inbox 中 from=B 的那条)
+ *   5. B 人类上线 → getInbox() 看到 'drafted' 状态的条目, approveAndSend / dismissDraft
+ *
+ * 镜像 p2p-document-tools.ts 风格: iroh 消息 + 可注入 transport (支持多实例测试)
+ */
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { EventEmitter } from 'events';
+import { irohTransport as defaultIrohTransport } from '../network/iroh-transport.js';
+import { getRelevantValues, getValueProfile, loadAllJudgments } from '../pi-ecosystem-judgment/human-value-store.js';
+function homeDir() {
+    return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+class ChatEventBus extends EventEmitter {
+}
+export const chatEventBus = new ChatEventBus();
+const states = new WeakMap();
+function getState(transport) {
+    let s = states.get(transport);
+    if (!s) {
+        s = { handlers: new Set(), listenerInstalled: false };
+        states.set(transport, s);
+    }
+    return s;
+}
+// ============================================================================
+// Inbox 存储
+// ============================================================================
+function inboxDir() {
+    return path.join(homeDir(), '.bolloon', 'inbox');
+}
+function inboxPath(peerDID) {
+    const safe = peerDID.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(inboxDir(), `${safe}.jsonl`);
+}
+function outboxPath() {
+    return path.join(inboxDir(), '_outbox.jsonl');
+}
+async function appendInbox(peerDID, entry) {
+    await fs.mkdir(inboxDir(), { recursive: true });
+    await fs.appendFile(inboxPath(peerDID), JSON.stringify(entry) + '\n', 'utf-8');
+}
+async function readInbox(peerDID) {
+    try {
+        const content = await fs.readFile(inboxPath(peerDID), 'utf-8');
+        return content.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+    }
+    catch {
+        return [];
+    }
+}
+async function rewriteInbox(peerDID, entries) {
+    await fs.mkdir(inboxDir(), { recursive: true });
+    await fs.writeFile(inboxPath(peerDID), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+}
+async function updateInboxEntry(peerDID, id, patch) {
+    const entries = await readInbox(peerDID);
+    const idx = entries.findIndex((e) => e.id === id);
+    if (idx < 0)
+        return null;
+    entries[idx] = { ...entries[idx], ...patch };
+    await rewriteInbox(peerDID, entries);
+    return entries[idx];
+}
+async function markOutboundDraft(originalId, draft, at) {
+    try {
+        const content = await fs.readFile(outboxPath(), 'utf-8');
+        const entries = content.split('\n').filter((l) => l.trim()).map((l) => JSON.parse(l));
+        const idx = entries.findIndex((e) => e.id === originalId);
+        if (idx >= 0) {
+            entries[idx].inboundDraft = draft;
+            entries[idx].inboundDraftAt = at;
+            await fs.writeFile(outboxPath(), entries.map((e) => JSON.stringify(e)).join('\n') + '\n', 'utf-8');
+        }
+    }
+    catch { /* no outbox */ }
+}
+// ============================================================================
+// Listener 安装 (每个 transport 各装一次)
+// ============================================================================
+function ensureListener(transport) {
+    const s = getState(transport);
+    if (s.listenerInstalled)
+        return;
+    s.listenerInstalled = true;
+    transport.onMessage('agent_chat', (msg) => {
+        try {
+            const data = JSON.parse(new TextDecoder().decode(msg.payload));
+            void handleIncomingChat(transport, msg.from, data);
+        }
+        catch (e) {
+            console.error('[ChatReceiver] parse err:', e.message);
+        }
+    });
+}
+async function handleIncomingChat(transport, fromNodeId, data) {
+    const peerDID = fromNodeId;
+    if (data.kind === 'user') {
+        const entry = {
+            id: data.id, peerDID, fromNodeId, text: data.text,
+            timestamp: Date.now(), receivedAt: Date.now(), status: 'received',
+        };
+        await appendInbox(peerDID, entry);
+        const preview = data.text.slice(0, 60);
+        const peerShort = peerDID.slice(0, 12);
+        console.log('[ChatReceiver] received from ' + peerShort + ': ' + preview);
+        chatEventBus.emit('chat', { kind: 'inbox_new', peerDID, entry });
+        for (const h of getState(transport).handlers) {
+            try {
+                h(entry, fromNodeId);
+            }
+            catch { }
+        }
+    }
+    else if (data.kind === 'draft' && data.originalId) {
+        await markOutboundDraft(data.originalId, data.text, Date.now());
+        console.log('[ChatReceiver] inbound draft for ' + data.originalId);
+        chatEventBus.emit('chat', { kind: 'outbox_draft_in', peerDID, originalId: data.originalId, draft: data.text });
+    }
+}
+// ============================================================================
+// 公共 API (可注入 transport)
+// ============================================================================
+export function onChatMessage(handler, transport = defaultIrohTransport) {
+    getState(transport).handlers.add(handler);
+    ensureListener(transport);
+}
+export async function initChatReceiver(transport = defaultIrohTransport) {
+    ensureListener(transport);
+    await fs.mkdir(inboxDir(), { recursive: true });
+    console.log('[ChatReceiver] Initialized at', inboxDir(), 'transport=', transport === defaultIrohTransport ? 'singleton' : 'instance');
+}
+export async function sendChat(peerDID, text, transport = defaultIrohTransport) {
+    const id = crypto.randomUUID();
+    const ok = await transport.sendMessage(peerDID, 'agent_chat', new TextEncoder().encode(JSON.stringify({ kind: 'user', id, text })));
+    if (ok) {
+        const entry = {
+            id, peerDID,
+            fromNodeId: transport.getNodeId() || '',
+            text, timestamp: Date.now(), receivedAt: Date.now(),
+            status: 'sent', sentText: text, sentAt: Date.now(),
+        };
+        await fs.mkdir(inboxDir(), { recursive: true });
+        await fs.appendFile(outboxPath(), JSON.stringify(entry) + '\n', 'utf-8');
+        chatEventBus.emit('chat', { kind: 'outbox_updated', peerDID, entry });
+    }
+    else {
+        console.warn(`[ChatReceiver] send to ${peerDID.slice(0, 12)}... failed`);
+    }
+    return id;
+}
+export async function getInbox(peerDID) {
+    if (peerDID)
+        return readInbox(peerDID);
+    try {
+        const files = await fs.readdir(inboxDir());
+        const all = [];
+        for (const f of files) {
+            if (!f.endsWith('.jsonl') || f.startsWith('_'))
+                continue;
+            const peerDID = f.replace('.jsonl', '').replace(/_/g, ':');
+            all.push(...await readInbox(peerDID));
+        }
+        return all.sort((a, b) => b.receivedAt - a.receivedAt);
+    }
+    catch {
+        return [];
+    }
+}
+// ============================================================================
+// Draft 引擎
+// ============================================================================
+async function buildValueHint(text) {
+    try {
+        const allJudgments = await loadAllJudgments();
+        const relevant = await getRelevantValues(text, undefined);
+        const profile = await getValueProfile('me');
+        const profileHint = [
+            `quality_focus=${profile.quality_focus.toFixed(2)}`,
+            `efficiency_focus=${profile.efficiency_focus.toFixed(2)}`,
+            `safety_focus=${profile.safety_focus.toFixed(2)}`,
+            `collaboration_focus=${profile.collaboration_focus.toFixed(2)}`,
+            `learning_focus=${profile.learning_focus.toFixed(2)}`,
+        ].join(', ');
+        const reasons = allJudgments
+            .filter((j) => (j.reasons || []).length > 0)
+            .slice(-10)
+            .flatMap((j) => j.reasons || [])
+            .slice(0, 20);
+        return `\n[主人历史判断 (style 参考, 不可外泄)]\n关注维度: ${profileHint}\n关键理由示例: ${reasons.join(' | ').slice(0, 400) || '(无)'}\n`;
+    }
+    catch (e) {
+        return '';
+    }
+}
+export async function generateDraft(messageId, peerDID, transport = defaultIrohTransport) {
+    const entries = await readInbox(peerDID);
+    const entry = entries.find((e) => e.id === messageId);
+    if (!entry)
+        return null;
+    if (entry.status !== 'received')
+        return entry;
+    const valueHint = await buildValueHint(entry.text);
+    const promptForDraft = `你是主人的代理. 对方发来这条消息: "${entry.text.slice(0, 1500)}"\n${valueHint}\n请基于主人的历史判断, 用 1-2 句话代主人拟一个回复草案. 草案要保留主人的语气和立场, 开头标注 [DRAFT]. 直接给草案文本, 不要解释.`;
+    let draftText = '';
+    let confidence = 0.5;
+    try {
+        const openaiKey = process.env.OPENAI_API_KEY;
+        if (!openaiKey)
+            throw new Error('OPENAI_API_KEY not set');
+        const openaiBase = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
+        const openaiModel = process.env.OPENAI_MODEL || 'gpt-4';
+        const r = await fetch(`${openaiBase}/chat/completions`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${openaiKey}` },
+            body: JSON.stringify({
+                model: openaiModel,
+                messages: [
+                    { role: 'system', content: '你是主人的代理. 你的输出会被主人审阅后才发出. 请谨慎.' },
+                    { role: 'user', content: promptForDraft },
+                ],
+                temperature: 0.4,
+                max_tokens: 300,
+            }),
+            signal: AbortSignal.timeout(15000),
+        });
+        if (r.ok) {
+            const data = await r.json();
+            draftText = (data.choices?.[0]?.message?.content || '').trim();
+            confidence = 0.7;
+        }
+        else {
+            console.warn(`[DraftEngine] LLM ${r.status}`);
+        }
+    }
+    catch (e) {
+        console.warn(`[DraftEngine] LLM call failed: ${e.message}`);
+    }
+    if (!draftText) {
+        draftText = `[DRAFT] 已收到. (本地 draft 引擎未配置 LLM, 主人上线后请手写回复)`;
+        confidence = 0.1;
+    }
+    const updated = await updateInboxEntry(peerDID, messageId, {
+        status: 'drafted', draft: draftText, draftConfidence: confidence,
+        draftReasoning: valueHint.slice(0, 200), draftAt: Date.now(),
+    });
+    if (updated) {
+        const sent = await transport.sendMessage(peerDID, 'agent_chat', new TextEncoder().encode(JSON.stringify({ kind: 'draft', id: crypto.randomUUID(), text: draftText, originalId: messageId })));
+        if (sent)
+            console.log('[DraftEngine] draft sent to ' + peerDID.slice(0, 12) + ' for ' + messageId.slice(0, 8));
+        else
+            console.warn('[DraftEngine] failed to send draft');
+        chatEventBus.emit('chat', { kind: 'draft_ready', peerDID, entry: updated });
+        chatEventBus.emit('chat', { kind: 'outbox_updated', peerDID, entry: updated });
+    }
+    return updated;
+}
+export async function processPendingInbox(transport = defaultIrohTransport) {
+    await fs.mkdir(inboxDir(), { recursive: true });
+    const files = await fs.readdir(inboxDir());
+    let processed = 0, skipped = 0;
+    for (const f of files) {
+        if (!f.endsWith('.jsonl') || f.startsWith('_'))
+            continue;
+        const peerDID = f.replace('.jsonl', '').replace(/_/g, ':');
+        const entries = await readInbox(peerDID);
+        for (const e of entries) {
+            if (e.status === 'received') {
+                const r = await generateDraft(e.id, peerDID, transport);
+                if (r)
+                    processed++;
+                else
+                    skipped++;
+            }
+        }
+    }
+    return { processed, skipped };
+}
+export async function approveAndSend(messageId, peerDID, finalText, transport = defaultIrohTransport) {
+    const entries = await readInbox(peerDID);
+    const entry = entries.find((e) => e.id === messageId);
+    if (!entry || entry.status !== 'drafted')
+        return false;
+    const text = finalText || entry.draft || '';
+    const ok = await transport.sendMessage(peerDID, 'agent_chat', new TextEncoder().encode(JSON.stringify({ kind: 'user', id: crypto.randomUUID(), text })));
+    if (ok) {
+        const updated = await updateInboxEntry(peerDID, messageId, { status: 'sent', sentText: text, sentAt: Date.now() });
+        if (updated)
+            chatEventBus.emit('chat', { kind: 'inbox_sent', peerDID, entry: updated });
+    }
+    return ok;
+}
+export async function dismissDraft(messageId, peerDID) {
+    const entries = await readInbox(peerDID);
+    const entry = entries.find((e) => e.id === messageId);
+    if (!entry)
+        return false;
+    const updated = await updateInboxEntry(peerDID, messageId, { status: 'dismissed' });
+    if (updated)
+        chatEventBus.emit('chat', { kind: 'inbox_dismissed', peerDID, entry: updated });
+    return true;
+}
+export const p2pChatTools = {
+    sendChat, getInbox, processPendingInbox, generateDraft, approveAndSend, dismissDraft, onChatMessage, initChatReceiver,
+};

package/dist/agents/p2p-document-tools.js

@@ -3,6 +3,7 @@
  */
 import * as crypto from 'crypto';
 import * as fs from 'fs/promises';
+import * as path from 'path';
 import { irohTransport } from '../network/iroh-transport.js';
 import { documentReader } from '../documents/reader.js';
 import { documentStore } from '../documents/store.js';
@@ -15,6 +16,11 @@ function getMimeType(filename) {
     const mimeTypes = {
         'txt': 'text/plain',
         'md': 'text/markdown',
+        'html': 'text/html',
+        'htm': 'text/html',
+        'yaml': 'application/yaml',
+        'yml': 'application/yaml',
+        'json': 'application/json',
         'pdf': 'application/pdf',
         'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
     };
@@ -22,8 +28,10 @@ function getMimeType(filename) {
 }
 export async function initDocumentReceiver() {
     await documentStore.initialize();
-    documentStore.onDocumentReceived((doc) => {
+    documentStore.onDocumentReceived(async (doc) => {
         console.log(`[DocumentReceiver] Document received: ${doc.fileName} from ${doc.fromNodeIdShort}`);
+        // 异步调用 LLM 解析（不阻塞接收流程）
+        void parseDocumentWithLLM(doc);
     });
     irohTransport.onMessage('document_chunk', async (msg) => {
         try {
@@ -39,6 +47,118 @@ export async function initDocumentReceiver() {
     });
     console.log('[DocumentReceiver] Initialized and listening for document chunks');
 }
+const feedbackHandlers = new Set();
+/** 注册 AI 解析反馈监听器（发送方调用） */
+export function onAIFeedback(handler) {
+    feedbackHandlers.add(handler);
+    // iroh listener 只挂一次
+    ensureFeedbackListenerInstalled();
+}
+let feedbackListenerInstalled = false;
+function ensureFeedbackListenerInstalled() {
+    if (feedbackListenerInstalled)
+        return;
+    feedbackListenerInstalled = true;
+    irohTransport.onMessage('ai_feedback', (msg) => {
+        try {
+            const fb = JSON.parse(new TextDecoder().decode(msg.payload));
+            for (const h of feedbackHandlers) {
+                try {
+                    h(fb, msg.from);
+                }
+                catch (e) {
+                    console.error('[AIFeedback] handler error:', e);
+                }
+            }
+        }
+        catch (e) {
+            console.error('[AIFeedback] failed to parse message:', e);
+        }
+    });
+}
+/** 文档解析服务：优先走 web 统一入口 (含 judgment + harness), fallback 到本地 LLM */
+async function callAIParseService(text, fileName, mimeType, fromNodeId) {
+    // 1) 优先: 调 web 端 POST /api/ai-parse (统一入口, 含 judgment + harness)
+    const webBase = process.env.BOLLOON_WEB_URL || process.env.PORTAL_URL || 'http://127.0.0.1:54188';
+    try {
+        const r = await fetch(`${webBase}/api/ai-parse`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ text, mimeType, fileName, fromNodeId, source: 'p2p-document' }),
+            // 短超时, fallback 友好
+            signal: AbortSignal.timeout(8000),
+        });
+        if (r.ok) {
+            const data = await r.json();
+            return {
+                summary: data.summary,
+                qualityScore: data.qualityScore,
+                source: 'web',
+                judgmentId: data.judgmentId,
+                gateArtifact: data.gateArtifact,
+            };
+        }
+        console.warn(`[AIParse] web returned ${r.status}, fallback to local`);
+    }
+    catch (e) {
+        console.warn(`[AIParse] web ${webBase} unreachable (${e.message}), fallback to local`);
+    }
+    // 2) Fallback: 直接调本地 LLM (不调 judgment/harness, 仅在 web 不可用时使用)
+    const apiKey = process.env.OPENAI_API_KEY || process.env.ANTHROPIC_API_KEY || process.env.MINIMAX_API_KEY || process.env.OPENROUTER_API_KEY || process.env.GEMINI_API_KEY;
+    if (!apiKey) {
+        throw new Error('No web endpoint and no LLM API key configured. Set BOLLOON_WEB_URL or OPENAI_API_KEY.');
+    }
+    const { getMinimax } = await import('../constraints/index.js');
+    const llm = getMinimax();
+    const truncated = text.length > 6000 ? text.substring(0, 6000) + '...[截断]' : text;
+    const prompt = `请分析以下 ${mimeType} 文档，并给出 (1) 一句话中文摘要 (2) 关键要点列表 (3) 文档质量评分(0-1)。\n\n文件名: ${fileName}\n\n内容:\n${truncated}`;
+    const r = await llm.summarize(prompt);
+    return { summary: r.summary, qualityScore: r.qualityScore, source: 'local' };
+}
+async function parseDocumentWithLLM(doc) {
+    try {
+        const filePath = path.join(process.env.HOME || '/tmp', '.bolloon', 'documents', 'received', doc.id, doc.fileName);
+        const content = await fs.readFile(filePath, 'utf-8');
+        const r = await callAIParseService(content, doc.fileName, doc.mimeType, doc.fromNodeId);
+        const sidecar = {
+            filename: doc.fileName,
+            mimeType: doc.mimeType,
+            fromNodeId: doc.fromNodeId,
+            receivedAt: doc.receivedAt,
+            summary: r.summary,
+            qualityScore: r.qualityScore,
+            parseSource: r.source,
+            judgmentId: r.judgmentId,
+            gateArtifact: r.gateArtifact,
+            analyzedAt: Date.now(),
+        };
+        const sidecarPath = path.join(process.env.HOME || '/tmp', '.bolloon', 'documents', 'received', doc.id, 'ai-analysis.json');
+        await fs.writeFile(sidecarPath, JSON.stringify(sidecar, null, 2));
+        console.log(`[DocumentReceiver] AI parsed ${doc.fileName} via ${r.source} (score=${r.qualityScore.toFixed(2)})${r.judgmentId ? ` judgment=${r.judgmentId}` : ''}${r.gateArtifact ? ` gate=${r.gateArtifact}` : ''}`);
+        // 把 AI 解析结果回送给发送方 (doc.fromNodeId)，形成 "接收 → 解析 → 反馈" 闭环
+        if (doc.fromNodeId) {
+            const feedback = {
+                docId: doc.id,
+                fileName: doc.fileName,
+                mimeType: doc.mimeType,
+                summary: r.summary,
+                qualityScore: r.qualityScore,
+                feedbackAt: Date.now(),
+                fromNodeId: irohTransport.getNodeId() || '',
+            };
+            const sent = await irohTransport.sendMessage(doc.fromNodeId, 'ai_feedback', new TextEncoder().encode(JSON.stringify(feedback)));
+            if (sent) {
+                console.log(`[DocumentReceiver] Feedback sent to ${doc.fromNodeIdShort}`);
+            }
+            else {
+                console.warn(`[DocumentReceiver] Failed to send feedback to ${doc.fromNodeIdShort}`);
+            }
+        }
+    }
+    catch (e) {
+        console.error(`[DocumentReceiver] AI parse failed for ${doc.fileName}:`, e);
+    }
+}
 export const p2pDocumentTools = [
     {
         name: 'list_online_peers',

package/dist/agents/workflow-pivot-loop.js

@@ -220,7 +220,7 @@ export class WorkflowPivotLoop {
                         tool: toolCall.name
                     });
                     try {
-                        const result = await tool.execute(toolCall.args);
+                        const result = await tool.execute(toolCall.args ?? {});
                         this.emit({
                             type: result.success ? 'status' : 'error',
                             content: result.success
@@ -313,7 +313,7 @@ export class WorkflowPivotLoop {
             const argsStr = match[2];
             const args = this.parseArgs(argsStr);
             if (this.tools.has(name)) {
-                pending.push({ name, args });
+                pending.push({ name, args, description: '', parameters: {} });
             }
         }
         // Pattern 2: tool_name(args) format
@@ -327,7 +327,7 @@ export class WorkflowPivotLoop {
             if (!this.tools.has(name))
                 continue;
             const args = this.parseArgs(argsStr);
-            pending.push({ name, args });
+            pending.push({ name, args, description: '', parameters: {} });
         }
         // Pattern 3: JSON format tool calls
         try {
@@ -337,7 +337,7 @@ export class WorkflowPivotLoop {
                 if (Array.isArray(parsed.tool_calls)) {
                     for (const tc of parsed.tool_calls) {
                         if (this.tools.has(tc.name)) {
-                            pending.push({ name: tc.name, args: tc.args || {} });
+                            pending.push({ name: tc.name, args: tc.args || {}, description: '', parameters: {} });
                         }
                     }
                 }

package/dist/cli-entry.js

@@ -22,7 +22,7 @@ const YELLOW = '\x1b[33m';
 const GREEN = '\x1b[32m';
 const MAGENTA = '\x1b[35m';
 // 版本信息
-const VERSION = '0.1.11';
+const VERSION = '0.1.12';
 function log(msg, color = RESET) {
     console.log(`${color}${msg}${RESET}`);
 }

package/dist/documents/reader.js

@@ -11,6 +11,11 @@ export class DocumentReader {
         switch (ext) {
             case '.txt':
             case '.md':
+            case '.html':
+            case '.htm':
+            case '.yaml':
+            case '.yml':
+            case '.json':
                 text = await fs.readFile(filePath, 'utf-8');
                 break;
             case '.pdf':

package/dist/documents/store.js

@@ -139,10 +139,10 @@ export class DocumentStore {
     async readDocument(docId) {
         const docDir = path.join(this.baseDir, docId);
         const manifestPath = path.join(docDir, 'manifest.json');
-        const filePath = path.join(docDir);
         try {
             const manifestData = await fs.readFile(manifestPath, 'utf-8');
             const manifest = JSON.parse(manifestData);
+            const filePath = path.join(docDir, manifest.fileName);
             const fileContent = await fs.readFile(filePath, 'utf-8');
             return {
                 content: fileContent,

package/dist/llm/pi-ai.js

@@ -102,25 +102,26 @@ export class PiAIModel {
         if (this.config.baseUrl) {
             return this.config.baseUrl;
         }
+        // 允许通过 OPENAI_BASE_URL 等环境变量覆盖默认 base URL
         const baseUrls = {
-            openai: 'https://api.openai.com/v1',
+            openai: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
             anthropic: 'https://api.anthropic.com/v1',
             ollama: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
-            openrouter: 'https://openrouter.ai/api/v1',
+            openrouter: process.env.OPENROUTER_BASE_URL || 'https://openrouter.ai/api/v1',
             gemini: 'https://generativelanguage.googleapis.com/v1beta',
-            minimax: 'https://api.minimaxi.com/v1',
+            minimax: process.env.MINIMAX_BASE_URL || 'https://api.minimaxi.com/v1',
             local: 'http://localhost:11434'
         };
         return baseUrls[this.provider];
     }
     mapModel() {
         const modelMap = {
-            openai: this.config.model || 'gpt-4',
+            openai: this.config.model || process.env.OPENAI_MODEL || 'gpt-4',
             anthropic: this.config.model || 'claude-3-5-sonnet-20241022',
             ollama: this.config.model || 'llama3.2',
             openrouter: this.config.model || 'anthropic/claude-3.5-sonnet',
             gemini: this.config.model || 'gemini-2.0-flash',
-            minimax: this.config.model || 'MiniMax-M2.7',
+            minimax: this.config.model || process.env.MINIMAX_MODEL || 'MiniMax-M2.7',
             local: this.config.model || 'llama3.2'
         };
         return modelMap[this.provider];

package/dist/network/iroh-discovery.js

@@ -54,9 +54,10 @@ export class IrohDiscoveryService {
         }, this.config.refreshIntervalMs);
     }
     startDiscoveryLoop() {
+        const interval = this.config.discoveryIntervalMs ?? 30000;
         this.discoveryTimer = setInterval(async () => {
             await this.discoverPeers();
-        }, this.discoveryIntervalMs);
+        }, interval);
         setTimeout(() => this.discoverPeers(), 2000);
     }
     async discoverPeers() {

package/dist/network/iroh-transport.js

@@ -100,6 +100,9 @@ export class IrohTransport {
                     count += queue.length;
                 return count;
             },
+            async getAllOfflineTargets() {
+                return Array.from(offlineQueues.keys());
+            },
             async savePendingResponse(req) {
                 const id = crypto.randomUUID();
                 const pending = { ...req, id };
@@ -123,8 +126,13 @@ export class IrohTransport {
         if (!this.messageStore)
             return;
         this.offlineDeliveryInterval = setInterval(async () => {
+            // 遍历所有有离线消息的目标节点（不仅是"已连接"的）
+            // 这样目标节点一旦在线（accept 连接）就能拿到离线消息
+            const allTargets = await this.messageStore.getAllOfflineTargets();
             const connectedPeers = this.getConnectedPeers();
-            for (const peerId of connectedPeers) {
+            // 合并：已连接 + 有离线消息但未连接（也会去尝试 connect）
+            const targets = new Set([...connectedPeers, ...allTargets]);
+            for (const peerId of targets) {
                 const offlineMsgs = await this.messageStore.getOfflineMessages(peerId);
                 for (const msg of offlineMsgs) {
                     if (msg.retryCount >= 10) {
@@ -140,6 +148,9 @@ export class IrohTransport {
                             await this.messageStore.dequeueOfflineMessage(msg.id);
                             console.log(`[IrohTransport] Delivered offline message to ${peerId.substring(0, 12)}...`);
                         }
+                        else {
+                            await this.messageStore.incrementOfflineRetry(msg.id);
+                        }
                     }
                     catch {
                         await this.messageStore.incrementOfflineRetry(msg.id);
@@ -356,8 +367,10 @@ export class IrohTransport {
                 await send.writeAll(Buffer.from(requestMsg));
                 await send.finish();
                 // 等待响应，带超时
+                // 注意: server sendResponse 后会关闭连接，导致 readToEnd 以 "connection lost" 错误 reject
+                // 这里我们把 readToEnd 的错误吞掉（视为流结束），只有超时才视为失败
                 const response = await Promise.race([
-                    recv.readToEnd(64 * 1024),
+                    recv.readToEnd(64 * 1024).catch(() => new Uint8Array(0)),
                     new Promise((_, rejectTimeout) => setTimeout(() => rejectTimeout(new Error('timeout')), timeout)),
                 ]);
                 conn.close();

package/dist/network/p2p.js

@@ -437,8 +437,8 @@ export class P2PNetwork {
                 const colonIdx = messageStr.indexOf(':');
                 const didMarker = 'DID:';
                 let did;
-                let type;
-                let payload;
+                let type = 'message';
+                let payload = '';
                 let requestId = undefined;
                 if (messageStr.startsWith(didMarker)) {
                     const didEndIdx = messageStr.indexOf('|');
@@ -651,7 +651,11 @@ export class P2PNetwork {
      * Register a handler for responses (used by the receiving side)
      */
     onResponse(type, handler) {
-        this.messageHandlers.set(type, handler);
+        // Store as pendingResponseHandlers-shaped wrapper. Extra args (did, requestId) are not
+        // available in pendingResponseHandlers signature, so ignore them when invoked.
+        this.pendingResponseHandlers.set(type, (responseData, from) => {
+            handler(responseData, from, undefined, undefined);
+        });
     }
     /**
      * Send a response back to a peer
@@ -675,11 +679,8 @@ export class P2PNetwork {
     handleRequest(type, payload, requestId, fromPeerId, did) {
         const handler = this.messageHandlers.get(type);
         if (handler) {
-            // Create a wrapper that sends the response
-            const originalHandler = handler;
-            handler = (msg, from, didParam) => {
-                originalHandler(msg, from, didParam);
-            };
+            // Forward raw payload; callers register with onMessage() and adapt as needed.
+            handler(new TextEncoder().encode(payload), fromPeerId, did);
         }
         // Check if there's a response handler registered
         const responseHandler = this.pendingResponseHandlers.get(type);