@bolloon/bolloon-agent 0.1.0

package/dist/agents/pi-sdk.js

@@ -0,0 +1,1199 @@
+"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");
+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 {
+    session;
+    state;
+    memory;
+    persona = null;
+    channels = new Map();
+    channelsPath;
+    initialized = false;
+    sessionDir;
+    cwd;
+    sharedContext;
+    agentId;
+    constructor(agentId, cwd) {
+        this.cwd = cwd;
+        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.state = {
+            id: sessionId,
+            agentId,
+            cwd,
+            startedAt: new Date().toISOString(),
+            lastActive: new Date().toISOString()
+        };
+        this.memory = {
+            workingMemory: [],
+            summarizedMemory: [],
+            fileContext: new Map()
+        };
+        this.channelsPath = path.join(SHARED_SESSION_PATH, 'pi-channels.json');
+        this.sharedContext = (0, global_shared_context_js_1.getGlobalSharedContext)();
+    }
+    get sessionId() {
+        return this.session.sessionId;
+    }
+    get turnCount() {
+        return this.session.turnCount;
+    }
+    addSessionMessage(msg) {
+        this.session.addMessage(msg);
+        this.persistSession();
+    }
+    getSessionHistory() {
+        return this.session.history;
+    }
+    setSessionContext(key, value) {
+        this.session.setContext(key, value);
+        this.persistSession();
+    }
+    getSessionContext(key) {
+        return this.session.getContext(key);
+    }
+    persistSession() {
+        try {
+            const stored = {
+                sessionId: this.session.sessionId,
+                messages: this.session.history,
+                inputTokens: 0,
+                outputTokens: 0
+            };
+            (0, constraint_runtime_2.saveSession)(stored);
+        }
+        catch (e) {
+            console.warn('Failed to persist session:', e);
+        }
+    }
+    loadPersistedSession() {
+        try {
+            const sessionId = this.state.id;
+            const stored = (0, constraint_runtime_2.loadSession)(sessionId);
+            for (const msg of stored.messages) {
+                this.session.addMessage(msg);
+            }
+        }
+        catch {
+            // No persisted session found, start fresh
+        }
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        await fs.mkdir(SHARED_SESSION_PATH, { recursive: true });
+        await fs.mkdir(this.sessionDir, { recursive: true });
+        this.persona = await this.loadPersona();
+        await this.loadChannels();
+        this.loadPersistedSession();
+        await this.sharedContext.initialize();
+        await this.sharedContext.registerAgent({
+            agentId: this.agentId,
+            sessionId: this.sessionId,
+            channelId: 'system',
+            capabilities: this.persona?.capabilities || [],
+            status: 'active',
+            name: this.persona?.name,
+            persona: this.persona ? {
+                name: this.persona.name,
+                description: this.persona.description,
+                capabilities: this.persona.capabilities
+            } : undefined
+        });
+        this.initialized = true;
+    }
+    async loadPersona() {
+        try {
+            const data = await fs.readFile(PERSONA_PATH, 'utf-8');
+            return JSON.parse(data);
+        }
+        catch {
+            return null;
+        }
+    }
+    async loadChannels() {
+        try {
+            const data = await fs.readFile(this.channelsPath, 'utf-8');
+            const channelsArray = JSON.parse(data);
+            this.channels.clear();
+            for (const channel of channelsArray) {
+                this.channels.set(channel.id, channel);
+            }
+        }
+        catch {
+            this.channels.clear();
+        }
+    }
+    async saveChannels() {
+        const channelsArray = Array.from(this.channels.values());
+        await fs.writeFile(this.channelsPath, JSON.stringify(channelsArray, null, 2));
+    }
+    async savePersona(persona) {
+        await fs.writeFile(PERSONA_PATH, JSON.stringify(persona, null, 2));
+        this.persona = persona;
+    }
+    getPersona() {
+        return this.persona;
+    }
+    getState() {
+        return { ...this.state, lastActive: new Date().toISOString() };
+    }
+    getMemory() {
+        return this.memory;
+    }
+    addToWorkingMemory(content) {
+        this.memory.workingMemory.push(content);
+        if (this.memory.workingMemory.length > 100) {
+            this.memory.workingMemory = this.memory.workingMemory.slice(-100);
+        }
+        this.state.lastActive = new Date().toISOString();
+    }
+    addSummarizedMemory(content) {
+        this.memory.summarizedMemory.push(content);
+        if (this.memory.summarizedMemory.length > 50) {
+            this.memory.summarizedMemory = this.memory.summarizedMemory.slice(-50);
+        }
+    }
+    addFileContext(filePath, content) {
+        this.memory.fileContext.set(filePath, content);
+        if (this.memory.fileContext.size > 20) {
+            const entries = Array.from(this.memory.fileContext.entries());
+            this.memory.fileContext = new Map(entries.slice(-20));
+        }
+    }
+    updateTokenUsage(promptTokens, completionTokens) {
+        this.state.tokenUsage = {
+            promptTokens: (this.state.tokenUsage?.promptTokens || 0) + promptTokens,
+            completionTokens: (this.state.tokenUsage?.completionTokens || 0) + completionTokens,
+            totalTokens: (this.state.tokenUsage?.totalTokens || 0) + promptTokens + completionTokens
+        };
+    }
+    async addMessage(channelId, message) {
+        await this.initialize();
+        if (!this.channels.has(channelId)) {
+            this.channels.set(channelId, {
+                id: channelId,
+                name: channelId,
+                messages: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            });
+        }
+        const channel = this.channels.get(channelId);
+        channel.messages.push(message);
+        channel.updatedAt = new Date().toISOString();
+        await this.saveChannels();
+    }
+    async getChannelMessages(channelId) {
+        await this.initialize();
+        return this.channels.get(channelId)?.messages || [];
+    }
+    async createChannel(name, peerInfo, persona) {
+        await this.initialize();
+        const channelId = `ch_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+        const channel = {
+            id: channelId,
+            name,
+            messages: [],
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            ...peerInfo,
+            persona: persona || undefined
+        };
+        this.channels.set(channelId, channel);
+        await this.saveChannels();
+        return channel;
+    }
+    async getOrCreatePeerChannel(peerDid, peerName, persona) {
+        await this.initialize();
+        for (const channel of this.channels.values()) {
+            if (channel.peerDid === peerDid) {
+                return channel;
+            }
+        }
+        return this.createChannel(`与 ${peerName} 的对话`, {
+            peerDid,
+            peerName
+        }, persona);
+    }
+    async setChannelInfo(channelId, info) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            Object.assign(channel, info, { updatedAt: new Date().toISOString() });
+            await this.saveChannels();
+        }
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+    getChannelPersona(channelId) {
+        return this.channels.get(channelId)?.persona;
+    }
+    async setChannelPersona(channelId, persona) {
+        await this.initialize();
+        const channel = this.channels.get(channelId);
+        if (channel) {
+            channel.persona = persona;
+            channel.updatedAt = new Date().toISOString();
+            await this.saveChannels();
+        }
+    }
+    async addUserActionToSharedContext(content, importance) {
+        await this.initialize();
+        await this.sharedContext.addUserAction(content, this.agentId, undefined, importance);
+        await this.sharedContext.updateAgentStatus(this.agentId, 'active');
+    }
+    async addSharedKnowledge(knowledge) {
+        await this.initialize();
+        await this.sharedContext.addSharedKnowledge(knowledge);
+    }
+    async getRecentActionsSummary(count) {
+        return this.sharedContext.getRecentActionsSummary(count);
+    }
+    async getSharedKnowledge() {
+        return this.sharedContext.getSharedKnowledge();
+    }
+    async getGlobalContext() {
+        return this.sharedContext.getFullContext();
+    }
+    async getGlobalContextSummary() {
+        return this.sharedContext.getContextSummary();
+    }
+    async createCooperation(type, task, toAgentId, context) {
+        await this.initialize();
+        return this.sharedContext.createCooperation(type, this.agentId, task, toAgentId, context);
+    }
+    async getPendingCooperations() {
+        return this.sharedContext.getPendingCooperations(this.agentId);
+    }
+    async updateCooperationStatus(cooperationId, status, result) {
+        await this.sharedContext.updateCooperationStatus(cooperationId, status, result);
+    }
+    async getAllRegisteredAgents() {
+        return this.sharedContext.getAllAgents();
+    }
+    async findAgentByCapability(capability) {
+        return this.sharedContext.findAgentByCapability(capability);
+    }
+    async getCooperation(cooperationId) {
+        return this.sharedContext.getCooperation(cooperationId);
+    }
+    async updateAgentStatusInRegistry(status) {
+        await this.sharedContext.updateAgentStatus(this.agentId, status);
+    }
+}
+exports.PiSessionManager = PiSessionManager;
+const TOOL_DEFINITIONS = `
+可用工具:
+1. read_document(path) - 读取文档内容，支持 .txt, .md, .pdf, .docx
+2. summarize_document(path, context?) - 总结文档内容，可选提供上下文
+3. improve_document(path, requirements) - 改进文档，需提供文件路径和改进要求
+4. list_peers() - 列出已连接的对等节点
+5. send_message(peer_id, message) - 向指定对等节点发送消息
+6. broadcast_message(message) - 向所有对等节点广播消息
+7. get_identity() - 获取当前智能体身份信息
+8. set_persona(persona_json) - 更新智能体 persona，包含 name、description、personality、greeting 等
+9. run_workflow(steps) - 执行预定义工作流
+10. get_operation_logs() - 获取操作日志
+`;
+class PiAgentSession {
+    cwd;
+    peerId;
+    identity;
+    persona = null;
+    minimaxAvailable = false;
+    workflows = new Map();
+    constraintLayer;
+    workflowEngine;
+    sessionManager;
+    agentsManager;
+    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);
+    harness = null;
+    harnessEnabled = false;
+    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.sessionManager = new PiSessionManager(this.identity.did, this.cwd);
+        this.agentsManager = new heartbeat_js_1.DiscoveredAgentsManager();
+        this.initSession();
+        this.registerTools();
+        this.initHarness();
+    }
+    async initHarness() {
+        try {
+            const { createBollharnessIntegration } = await Promise.resolve().then(() => __importStar(require('../bollharness-integration/index.js')));
+            this.harness = createBollharnessIntegration();
+            this.harnessEnabled = true;
+        }
+        catch (e) {
+            console.warn('[PiAgentSession] Harness initialization failed:', e);
+            this.harnessEnabled = false;
+        }
+    }
+    registerTools() {
+        this.tools.set('read_document', {
+            name: 'read_document',
+            description: '读取文档内容，支持 .txt, .md, .pdf, .docx 格式',
+            parameters: { path: '文件路径' },
+            execute: async (args) => {
+                try {
+                    const content = await reader_js_1.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 ? '...' : ''}`
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        this.tools.set('summarize_document', {
+            name: 'summarize_document',
+            description: '总结文档内容，分析并生成摘要',
+            parameters: { path: '文件路径', context: '可选上下文信息' },
+            execute: async (args) => {
+                try {
+                    if (!this.minimaxAvailable) {
+                        return { success: false, error: 'LLM未初始化，请设置 MINIMAX_API_KEY' };
+                    }
+                    const result = await this.summarizeDocument(args.path, args.context);
+                    return {
+                        success: true,
+                        output: `📝 摘要:\n${result.summary}\n\n质量评分: ${(result.qualityScore * 10).toFixed(1)}/10`
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        this.tools.set('improve_document', {
+            name: 'improve_document',
+            description: '根据要求改进文档内容',
+            parameters: { path: '文件路径', requirements: '改进要求' },
+            execute: async (args) => {
+                try {
+                    if (!this.minimaxAvailable) {
+                        return { success: false, error: 'LLM未初始化，请设置 MINIMAX_API_KEY' };
+                    }
+                    const result = await this.improveDocument({
+                        originalPath: args.path,
+                        requirements: args.requirements
+                    });
+                    return {
+                        success: true,
+                        output: `✅ 改进${result.improved ? '成功' : '失败'}\n质量评分: ${(result.qualityScore * 10).toFixed(1)}/10\n${result.newContent ? '\n改进内容:\n' + result.newContent.substring(0, 500) + '...' : ''}`
+                    };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        this.tools.set('list_peers', {
+            name: 'list_peers',
+            description: '列出已连接的对等节点',
+            parameters: {},
+            execute: async () => {
+                const peers = p2p_js_1.p2pNetwork.getPeers();
+                if (peers.length === 0) {
+                    return { success: true, output: '当前无连接的对等节点' };
+                }
+                return { success: true, output: `已连接节点 (${peers.length}):\n${peers.map(p => `  - ${p}`).join('\n')}` };
+            }
+        });
+        this.tools.set('send_message', {
+            name: 'send_message',
+            description: '向指定对等节点发送消息',
+            parameters: { peer_id: '对等节点ID', message: '消息内容' },
+            execute: async (args) => {
+                try {
+                    await p2p_js_1.p2pNetwork.sendMessage(args.peer_id, 'message', args.message);
+                    return { success: true, output: `消息已发送到 ${args.peer_id}` };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        this.tools.set('broadcast_message', {
+            name: 'broadcast_message',
+            description: '向所有对等节点广播消息',
+            parameters: { message: '消息内容' },
+            execute: async (args) => {
+                try {
+                    await p2p_js_1.p2pNetwork.broadcast('message', args.message);
+                    return { success: true, output: '消息已广播到所有节点' };
+                }
+                catch (e) {
+                    return { success: false, error: String(e) };
+                }
+            }
+        });
+        this.tools.set('get_identity', {
+            name: 'get_identity',
+            description: '获取当前智能体身份信息',
+            parameters: {},
+            execute: async () => {
+                const id = this.getIdentity();
+                const extraInfo = id.cid ? `\nCID: ${id.cid}` : '';
+                const ipnsInfo = id.ipnsName ? `\nIPNS: ${id.ipnsName}` : '';
+                return {
+                    success: true,
+                    output: `DID: ${id.did}\n名称: ${id.name}\n公钥: ${id.publicKey}${extraInfo}${ipnsInfo}\n创建时间: ${new Date(id.createdAt).toISOString()}`
+                };
+            }
+        });
+        this.tools.set('set_persona', {
+            name: 'set_persona',
+            description: '更新智能体的 persona 信息，包括名字、描述、性格等',
+            parameters: { persona_json: 'Persona JSON 对象，包含 name、description、personality、greeting 等字段' },
+            execute: async (args) => {
+                try {
+                    const personaData = typeof args.persona_json === 'string' ? JSON.parse(args.persona_json) : args.persona_json;
+                    const now = new Date().toISOString();
+                    const newPersona = {
+                        name: personaData.name || this.identity.name,
+                        description: personaData.description || '',
+                        capabilities: personaData.capabilities || [],
+                        personality: personaData.personality || '',
+                        greeting: personaData.greeting || '',
+                        interests: personaData.interests || [],
+                        createdAt: this.persona?.createdAt || now,
+                        updatedAt: now
+                    };
+                    await this.setPersona(newPersona);
+                    this.persona = newPersona;
+                    if (newPersona.name) {
+                        this.identity.name = newPersona.name;
+                    }
+                    return { success: true, output: `Persona 已更新:\n名称: ${newPersona.name}\n描述: ${newPersona.description}\n性格: ${newPersona.personality}` };
+                }
+                catch (e) {
+                    return { success: false, error: `更新 persona 失败: ${String(e)}` };
+                }
+            }
+        });
+        this.tools.set('get_operation_logs', {
+            name: 'get_operation_logs',
+            description: '获取约束层的操作日志',
+            parameters: {},
+            execute: async () => {
+                const logs = this.constraintLayer.getLogs();
+                if (logs.length === 0) {
+                    return { success: true, output: '暂无操作日志' };
+                }
+                return {
+                    success: true,
+                    output: `操作日志 (${logs.length} 条):\n${logs.slice(-10).map(l => `[${new Date(l.timestamp).toISOString()}] ${l.action} - ${l.status}`).join('\n')}`
+                };
+            }
+        });
+    }
+    getToolDefinitions() {
+        const defs = ['可用工具:'];
+        for (const tool of this.tools.values()) {
+            const params = Object.entries(tool.parameters).map(([k, v]) => `${k}: ${v}`).join(', ');
+            defs.push(`- ${tool.name}(${params}) - ${tool.description}`);
+        }
+        return defs.join('\n');
+    }
+    async initSession() {
+        await this.sessionManager.initialize();
+        await this.agentsManager.initialize();
+        this.persona = this.sessionManager.getPersona();
+        if (this.persona?.name) {
+            this.identity.name = this.persona.name;
+        }
+    }
+    createDefaultIdentity() {
+        return {
+            did: `did:pi:${this.peerId.substring(0, 16)}`,
+            name: `Agent-${this.peerId.substring(0, 8)}`,
+            publicKey: this.peerId,
+            createdAt: Date.now()
+        };
+    }
+    checkMinimax() {
+        try {
+            (0, index_js_1.getMinimax)();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async prompt(input) {
+        this.minimaxAvailable = this.checkMinimax();
+        this.messageHistory.push({
+            role: 'user',
+            content: input
+        });
+        if (!this.minimaxAvailable) {
+            const response = await this.handleFallback(input);
+            this.messageHistory.push({ role: 'assistant', content: response });
+            return response;
+        }
+        return this.runReActLoop();
+    }
+    async promptStream(input, onStream) {
+        this.minimaxAvailable = this.checkMinimax();
+        this.messageHistory.push({
+            role: 'user',
+            content: input
+        });
+        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();
+        onStream({ type: 'done', content: '' });
+        return result;
+    }
+    async runReActLoop() {
+        const llm = (0, index_js_1.getMinimax)();
+        let iteration = 0;
+        let finalResponse = '';
+        while (iteration < this.MAX_REACT_ITERATIONS) {
+            iteration++;
+            const context = this.buildContext();
+            const toolDefs = this.getToolDefinitions();
+            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})
+
+${toolDefs}
+
+工作模式:
+1. 理解用户自然语言请求
+2. 分析需要哪些工具来完成
+3. 按顺序调用工具并观察结果
+4. 根据观察结果决定下一步
+5. 最终给出完整回答
+
+重要:
+- 每次只调用一个工具
+- 仔细分析工具返回结果
+- 如果任务完成，返回完整回答
+- 如果需要更多信息，继续调用工具`;
+            const response = await llm.chat(context, systemPrompt);
+            const reply = response.reply.trim();
+            if (this.isFinalResponse(reply)) {
+                finalResponse = this.extractFinalAnswer(reply);
+                break;
+            }
+            const toolCall = this.parseToolCall(reply);
+            if (toolCall) {
+                this.messageHistory.push({
+                    role: 'assistant',
+                    content: reply,
+                    toolCall
+                });
+                const tool = this.tools.get(toolCall.name);
+                if (!tool) {
+                    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);
+                    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}`);
+                }
+            }
+            else {
+                this.messageHistory.push({ role: 'assistant', content: reply });
+                finalResponse = reply;
+                break;
+            }
+        }
+        if (!finalResponse) {
+            finalResponse = '任务处理超时，请尝试更具体的请求。';
+        }
+        const now = new Date().toISOString();
+        const identityPrefix = `${this.identity.name} ｜ bolloon 智能体
+<environment_details>
+Current time: ${now}
+Working directory: ${this.cwd}
+Workspace root folder: ${this.cwd}
+</environment_details>
+`;
+        finalResponse = identityPrefix + finalResponse;
+        this.messageHistory.push({ role: 'assistant', content: finalResponse });
+        return finalResponse;
+    }
+    async deepThink(prompt) {
+        const result = await this.thinkingEngine.think(prompt);
+        let response = `深度思考完成（${result.depth}层）:\n\n`;
+        for (const step of result.steps) {
+            response += `第${step.step}步: ${step.thought}\n`;
+            if (step.reflection) {
+                response += `  反思: ${step.reflection}\n`;
+            }
+            if (step.improvement) {
+                response += `  改进: ${step.improvement}\n`;
+            }
+            response += '\n';
+        }
+        response += `最终输出: ${result.finalOutput}`;
+        return { result, response };
+    }
+    async processDocumentsInParallel(paths, operation, requirements) {
+        if (paths.length === 0) {
+            return { outputs: [], success: true };
+        }
+        const subtasks = paths.map((filePath, index) => ({
+            id: `doc-${index}`,
+            description: `${operation}:${filePath}${requirements ? `:${requirements}` : ''}`,
+            priority: index
+        }));
+        const dispatchPrompts = subtasks.map(t => t.description);
+        const results = await this.coordinator.dispatch(dispatchPrompts.join(' ||| '), paths.length);
+        const outputs = [];
+        let allSuccess = true;
+        for (let i = 0; i < paths.length; i++) {
+            const result = results.find((r) => r.taskId === `task-${i}`);
+            if (result) {
+                outputs.push(result.output);
+                if (!result.success)
+                    allSuccess = false;
+            }
+            else {
+                outputs.push(`No result for ${paths[i]}`);
+                allSuccess = false;
+            }
+        }
+        return { outputs, success: allSuccess };
+    }
+    buildContext() {
+        const recentMessages = this.messageHistory.slice(-10);
+        return recentMessages.map(m => {
+            if (m.role === 'user')
+                return `用户: ${m.content}`;
+            if (m.role === 'assistant')
+                return `助手: ${m.content}`;
+            if (m.role === 'tool') {
+                const result = m.toolResult ? JSON.stringify(m.toolResult) : m.content;
+                return `工具结果: ${result}`;
+            }
+            return m.content;
+        }).join('\n');
+    }
+    isFinalResponse(content) {
+        const finalMarkers = ['最终回答', '完成', '答案如下', '结果是', 'final', 'answer:', '结果:'];
+        const lower = content.toLowerCase();
+        return finalMarkers.some(m => lower.includes(m)) || (content.includes('✅') && content.length < 500);
+    }
+    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();
+        }
+        return content;
+    }
+    parseToolCall(content) {
+        const patterns = [
+            /调用工具[：:]\s*(\w+)\s*\(([^)]*)\)/,
+            /使用工具[：:]\s*(\w+)\s*\(([^)]*)\)/,
+            /tool[_\w]*[：:]\s*(\w+)\s*\(([^)]*)\)/i,
+            /(\w+)\s*\(\s*([^)]*)\s*\)/
+        ];
+        for (const pattern of patterns) {
+            const match = content.match(pattern);
+            if (match) {
+                const name = match[1];
+                const argsStr = match[2] || '';
+                const args = {};
+                const argPairs = argsStr.split(',').map(s => s.trim()).filter(Boolean);
+                for (const pair of argPairs) {
+                    const [key, ...valueParts] = pair.split(':').map(s => s.trim().replace(/['"]/g, ''));
+                    if (key) {
+                        args[key] = valueParts.join(':') || '';
+                    }
+                }
+                if (this.tools.has(name) || this.tools.has(name.replace(/_/g, '_'))) {
+                    return { name, args };
+                }
+            }
+        }
+        return null;
+    }
+    async handleFallback(input) {
+        const lowerInput = input.toLowerCase();
+        const parts = input.trim().split(/\s+/);
+        const cmd = parts[0].toLowerCase();
+        const args = parts.slice(1).join(' ');
+        if (cmd.includes('读取') || cmd === 'read' || cmd === 'read_document') {
+            if (args)
+                return await this.readDocument(args);
+        }
+        if (cmd.includes('总结') || cmd === 'summary' || cmd === 'summarize') {
+            if (args)
+                return await this.summarizeText(args);
+        }
+        if (cmd.includes('改进') || cmd === 'improve' || cmd === 'improve_document') {
+            const match = input.match(/改进[^\w]+(.+)/i) || input.match(/improve\s+(.+)/i);
+            if (match) {
+                return `改进需要LLM支持，请设置 MINIMAX_API_KEY 环境变量。\n文件: ${match[1]}`;
+            }
+        }
+        if (cmd.includes('节点') || cmd === 'peers' || cmd === 'list_peers') {
+            return this.listPeers();
+        }
+        if (cmd.includes('身份') || cmd === 'identity' || cmd === 'get_identity') {
+            return JSON.stringify(this.getIdentity(), null, 2);
+        }
+        if (cmd.includes('日志') || cmd === 'logs') {
+            const logs = this.constraintLayer.getLogs();
+            if (logs.length === 0)
+                return '暂无操作日志';
+            return logs.slice(-5).map(l => `[${new Date(l.timestamp).toISOString()}] ${l.action}`).join('\n');
+        }
+        return this.getDefaultResponse(input);
+    }
+    getDefaultResponse(input) {
+        return `收到了: "${input}"
+
+我是一个文档处理智能体，支持自然语言交互。
+
+可用操作（直接说出即可）:
+  - "读取 README.md" - 读取并分析文档
+  - "总结文档" - 总结文档内容
+  - "改进文档，按照X要求" - 改进文档
+  - "查看节点" - 查看已连接的对等节点
+  - "向X发送消息Y" - 向对等节点发送消息
+  - "广播消息X" - 广播消息到所有节点
+  - "查看身份" - 查看当前智能体身份
+  - "查看日志" - 查看最近操作日志
+
+示例请求:
+  - "读取 src/index.ts 文件"
+  - "总结一下 README.md"
+  - "查看当前连接了哪些节点"
+  - "向 QmABC... 发送测试消息"`;
+    }
+    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)();
+        try {
+            const response = await llm.chat(`根据以下对话内容，为这个对话生成一个简短的名称（不超过20个字）：\n\n${conversation}\n\n直接输出名称，不要其他解释。`, '命名建议');
+            const name = response.reply.trim();
+            if (name && name.length <= 20 && name !== '智能体') {
+                return `Agent | ${name}`;
+            }
+        }
+        catch {
+            // ignore
+        }
+        return null;
+    }
+    async summarizeText(text) {
+        if (!this.minimaxAvailable) {
+            return '⚠️ LLM未初始化，请设置 MINIMAX_API_KEY 环境变量';
+        }
+        const llm = (0, index_js_1.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);
+        this.sessionManager.addFileContext(filePath, content.text.substring(0, 1000));
+        return `📄 ${content.metadata.filename}\n大小: ${content.metadata.size} 字节\n\n${content.text.substring(0, 500)}...`;
+    }
+    async summarizeDocument(filePath, context) {
+        if (!this.minimaxAvailable) {
+            return {
+                summary: '⚠️ LLM未初始化，请设置 MINIMAX_API_KEY 环境变量',
+                qualityScore: 0
+            };
+        }
+        const content = await reader_js_1.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 summaries = [];
+        let totalQuality = 0;
+        for (const chunk of chunks) {
+            const result = await llm.summarize(chunk, context);
+            summaries.push(result.summary);
+            totalQuality += result.qualityScore;
+        }
+        const avgQuality = totalQuality / chunks.length;
+        return {
+            summary: summaries.join('\n\n'),
+            qualityScore: avgQuality
+        };
+    }
+    async improveDocument(request) {
+        if (!this.minimaxAvailable) {
+            return {
+                improved: false,
+                qualityScore: 0,
+                shouldAutoSend: false
+            };
+        }
+        const content = await reader_js_1.documentReader.read(request.originalPath);
+        const llm = (0, index_js_1.getMinimax)();
+        const improvedResult = await llm.summarize(content.text + '\n\n改进要求: ' + request.requirements, request.context);
+        const shouldAutoSend = await llm.shouldAutoSend(improvedResult.qualityScore, 0.7);
+        return {
+            improved: true,
+            newContent: improvedResult.summary,
+            qualityScore: improvedResult.qualityScore,
+            shouldAutoSend
+        };
+    }
+    async runWorkflow(steps) {
+        const context = {
+            peers: this.getPeers(),
+            logs: []
+        };
+        const checkResult = await this.constraintLayer.checkGuardrails(context);
+        if (!checkResult.passed && checkResult.blocked) {
+            console.warn(`Guardrail blocked: ${checkResult.blocked.name}`);
+        }
+        return this.workflowEngine.executeWorkflow(steps, context);
+    }
+    async summarizeDocumentWorkflow(filePath, targetPeer) {
+        const steps = [
+            {
+                id: 'read',
+                type: 'read',
+                config: { path: filePath },
+                retry: { max: 3, current: 0, backoffMs: 1000 },
+                onFail: 'abort'
+            },
+            {
+                id: 'summarize',
+                type: 'summarize',
+                config: { context: `File: ${filePath}` },
+                retry: { max: 3, current: 0, backoffMs: 1000 },
+                onFail: 'skip',
+                guardrail: (ctx) => Promise.resolve(ctx.qualityScore !== undefined && ctx.qualityScore >= 0.5)
+            }
+        ];
+        if (targetPeer) {
+            steps.push({
+                id: 'send',
+                type: 'send',
+                config: { peerId: targetPeer },
+                retry: { max: 2, current: 0, backoffMs: 2000 },
+                onFail: 'skip'
+            });
+        }
+        return this.runWorkflow(steps);
+    }
+    async improveAndSendWorkflow(filePath, requirements, targetPeer) {
+        const steps = [
+            {
+                id: 'read',
+                type: 'read',
+                config: { path: filePath },
+                retry: { max: 3, current: 0, backoffMs: 1000 },
+                onFail: 'abort'
+            },
+            {
+                id: 'improve',
+                type: 'improve',
+                config: { requirements, context: `File: ${filePath}` },
+                retry: { max: 2, current: 0, backoffMs: 1500 },
+                onFail: 'skip'
+            },
+            {
+                id: 'send',
+                type: 'send',
+                config: { peerId: targetPeer, message: '改进后的文档' },
+                retry: { max: 2, current: 0, backoffMs: 2000 },
+                onFail: 'skip'
+            }
+        ];
+        return this.runWorkflow(steps);
+    }
+    getOperationLogs() {
+        return this.constraintLayer.getLogs();
+    }
+    listPeers() {
+        const peers = p2p_js_1.p2pNetwork.getPeers();
+        if (peers.length === 0) {
+            return '当前无连接的对等节点';
+        }
+        return `已连接节点 (${peers.length}):\n${peers.map(p => `  - ${p}`).join('\n')}`;
+    }
+    getPeers() {
+        return p2p_js_1.p2pNetwork.getPeers();
+    }
+    async sendMessage(peerId, message) {
+        await p2p_js_1.p2pNetwork.sendMessage(peerId, 'message', message);
+    }
+    async broadcast(message) {
+        await p2p_js_1.p2pNetwork.broadcast('message', message);
+    }
+    getIdentity() {
+        return { ...this.identity };
+    }
+    updateIdentity(updates) {
+        this.identity = { ...this.identity, ...updates };
+    }
+    getSessionState() {
+        return this.sessionManager.getState();
+    }
+    getMemory() {
+        return this.sessionManager.getMemory();
+    }
+    getPersona() {
+        return this.sessionManager.getPersona();
+    }
+    async setPersona(persona) {
+        await this.sessionManager.savePersona(persona);
+        this.persona = persona;
+        if (persona.name) {
+            this.identity.name = persona.name;
+        }
+    }
+    getDiscoveredAgents() {
+        return this.agentsManager.getAllAgents();
+    }
+    getSocialChannels() {
+        return this.sessionManager.getAllChannels();
+    }
+    async sendSocialMessage(channelId, content) {
+        const message = {
+            id: crypto.randomUUID(),
+            type: 'ai',
+            content,
+            sender: 'self',
+            timestamp: new Date().toISOString(),
+            agentId: this.identity.did
+        };
+        await this.sessionManager.addMessage(channelId, message);
+        const channels = this.sessionManager.getAllChannels();
+        const channel = channels.find(c => c.id === channelId);
+        if (channel?.peerDid) {
+            const agent = this.agentsManager.getAgent(channel.peerDid);
+            if (agent) {
+                const comm = global.hyperswarmComm;
+                if (comm) {
+                    const connections = comm.getConnections?.() || [];
+                    for (const conn of connections) {
+                        if (conn.publicKey === agent.peerId) {
+                            const data = new TextEncoder().encode(`social|${JSON.stringify({ from: this.identity.did, message: content })}`);
+                            comm.sendToConnection?.(conn, data);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    async startSocialHeartbeat(config) {
+        if (this.socialHeartbeat) {
+            return;
+        }
+        this.socialHeartbeat = await (0, heartbeat_js_1.createSocialHeartbeat)(this.sessionManager, this.agentsManager, config);
+        this.socialHeartbeat.setOnAgentDiscovered((agent) => {
+            console.log(`[Agent] 发现新智能体: ${agent.name}`);
+        });
+        this.socialHeartbeat.setOnSocialMessage((fromDid, message, channelId) => {
+            console.log(`[Agent] 收到来自 ${fromDid} 的社交消息: ${message.substring(0, 50)}...`);
+        });
+    }
+    stopSocialHeartbeat() {
+        if (this.socialHeartbeat) {
+            this.socialHeartbeat.stop();
+            this.socialHeartbeat = null;
+        }
+    }
+    getSkillRegistry() {
+        return this.skillRegistry;
+    }
+    registerSkill(skill) {
+        this.skillRegistry.register(skill);
+    }
+    async executeSkill(name, params) {
+        return this.skillRegistry.execute(name, params);
+    }
+    async addUserAction(content, importance) {
+        await this.sessionManager.addUserActionToSharedContext(content, importance);
+    }
+    async addSharedKnowledge(knowledge) {
+        await this.sessionManager.addSharedKnowledge(knowledge);
+    }
+    async getRecentActionsSummary(count) {
+        return this.sessionManager.getRecentActionsSummary(count);
+    }
+    async getSharedKnowledge() {
+        return this.sessionManager.getSharedKnowledge();
+    }
+    async getGlobalContextSummary() {
+        return this.sessionManager.getGlobalContextSummary();
+    }
+    async createCooperation(type, task, toAgentId, context) {
+        return this.sessionManager.createCooperation(type, task, toAgentId, context);
+    }
+    async getPendingCooperations() {
+        return this.sessionManager.getPendingCooperations();
+    }
+    async updateCooperationStatus(cooperationId, status, result) {
+        return this.sessionManager.updateCooperationStatus(cooperationId, status, result);
+    }
+    async getAllRegisteredAgents() {
+        return this.sessionManager.getAllRegisteredAgents();
+    }
+    async findAgentByCapability(capability) {
+        return this.sessionManager.findAgentByCapability(capability);
+    }
+    // ==================== Harness Integration ====================
+    operationLog = [];
+    logToHarness(action, args, result) {
+        if (!this.harnessEnabled || !this.harness)
+            return;
+        this.operationLog.push({
+            timestamp: Date.now(),
+            action,
+            args,
+            result,
+            status: result.success ? 'ok' : 'error'
+        });
+        if (this.operationLog.length >= 10) {
+            this.archiveToHarness();
+        }
+    }
+    archiveToHarness() {
+        if (!this.harnessEnabled || !this.harness || this.operationLog.length === 0)
+            return;
+        this.harness.archiveSession(this.operationLog);
+        this.operationLog = [];
+    }
+    getHarnessContext() {
+        if (!this.harnessEnabled || !this.harness) {
+            return 'Harness not available';
+        }
+        return this.harness.getSessionContext();
+    }
+    isHarnessEnabled() {
+        return this.harnessEnabled;
+    }
+    getHarness() {
+        return this.harness;
+    }
+    getOperationLog() {
+        return [...this.operationLog];
+    }
+}
+let sessionInstance = null;
+let lastIdentityDid = null;
+async function createAgentSession(config) {
+    const incomingDid = config.identityDoc?.did;
+    // 如果有新的 DID，强制重建 session
+    if (sessionInstance && lastIdentityDid && incomingDid && lastIdentityDid !== incomingDid) {
+        console.log(`[createAgentSession] DID 变化 ${lastIdentityDid} -> ${incomingDid}，重建 session`);
+        sessionInstance = null;
+    }
+    if (sessionInstance) {
+        // 检查是否需要更新 identity
+        const currentDid = sessionInstance.getIdentity().did;
+        if (incomingDid && currentDid !== incomingDid) {
+            console.log(`[createAgentSession] 更新 identity: ${currentDid} -> ${incomingDid}`);
+            sessionInstance.updateIdentity({
+                did: incomingDid,
+                name: config.identityDoc?.name || sessionInstance.getIdentity().name,
+                publicKey: config.identityDoc?.publicKey || '',
+                createdAt: Date.now()
+            });
+        }
+        return sessionInstance;
+    }
+    sessionInstance = new PiAgentSession(config);
+    lastIdentityDid = config.identityDoc?.did || null;
+    console.log(`[createAgentSession] 新建 session, DID=${lastIdentityDid}`);
+    return sessionInstance;
+}
+function getAgentSession() {
+    return sessionInstance;
+}
+function resetAgentSession() {
+    sessionInstance = null;
+    lastIdentityDid = null;
+}
+//# sourceMappingURL=pi-sdk.js.map