@bolloon/bolloon-agent 0.1.1 → 0.1.3

package/dist/agents/pi-sdk.js

@@ -1,60 +1,23 @@
-"use strict";
 /**
  * Pi-SDK - Agent Session for Document Processing
  * Part of OpenClaw dual-layer architecture
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PiSessionManager = void 0;
-exports.createAgentSession = createAgentSession;
-exports.getAgentSession = getAgentSession;
-exports.resetAgentSession = resetAgentSession;
-const fs = __importStar(require("fs/promises"));
-const path = __importStar(require("path"));
-const reader_js_1 = require("../documents/reader.js");
-const index_js_1 = require("../constraints/index.js");
-const p2p_js_1 = require("../network/p2p.js");
-const constraint_layer_js_1 = require("./constraint-layer.js");
-const workflow_engine_js_1 = require("./workflow-engine.js");
-const constraint_runtime_1 = require("@bolloon/constraint-runtime");
-const heartbeat_js_1 = require("../social/heartbeat.js");
-const global_shared_context_js_1 = require("../social/global-shared-context.js");
-const constraint_runtime_2 = require("@bolloon/constraint-runtime");
+import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { documentReader } from '../documents/reader.js';
+import { getMinimax } from '../constraints/index.js';
+import { p2pNetwork } from '../network/p2p.js';
+import { ConstraintLayer } from './constraint-layer.js';
+import { WorkflowEngine } from './workflow-engine.js';
+import { DeepThinkingEngine, AgentCoordinator } from '@bolloon/constraint-runtime';
+import { WorkflowPivotLoop, createDefaultPivotConfig } from './workflow-pivot-loop.js';
+import { DiscoveredAgentsManager, createSocialHeartbeat } from '../social/heartbeat.js';
+import { getGlobalSharedContext } from '../social/global-shared-context.js';
+import { Session, SkillRegistry, saveSession, loadSession } from '@bolloon/constraint-runtime';
 const SHARED_SESSION_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'sessions');
 const PERSONA_PATH = path.join(process.env.HOME || '/tmp', '.bolloon', 'persona.json');
-class PiSessionManager {
+export class PiSessionManager {
     session;
     state;
     memory;
@@ -71,7 +34,7 @@ class PiSessionManager {
         this.sessionDir = path.join(cwd, '.port_sessions');
         this.agentId = agentId;
         const sessionId = `pi-session-${Date.now()}`;
-        this.session = new constraint_runtime_2.Session(sessionId);
+        this.session = new Session(sessionId);
         this.state = {
             id: sessionId,
             agentId,
@@ -85,7 +48,7 @@ class PiSessionManager {
             fileContext: new Map()
         };
         this.channelsPath = path.join(SHARED_SESSION_PATH, 'pi-channels.json');
-        this.sharedContext = (0, global_shared_context_js_1.getGlobalSharedContext)();
+        this.sharedContext = getGlobalSharedContext();
     }
     get sessionId() {
         return this.session.sessionId;
@@ -115,7 +78,7 @@ class PiSessionManager {
                 inputTokens: 0,
                 outputTokens: 0
             };
-            (0, constraint_runtime_2.saveSession)(stored);
+            saveSession(stored);
         }
         catch (e) {
             console.warn('Failed to persist session:', e);
@@ -124,7 +87,7 @@ class PiSessionManager {
     loadPersistedSession() {
         try {
             const sessionId = this.state.id;
-            const stored = (0, constraint_runtime_2.loadSession)(sessionId);
+            const stored = loadSession(sessionId);
             for (const msg of stored.messages) {
                 this.session.addMessage(msg);
             }
@@ -338,7 +301,6 @@ class PiSessionManager {
         await this.sharedContext.updateAgentStatus(this.agentId, status);
     }
 }
-exports.PiSessionManager = PiSessionManager;
 const TOOL_DEFINITIONS = `
 可用工具:
 1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
@@ -366,28 +328,34 @@ class PiAgentSession {
     socialHeartbeat = null;
     messageHistory = [];
     tools = new Map();
-    skillRegistry = new constraint_runtime_2.SkillRegistry();
-    MAX_REACT_ITERATIONS = 10;
-    thinkingEngine = new constraint_runtime_1.DeepThinkingEngine(3);
-    coordinator = new constraint_runtime_1.AgentCoordinator(3);
+    skillRegistry = new SkillRegistry();
+    MAX_REACT_ITERATIONS = 100;
+    MAX_REFINE_ATTEMPTS = 3;
+    QUALITY_THRESHOLD = 0.6;
+    thinkingEngine = new DeepThinkingEngine(3);
+    coordinator = new AgentCoordinator(3);
     harness = null;
     harnessEnabled = false;
+    usePivotLoop = false;
+    pivotLoopConfig;
     constructor(config) {
         this.cwd = config.cwd;
         this.peerId = config.peerId || 'local';
         this.identity = config.identityDoc || this.createDefaultIdentity();
         this.minimaxAvailable = this.checkMinimax();
-        this.constraintLayer = new constraint_layer_js_1.ConstraintLayer();
-        this.workflowEngine = new workflow_engine_js_1.WorkflowEngine(this.constraintLayer);
+        this.constraintLayer = new ConstraintLayer();
+        this.workflowEngine = new WorkflowEngine(this.constraintLayer);
         this.sessionManager = new PiSessionManager(this.identity.did, this.cwd);
-        this.agentsManager = new heartbeat_js_1.DiscoveredAgentsManager();
+        this.agentsManager = new DiscoveredAgentsManager();
+        this.usePivotLoop = config.usePivotLoop ?? false;
+        this.pivotLoopConfig = config.pivotLoopConfig;
         this.initSession();
         this.registerTools();
         this.initHarness();
     }
     async initHarness() {
         try {
-            const { createBollharnessIntegration } = await Promise.resolve().then(() => __importStar(require('../bollharness-integration/index.js')));
+            const { createBollharnessIntegration } = await import('../bollharness-integration/index.js');
             this.harness = createBollharnessIntegration();
             this.harnessEnabled = true;
         }
@@ -403,7 +371,7 @@ class PiAgentSession {
             parameters: { path: '文件路径' },
             execute: async (args) => {
                 try {
-                    const content = await reader_js_1.documentReader.read(args.path);
+                    const content = await documentReader.read(args.path);
                     return {
                         success: true,
                         output: `📄 ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n\n${content.text.substring(0, 1000)}${content.text.length > 1000 ? '...' : ''}`
@@ -462,7 +430,7 @@ class PiAgentSession {
             description: '列出已连接的对等节点',
             parameters: {},
             execute: async () => {
-                const peers = p2p_js_1.p2pNetwork.getPeers();
+                const peers = p2pNetwork.getPeers();
                 if (peers.length === 0) {
                     return { success: true, output: '当前无连接的对等节点' };
                 }
@@ -475,7 +443,7 @@ class PiAgentSession {
             parameters: { peer_id: '对等节点ID', message: '消息内容' },
             execute: async (args) => {
                 try {
-                    await p2p_js_1.p2pNetwork.sendMessage(args.peer_id, 'message', args.message);
+                    await p2pNetwork.sendMessage(args.peer_id, 'message', args.message);
                     return { success: true, output: `消息已发送到 ${args.peer_id}` };
                 }
                 catch (e) {
@@ -489,7 +457,7 @@ class PiAgentSession {
             parameters: { message: '消息内容' },
             execute: async (args) => {
                 try {
-                    await p2p_js_1.p2pNetwork.broadcast('message', args.message);
+                    await p2pNetwork.broadcast('message', args.message);
                     return { success: true, output: '消息已广播到所有节点' };
                 }
                 catch (e) {
@@ -556,6 +524,59 @@ class PiAgentSession {
                 };
             }
         });
+        // 添加文件列表工具
+        this.tools.set('list_files', {
+            name: 'list_files',
+            description: '列出目录中的文件',
+            parameters: { path: '目录路径（可选，默认为当前目录）' },
+            execute: async (args) => {
+                try {
+                    const fs = await import('fs');
+                    const path = args.path || this.cwd;
+                    const files = fs.readdirSync(path);
+                    return {
+                        success: true,
+                        output: `📁 目录 ${path} 中的文件 (${files.length} 个):\n${files.slice(0, 20).map(f => `  - ${f}`).join('\n')}${files.length > 20 ? '\n  ...' : ''}`
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        // 添加目录读取工具（更完整的实现）
+        this.tools.set('read_directory', {
+            name: 'read_directory',
+            description: '读取目录内容，返回文件列表和目录结构',
+            parameters: { path: '目录路径（可选，默认为当前目录）' },
+            execute: async (args) => {
+                try {
+                    const fs = await import('fs');
+                    const pathModule = await import('path');
+                    const targetPath = args.path || this.cwd;
+                    const items = fs.readdirSync(targetPath);
+                    const result = [];
+                    for (const item of items.slice(0, 30)) {
+                        const fullPath = pathModule.join(targetPath, item);
+                        try {
+                            const stat = fs.statSync(fullPath);
+                            const type = stat.isDirectory() ? '📁' : '📄';
+                            result.push(`${type} ${item}${stat.isDirectory() ? '/' : ''}`);
+                        }
+                        catch {
+                            result.push(`📄 ${item}`);
+                        }
+                    }
+                    return {
+                        success: true,
+                        output: `📂 ${targetPath} (${items.length} 项):\n${result.join('\n')}${items.length > 30 ? '\n... 还有更多文件' : ''}`
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: `无法读取目录: ${String(e)}` };
+                }
+            }
+        });
     }
     getToolDefinitions() {
         const defs = ['可用工具:'];
@@ -583,7 +604,7 @@ class PiAgentSession {
     }
     checkMinimax() {
         try {
-            (0, index_js_1.getMinimax)();
+            getMinimax();
             return true;
         }
         catch {
@@ -609,25 +630,104 @@ class PiAgentSession {
             role: 'user',
             content: input
         });
-        onStream({ type: 'thinking', content: '🤔 思考中...' });
+        onStream({ type: 'thinking', content: '🤔 开始思考...' });
         if (!this.minimaxAvailable) {
             const response = await this.handleFallback(input);
             this.messageHistory.push({ role: 'assistant', content: response });
             onStream({ type: 'done', content: '' });
             return response;
         }
-        const result = await this.runReActLoop();
+        const result = await this.runReActLoop(onStream);
         onStream({ type: 'done', content: '' });
         return result;
     }
-    async runReActLoop() {
-        const llm = (0, index_js_1.getMinimax)();
+    async promptWithPivotLoop(input, config) {
+        if (!this.minimaxAvailable) {
+            const response = await this.handleFallback(input);
+            return {
+                success: false,
+                response,
+                iterations: 0,
+                toolCalls: 0,
+                qualityScore: 0,
+                exitReason: 'error',
+                state: {
+                    iteration: 0,
+                    totalTokens: 0,
+                    toolCallsCount: 0,
+                    consecutiveNoProgress: 0,
+                    qualityScores: [],
+                    pendingToolUses: [],
+                    lastMeaningfulWork: 0
+                }
+            };
+        }
+        const llm = getMinimax();
+        const loopConfig = config || this.pivotLoopConfig || createDefaultPivotConfig();
+        const loop = new WorkflowPivotLoop(loopConfig);
+        for (const tool of this.tools.values()) {
+            loop.registerTool(tool);
+        }
+        const personaSection = this.persona ? `
+角色描述: ${this.persona.description || '无'}
+性格特点: ${this.persona.personality || '无'}
+问候语: ${this.persona.greeting || '无'}
+` : '';
+        const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
+当前工作目录: ${this.cwd}
+当前身份: ${this.identity.name} (${this.identity.did})
+
+${this.getToolDefinitions()}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
+- 如果需要更多信息，继续调用工具`;
+        const result = await loop.execute(input, llm, systemPrompt);
+        this.messageHistory.push({ role: 'user', content: input });
+        if (result.response) {
+            this.messageHistory.push({ role: 'assistant', content: result.response });
+        }
+        return result;
+    }
+    async runReActLoop(onStream) {
+        const llm = getMinimax();
         let iteration = 0;
         let finalResponse = '';
+        let lastQualityScore = 0;
+        let refineAttempts = 0;
+        let consecutiveErrors = 0;
+        const MAX_CONSECUTIVE_ERRORS = 3;
+        // 发送循环开始的事件
+        if (onStream) {
+            onStream({ type: 'status', content: '🔄 开始 ReAct 循环...', tool: 'system' });
+        }
         while (iteration < this.MAX_REACT_ITERATIONS) {
             iteration++;
+            // 调试日志：显示每次循环开始
+            console.log(`[PiAgent] 循环 ${iteration}/${this.MAX_REACT_ITERATIONS} 开始`);
+            if (onStream) {
+                onStream({ type: 'status', content: `🔄 循环 ${iteration}/${this.MAX_REACT_ITERATIONS}`, tool: 'loop' });
+            }
             const context = this.buildContext();
             const toolDefs = this.getToolDefinitions();
+            // 动态构建 refine 上下文
+            let refineContext = '';
+            if (refineAttempts > 0 && lastQualityScore < this.QUALITY_THRESHOLD) {
+                refineContext = `\n【改进提示】上轮结果质量分 ${(lastQualityScore * 10).toFixed(1)}/10，请改进回答。`;
+            }
+            // 连续错误时的额外提示
+            if (consecutiveErrors > 0) {
+                refineContext += `\n【错误提示】上轮发生 ${consecutiveErrors} 次错误，请重新分析问题或换一种方式处理。`;
+            }
             const personaSection = this.persona ? `
 角色描述: ${this.persona.description || '无'}
 性格特点: ${this.persona.personality || '无'}
@@ -636,6 +736,7 @@ class PiAgentSession {
             const systemPrompt = `你是 ${this.identity.name}，基于ReAct (Reasoning + Acting)模式工作。${personaSection}
 当前工作目录: ${this.cwd}
 当前身份: ${this.identity.name} (${this.identity.did})
+${refineContext}
 
 ${toolDefs}
 
@@ -649,11 +750,24 @@ ${toolDefs}
 重要:
 - 每次只调用一个工具
 - 仔细分析工具返回结果
-- 如果任务完成，返回完整回答
+- 当任务完成时，必须在回答末尾添加 <final gen> 标记表示结束
 - 如果需要更多信息，继续调用工具`;
             const response = await llm.chat(context, systemPrompt);
             const reply = response.reply.trim();
+            console.log(`[PiAgent] LLM 回复长度: ${reply.length}, 内容预览: "${reply.substring(0, 80)}..."`);
+            // 通知前端：收到 LLM 回复
+            if (onStream) {
+                onStream({ type: 'token', content: reply.substring(0, 100) });
+            }
             if (this.isFinalResponse(reply)) {
+                // 检查质量分数
+                lastQualityScore = this.estimateResponseQuality(reply);
+                // 如果质量太低且还有改进机会，进入改进循环
+                if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
+                    refineAttempts++;
+                    console.log(`[PiAgent] 质量评分 ${(lastQualityScore * 10).toFixed(1)}/10 < ${(this.QUALITY_THRESHOLD * 10).toFixed(1)}/10，自动改进中 (${refineAttempts}/${this.MAX_REFINE_ATTEMPTS})`);
+                    continue;
+                }
                 finalResponse = this.extractFinalAnswer(reply);
                 break;
             }
@@ -664,28 +778,123 @@ ${toolDefs}
                     content: reply,
                     toolCall
                 });
+                // 通知前端：检测到工具调用
+                if (onStream) {
+                    onStream({ type: 'tool', content: `🔧 调用工具: ${toolCall.name}`, tool: toolCall.name });
+                    if (toolCall.args && Object.keys(toolCall.args).length > 0) {
+                        onStream({ type: 'status', content: `📋 参数: ${JSON.stringify(toolCall.args)}`, tool: toolCall.name });
+                    }
+                }
                 const tool = this.tools.get(toolCall.name);
                 if (!tool) {
+                    consecutiveErrors++;
                     const errorResult = { success: false, error: `未知工具: ${toolCall.name}` };
                     this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
                     this.logToHarness(toolCall.name, toolCall.args, errorResult);
+                    console.warn(`[PiAgent] 未知工具: ${toolCall.name}，跳过并继续`);
                     continue;
                 }
-                const result = await tool.execute(toolCall.args);
-                this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
-                this.logToHarness(toolCall.name, toolCall.args, result);
-                if (!result.success && result.error) {
-                    console.warn(`Tool ${toolCall.name} error: ${result.error}`);
+                try {
+                    const result = await tool.execute(toolCall.args);
+                    console.log(`[PiAgent] 工具 ${toolCall.name} 执行完成: success=${result.success}`);
+                    this.messageHistory.push({ role: 'tool', content: JSON.stringify(result), toolResult: result });
+                    this.logToHarness(toolCall.name, toolCall.args, result);
+                    // 通知前端工具执行结果
+                    if (onStream) {
+                        if (result.success) {
+                            onStream({ type: 'status', content: `✅ ${toolCall.name} 执行成功`, tool: toolCall.name });
+                            if (result.output) {
+                                const outputPreview = result.output.substring(0, 200);
+                                onStream({ type: 'tool', content: `📤 结果: ${outputPreview}${result.output.length > 200 ? '...' : ''}`, tool: toolCall.name });
+                            }
+                        }
+                        else {
+                            onStream({ type: 'error', content: `❌ ${toolCall.name} 执行失败: ${result.error}`, tool: toolCall.name });
+                        }
+                    }
+                    if (result.success) {
+                        consecutiveErrors = 0; // 重置连续错误计数
+                        // 检查工具执行质量
+                        lastQualityScore = this.estimateToolResultQuality(result);
+                        if (lastQualityScore < this.QUALITY_THRESHOLD && refineAttempts < this.MAX_REFINE_ATTEMPTS) {
+                            refineAttempts++;
+                            console.log(`[PiAgent] 工具结果质量低，自动重试 (${refineAttempts}/${this.MAX_REFINE_ATTEMPTS})`);
+                        }
+                        else {
+                            console.log(`[PiAgent] 工具执行成功，质量评分: ${(lastQualityScore * 10).toFixed(1)}/10`);
+                        }
+                        // 工具执行成功后，继续循环获取下一个 LLM 响应
+                        if (onStream) {
+                            onStream({ type: 'status', content: `🔄 工具执行完成，继续循环...`, tool: 'loop' });
+                        }
+                        // 不 break，继续下一次循环
+                    }
+                    else {
+                        consecutiveErrors++;
+                        console.warn(`[PiAgent] 工具执行失败 (${consecutiveErrors}/${MAX_CONSECUTIVE_ERRORS}): ${result.error}`);
+                        // 连续错误达到上限，尝试换一种方式
+                        if (consecutiveErrors >= MAX_CONSECUTIVE_ERRORS) {
+                            console.log(`[PiAgent] 连续 ${MAX_CONSECUTIVE_ERRORS} 次错误，尝试换一种方式处理`);
+                            // 添加错误上下文，让 LLM 换一种方式
+                            this.messageHistory.push({
+                                role: 'system',
+                                content: `[注意] 前面的工具调用连续失败。请尝试其他工具或换一种方式完成用户请求。`
+                            });
+                            consecutiveErrors = 0; // 重置以继续尝试
+                        }
+                    }
+                }
+                catch (execError) {
+                    consecutiveErrors++;
+                    const errorResult = { success: false, error: String(execError) };
+                    this.messageHistory.push({ role: 'tool', content: JSON.stringify(errorResult), toolResult: errorResult });
+                    this.logToHarness(toolCall.name, toolCall.args, errorResult);
+                    console.error(`[PiAgent] 工具执行异常: ${execError}`);
                 }
             }
             else {
-                this.messageHistory.push({ role: 'assistant', content: reply });
+                // LLM 返回的不是 tool call 格式
+                this.messageHistory.push({
+                    role: 'assistant',
+                    content: reply
+                });
+                // 通知前端收到非工具调用回复
+                if (onStream) {
+                    onStream({ type: 'token', content: reply.substring(0, 150) });
+                }
+                // 检查是否需要继续循环处理
+                // 更严格的判断：只有当回复明确表示需要更多信息时才继续
+                const containsToolCallIntent = reply.includes('调用工具') || reply.includes('tool(') ||
+                    reply.includes('使用工具') || reply.includes('需要获取') || reply.includes('需要查看');
+                const hasError = ['不存在', '找不到', '无法找到', 'not found', 'does not exist',
+                    '错误', 'error', '失败', 'failed'].some(k => reply.includes(k));
+                const isTooShort = reply.length < 50 && reply.length > 0;
+                const hasQuestion = reply.includes('?') && (reply.includes('怎么') || reply.includes('如何') || reply.includes('什么'));
+                const needsMoreWork = hasError || containsToolCallIntent || isTooShort || hasQuestion;
+                if (needsMoreWork && iteration < this.MAX_REACT_ITERATIONS) {
+                    console.log(`[PiAgent] 继续循环处理 (${iteration}/${this.MAX_REACT_ITERATIONS}): needsMoreWork=${needsMoreWork}, hasError=${hasError}, containsToolCallIntent=${containsToolCallIntent}`);
+                    if (onStream) {
+                        onStream({ type: 'status', content: `🔄 继续处理，循环 ${iteration}...`, tool: 'loop' });
+                    }
+                    continue;
+                }
+                // 否则把这个当作可能的最终回答
                 finalResponse = reply;
+                if (onStream) {
+                    onStream({ type: 'status', content: `📝 提取最终回答，长度 ${reply.length}`, tool: 'system' });
+                }
                 break;
             }
         }
         if (!finalResponse) {
             finalResponse = '任务处理超时，请尝试更具体的请求。';
+            if (onStream) {
+                onStream({ type: 'error', content: '⚠️ 任务处理超时', tool: 'system' });
+            }
+        }
+        // 通知前端循环完成
+        if (onStream) {
+            onStream({ type: 'status', content: `✅ 处理完成，共 ${iteration - 1} 次循环`, tool: 'system' });
         }
         const now = new Date().toISOString();
         const identityPrefix = `${this.identity.name} ｜ bolloon 智能体
@@ -757,17 +966,23 @@ Workspace root folder: ${this.cwd}
         }).join('\n');
     }
     isFinalResponse(content) {
-        const finalMarkers = ['最终回答', '完成', '答案如下', '结果是', 'final', 'answer:', '结果:'];
-        const lower = content.toLowerCase();
-        return finalMarkers.some(m => lower.includes(m)) || (content.includes('✅') && content.length < 500);
+        // 只有明确输出 <final gen> 才认为是最终回答
+        return content.includes('<final gen>');
     }
     extractFinalAnswer(content) {
-        const lines = content.split('\n');
-        const answerStart = lines.findIndex(l => ['最终回答', '完成', '答案如下', '结果是', 'final', 'answer:'].some(m => l.toLowerCase().includes(m)));
-        if (answerStart >= 0) {
-            return lines.slice(answerStart + 1).join('\n').trim();
+        // 提取 <final gen> 后的内容作为最终回答
+        const marker = '<final gen>';
+        const markerIndex = content.indexOf(marker);
+        if (markerIndex !== -1) {
+            content = content.substring(markerIndex + marker.length).trim();
         }
-        return content;
+        // 移除任何 tool call 标记
+        let cleaned = content
+            .replace(/调用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
+            .replace(/使用工具[：:]\s*\w+\s*\([^)]*\)/g, '')
+            .replace(/tool[_\w]*[：:]\s*\w+\s*\([^)]*\)/gi, '')
+            .trim();
+        return cleaned;
     }
     parseToolCall(content) {
         const patterns = [
@@ -796,6 +1011,46 @@ Workspace root folder: ${this.cwd}
         }
         return null;
     }
+    estimateResponseQuality(response) {
+        let score = 0.5;
+        if (response.length > 50)
+            score += 0.1;
+        if (response.length > 200)
+            score += 0.1;
+        if (response.length < 20)
+            score -= 0.3;
+        if (response.includes('\n'))
+            score += 0.1;
+        if (response.includes('-') || response.includes('•'))
+            score += 0.05;
+        if (response.includes('```'))
+            score += 0.1;
+        const conclusionWords = ['完成', '结果', '总结', '所以', '因此', '答案', '推荐'];
+        if (conclusionWords.some(w => response.includes(w)))
+            score += 0.1;
+        if (response.includes('调用工具') || response.includes('tool('))
+            score -= 0.2;
+        return Math.max(0, Math.min(1, score));
+    }
+    estimateToolResultQuality(result) {
+        let score = 0.5;
+        if (!result.success)
+            return 0.2;
+        if (result.output) {
+            score += 0.2;
+            if (result.output.length > 50)
+                score += 0.1;
+            if (result.output.length < 10)
+                score -= 0.1;
+            if (result.output.includes('❌') || result.output.includes('error'))
+                score -= 0.2;
+            if (result.output.includes('✅') || result.output.includes('success'))
+                score += 0.1;
+        }
+        if (result.error)
+            score -= 0.3;
+        return Math.max(0, Math.min(1, score));
+    }
     async handleFallback(input) {
         const lowerInput = input.toLowerCase();
         const parts = input.trim().split(/\s+/);
@@ -829,10 +1084,38 @@ Workspace root folder: ${this.cwd}
         }
         return this.getDefaultResponse(input);
     }
+    static OPERATIONS_REFERENCE = null;
+    static getOperationsReference() {
+        if (this.OPERATIONS_REFERENCE === null) {
+            try {
+                const refPath = path.join(process.cwd(), 'src', 'bollharness', 'scripts', 'context-fragments', 'pi-agent-operations.md');
+                this.OPERATIONS_REFERENCE = fsSync.readFileSync(refPath, 'utf-8');
+            }
+            catch {
+                this.OPERATIONS_REFERENCE = '';
+            }
+        }
+        return this.OPERATIONS_REFERENCE;
+    }
     getDefaultResponse(input) {
+        const operationsRef = PiAgentSession.getOperationsReference();
+        if (operationsRef) {
+            return `收到了: "${input}"
+
+我是一个判断力处理智能体，支持自然语言交互。
+
+可用操作（直接说出即可）:
+${this.extractOperationsFromRef(operationsRef)}
+
+示例请求:
+  - "读取 src/index.ts 文件"
+  - "总结一下 README.md"
+  - "查看当前连接了哪些节点"
+  - "向 QmABC... 发送测试消息"`;
+        }
         return `收到了: "${input}"
 
-我是一个文档处理智能体，支持自然语言交互。
+我是一个判断力处理智能体，支持自然语言交互。
 
 可用操作（直接说出即可）:
   - "读取 README.md" - 读取并分析文档
@@ -849,13 +1132,44 @@ Workspace root folder: ${this.cwd}
   - "总结一下 README.md"
   - "查看当前连接了哪些节点"
   - "向 QmABC... 发送测试消息"`;
+    }
+    extractOperationsFromRef(ref) {
+        const lines = ref.split('\n');
+        const inOperationsSection = false;
+        const operationLines = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.startsWith('## 可用操作')) {
+                for (let j = i + 1; j < lines.length; j++) {
+                    const opLine = lines[j];
+                    if (opLine.startsWith('## ') || opLine.startsWith('#'))
+                        break;
+                    if (opLine.includes('|') && !opLine.startsWith('|')) {
+                        const parts = opLine.split('|').map(p => p.trim());
+                        if (parts.length >= 3 && parts[1] && parts[2]) {
+                            operationLines.push(`  - "${parts[1]}" - ${parts[2]}`);
+                        }
+                    }
+                }
+                break;
+            }
+        }
+        return operationLines.length > 0 ? operationLines.join('\n') :
+            `  - "读取 README.md" - 读取并分析文档
+  - "总结文档" - 总结文档内容
+  - "改进文档，按照X要求" - 改进文档
+  - "查看节点" - 查看已连接的对等节点
+  - "向X发送消息Y" - 向对等节点发送消息
+  - "广播消息X" - 广播消息到所有节点
+  - "查看身份" - 查看当前智能体身份
+  - "查看日志" - 查看最近操作日志`;
     }
     async suggestRename(messages) {
         if (!this.minimaxAvailable || messages.length < 2) {
             return null;
         }
         const conversation = messages.map(m => `${m.type === 'user' ? '用户' : '助手'}: ${m.content}`).join('\n');
-        const llm = (0, index_js_1.getMinimax)();
+        const llm = getMinimax();
         try {
             const response = await llm.chat(`根据以下对话内容，为这个对话生成一个简短的名称（不超过20个字）：\n\n${conversation}\n\n直接输出名称，不要其他解释。`, '命名建议');
             const name = response.reply.trim();
@@ -872,12 +1186,12 @@ Workspace root folder: ${this.cwd}
         if (!this.minimaxAvailable) {
             return '⚠️ LLM未初始化，请设置 MINIMAX_API_KEY 环境变量';
         }
-        const llm = (0, index_js_1.getMinimax)();
+        const llm = getMinimax();
         const result = await llm.summarize(text);
         return `📝 摘要:\n${result.summary}\n\n质量评分: ${(result.qualityScore * 10).toFixed(1)}/10`;
     }
     async readDocument(filePath) {
-        const content = await reader_js_1.documentReader.read(filePath);
+        const content = await documentReader.read(filePath);
         this.sessionManager.addFileContext(filePath, content.text.substring(0, 1000));
         return `📄 ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n\n${content.text.substring(0, 500)}...`;
     }
@@ -888,10 +1202,10 @@ Workspace root folder: ${this.cwd}
                 qualityScore: 0
             };
         }
-        const content = await reader_js_1.documentReader.read(filePath);
+        const content = await documentReader.read(filePath);
         this.sessionManager.addFileContext(filePath, content.text.substring(0, 1000));
-        const llm = (0, index_js_1.getMinimax)();
-        const chunks = reader_js_1.documentReader.chunk(content.text);
+        const llm = getMinimax();
+        const chunks = documentReader.chunk(content.text);
         const summaries = [];
         let totalQuality = 0;
         for (const chunk of chunks) {
@@ -913,8 +1227,8 @@ Workspace root folder: ${this.cwd}
                 shouldAutoSend: false
             };
         }
-        const content = await reader_js_1.documentReader.read(request.originalPath);
-        const llm = (0, index_js_1.getMinimax)();
+        const content = await documentReader.read(request.originalPath);
+        const llm = getMinimax();
         const improvedResult = await llm.summarize(content.text + '\n\n改进要求: ' + request.requirements, request.context);
         const shouldAutoSend = await llm.shouldAutoSend(improvedResult.qualityScore, 0.7);
         return {
@@ -994,20 +1308,20 @@ Workspace root folder: ${this.cwd}
         return this.constraintLayer.getLogs();
     }
     listPeers() {
-        const peers = p2p_js_1.p2pNetwork.getPeers();
+        const peers = p2pNetwork.getPeers();
         if (peers.length === 0) {
             return '当前无连接的对等节点';
         }
         return `已连接节点 (${peers.length}):\n${peers.map(p => `  - ${p}`).join('\n')}`;
     }
     getPeers() {
-        return p2p_js_1.p2pNetwork.getPeers();
+        return p2pNetwork.getPeers();
     }
     async sendMessage(peerId, message) {
-        await p2p_js_1.p2pNetwork.sendMessage(peerId, 'message', message);
+        await p2pNetwork.sendMessage(peerId, 'message', message);
     }
     async broadcast(message) {
-        await p2p_js_1.p2pNetwork.broadcast('message', message);
+        await p2pNetwork.broadcast('message', message);
     }
     getIdentity() {
         return { ...this.identity };
@@ -1070,7 +1384,7 @@ Workspace root folder: ${this.cwd}
         if (this.socialHeartbeat) {
             return;
         }
-        this.socialHeartbeat = await (0, heartbeat_js_1.createSocialHeartbeat)(this.sessionManager, this.agentsManager, config);
+        this.socialHeartbeat = await createSocialHeartbeat(this.sessionManager, this.agentsManager, config);
         this.socialHeartbeat.setOnAgentDiscovered((agent) => {
             console.log(`[Agent] 发现新智能体: ${agent.name}`);
         });
@@ -1163,8 +1477,22 @@ Workspace root folder: ${this.cwd}
 }
 let sessionInstance = null;
 let lastIdentityDid = null;
-async function createAgentSession(config) {
+// 独立的 session 实例缓存（用于多 session 支持）
+const independentSessions = new Map();
+export async function createAgentSession(config, forceNew) {
     const incomingDid = config.identityDoc?.did;
+    const sessionKey = config.peerId || 'default';
+    // 如果指定了 forceNew 或有独立的 session key，创建独立实例
+    if (forceNew || (config.peerId && config.peerId.includes(':'))) {
+        const key = `${sessionKey}:${forceNew ? Date.now() : ''}`;
+        if (!forceNew && independentSessions.has(key)) {
+            return independentSessions.get(key);
+        }
+        const session = new PiAgentSession(config);
+        independentSessions.set(key, session);
+        console.log(`[createAgentSession] 创建独立 session, key=${key}, DID=${incomingDid}`);
+        return session;
+    }
     // 如果有新的 DID，强制重建 session
     if (sessionInstance && lastIdentityDid && incomingDid && lastIdentityDid !== incomingDid) {
         console.log(`[createAgentSession] DID 变化 ${lastIdentityDid} -> ${incomingDid}，重建 session`);
@@ -1189,11 +1517,10 @@ async function createAgentSession(config) {
     console.log(`[createAgentSession] 新建 session, DID=${lastIdentityDid}`);
     return sessionInstance;
 }
-function getAgentSession() {
+export function getAgentSession() {
     return sessionInstance;
 }
-function resetAgentSession() {
+export function resetAgentSession() {
     sessionInstance = null;
     lastIdentityDid = null;
 }
-//# sourceMappingURL=pi-sdk.js.map