@bolloon/bolloon-agent 0.2.9 → 0.2.11

package/dist/test/human-value-store.test.js

@@ -0,0 +1,243 @@
+/**
+ * Human Value Store 测试
+ *
+ * 测试内容：
+ * 1. 存储人类判断
+ * 2. 从反馈中学习
+ * 3. 从修正中学习
+ * 4. 获取相关价值观
+ * 5. 价值观注入到 Prompt
+ *
+ * 运行: npx tsx src/test/human-value-store.test.ts
+ */
+import { config } from 'dotenv';
+import { storeHumanJudgment, learnFromFeedback, learnFromCorrection, getRelevantValues, getValueProfile, getValueStats } from '../pi-ecosystem-judgment/human-value-store.js';
+import { generateValueInjection, generateJudgmentPromptWithValues, generateValueSummary, detectValueConflicts, suggestBasedOnValues } from '../pi-ecosystem-judgment/value-injection.js';
+config();
+// ============================================================
+// 测试数据
+// ============================================================
+const SAMPLE_JUDGMENTS = [
+    {
+        decision: '添加单元测试覆盖认证模块',
+        decision_type: 'approve',
+        reasons: ['测试是代码质量的基本保障', '认证模块是高风险区域'],
+        values_derived: [
+            { category: 'quality', value: 'test-coverage', weight: 0.9 },
+            { category: 'safety', value: 'security-first', weight: 0.8 }
+        ],
+        context: {
+            domain: 'code',
+            complexity: 'moderate',
+            stakes: 'high',
+            time_pressure: 'medium'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 0.9, revisable: false }
+    },
+    {
+        decision: '使用简单的实现方案，不要过度设计',
+        decision_type: 'approve',
+        reasons: ['简单优于复杂', '过度设计浪费资源'],
+        values_derived: [
+            { category: 'efficiency', value: 'simplicity', weight: 0.9 },
+            { category: 'efficiency', value: 'pragmatism', weight: 0.8 }
+        ],
+        context: {
+            domain: 'architecture',
+            complexity: 'moderate',
+            stakes: 'medium',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 0.85, revisable: true }
+    },
+    {
+        decision: '提交前必须通过所有测试',
+        decision_type: 'approve',
+        reasons: ['保持 CI 流程的健康', '避免破坏性提交'],
+        values_derived: [
+            { category: 'quality', value: 'ci- discipline', weight: 0.9 },
+            { category: 'collaboration', value: 'team-trust', weight: 0.7 }
+        ],
+        context: {
+            domain: 'process',
+            complexity: 'simple',
+            stakes: 'medium',
+            time_pressure: 'medium'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'trajectory', confidence: 0.9, revisable: false }
+    },
+    {
+        decision: '代码审查发现安全漏洞，需要修复后才能合并',
+        decision_type: 'approve',
+        reasons: ['安全问题是阻塞性的', '不能为了速度牺牲安全'],
+        values_derived: [
+            { category: 'safety', value: 'security-blocker', weight: 1.0 },
+            { category: 'quality', value: 'review-discipline', weight: 0.8 }
+        ],
+        context: {
+            domain: 'security',
+            complexity: 'moderate',
+            stakes: 'critical',
+            time_pressure: 'low'
+        },
+        outcome: { approved: true },
+        metadata: { source: 'explicit', confidence: 1.0, revisable: false }
+    }
+];
+// ============================================================
+// 测试函数
+// ============================================================
+async function testStoreJudgments() {
+    console.log('\n━━━ 测试: 存储人类判断 ━━━\n');
+    for (const judgment of SAMPLE_JUDGMENTS) {
+        const stored = await storeHumanJudgment(judgment);
+        console.log(`✓ 存储判断: ${stored.id}`);
+        console.log(`  决策: ${stored.decision}`);
+        console.log(`  价值观: ${stored.values_derived.map(v => v.value).join(', ')}`);
+    }
+}
+async function testLearnFromFeedback() {
+    console.log('\n━━━ 测试: 从反馈中学习 ━━━\n');
+    // 批准一个行动
+    const approved = await learnFromFeedback('添加输入验证', true, '输入验证很重要，防止注入攻击');
+    console.log(`✓ 从批准中学习: ${approved.id}`);
+    // 拒绝一个行动
+    const rejected = await learnFromFeedback('跳过测试直接提交', false, '测试是质量保障，必须执行');
+    console.log(`✓ 从拒绝中学习: ${rejected.id}`);
+}
+async function testLearnFromCorrection() {
+    console.log('\n━━━ 测试: 从修正中学习 ━━━\n');
+    const corrected = await learnFromCorrection('使用全局变量存储用户状态', '使用 Context 存储用户状态', '全局变量难以追踪和测试，Context 更清晰');
+    console.log(`✓ 从修正中学习: ${corrected.id}`);
+    console.log(`  修正前: 使用全局变量存储用户状态`);
+    console.log(`  修正后: 使用 Context 存储用户状态`);
+    console.log(`  理由: ${corrected.reasons[0]}`);
+}
+async function testGetRelevantValues() {
+    console.log('\n━━━ 测试: 获取相关价值观 ━━━\n');
+    const securityValues = await getRelevantValues('安全 认证');
+    console.log('安全/认证相关的价值观:');
+    for (const v of securityValues) {
+        console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+    }
+    const qualityValues = await getRelevantValues('测试 代码质量');
+    console.log('\n测试/代码质量相关的价值观:');
+    for (const v of qualityValues) {
+        console.log(`  - ${v.value} (权重: ${(v.weight * 100).toFixed(0)}%)`);
+    }
+}
+async function testGetValueProfile() {
+    console.log('\n━━━ 测试: 获取价值画像 ━━━\n');
+    const profile = await getValueProfile('current');
+    console.log(`决策者画像 (${profile.agent_id}):`);
+    console.log(`  - 决策总数: ${profile.decision_count}`);
+    console.log(`  - 质量关注度: ${(profile.quality_focus * 100).toFixed(0)}%`);
+    console.log(`  - 效率关注度: ${(profile.efficiency_focus * 100).toFixed(0)}%`);
+    console.log(`  - 安全关注度: ${(profile.safety_focus * 100).toFixed(0)}%`);
+    console.log(`  - 协作关注度: ${(profile.collaboration_focus * 100).toFixed(0)}%`);
+    if (profile.decision_patterns.length > 0) {
+        console.log(`  - 决策模式:`);
+        for (const p of profile.decision_patterns) {
+            console.log(`    * ${p.pattern} (频率: ${p.frequency}, 成功率: ${(p.success_rate * 100).toFixed(0)}%)`);
+        }
+    }
+    if (profile.priority_rules.length > 0) {
+        console.log(`  - 优先级规则:`);
+        for (const r of profile.priority_rules.slice(0, 3)) {
+            console.log(`    * ${r.when} → ${r.prefer}`);
+        }
+    }
+}
+async function testValueInjection() {
+    console.log('\n━━━ 测试: 价值观注入到 Prompt ━━━\n');
+    const injection = await generateValueInjection('代码安全问题', {
+        mode: 'standard',
+        maxTokens: 600,
+        includeExamples: true,
+        includeRules: true,
+        includeBoundaries: true
+    });
+    console.log('生成的价值观注入内容:');
+    console.log('─'.repeat(50));
+    console.log(injection);
+    console.log('─'.repeat(50));
+}
+async function testJudgmentPromptWithValues() {
+    console.log('\n━━━ 测试: 带价值观的判断 Prompt ━━━\n');
+    const prompt = await generateJudgmentPromptWithValues('帮我检查这段代码有没有安全漏洞', '代码安全问题', ['用户询问了登录功能', '用户提到了密码存储']);
+    console.log('生成的判断 Prompt:');
+    console.log('─'.repeat(50));
+    console.log(prompt.substring(0, 800) + '...');
+    console.log('─'.repeat(50));
+}
+async function testValueSummary() {
+    console.log('\n━━━ 测试: 价值观摘要 ━━━\n');
+    const summary = await generateValueSummary();
+    console.log(summary);
+}
+async function testDetectValueConflicts() {
+    console.log('\n━━━ 测试: 价值观冲突检测 ━━━\n');
+    const result = await detectValueConflicts('添加更多测试来保证质量', '跳过测试加快交付速度');
+    console.log(`发现冲突: ${result.hasConflict ? '是' : '否'}`);
+    if (result.conflicts.length > 0) {
+        console.log('冲突点:');
+        for (const c of result.conflicts) {
+            console.log(`  - ${c}`);
+        }
+    }
+}
+async function testSuggestBasedOnValues() {
+    console.log('\n━━━ 测试: 基于价值观建议 ━━━\n');
+    const situation = '需要选择测试框架';
+    const result = await suggestBasedOnValues(situation, [
+        'Jest - 简单易用，社区大',
+        'Vitest - 现代化，性能好',
+        'Mocha - 灵活但配置复杂'
+    ]);
+    console.log(`情况: ${situation}`);
+    console.log(`建议: ${result.recommended}`);
+    console.log(`理由: ${result.reasoning}`);
+}
+async function testGetValueStats() {
+    console.log('\n━━━ 测试: 价值观统计 ━━━\n');
+    const stats = await getValueStats();
+    console.log(`总判断数: ${stats.total_judgments}`);
+    console.log(`按类型分布:`, stats.by_type);
+    console.log(`按来源分布:`, stats.by_source);
+    console.log('Top 价值观:');
+    for (const v of stats.top_values) {
+        console.log(`  - ${v.category}: ${v.value} (${(v.weight * 100).toFixed(0)}%)`);
+    }
+}
+// ============================================================
+// 主测试
+// ============================================================
+async function main() {
+    console.log('========================================');
+    console.log('  Human Value Store & Value Injection 测试');
+    console.log('========================================');
+    try {
+        await testStoreJudgments();
+        await testLearnFromFeedback();
+        await testLearnFromCorrection();
+        await testGetRelevantValues();
+        await testGetValueProfile();
+        await testValueInjection();
+        await testJudgmentPromptWithValues();
+        await testValueSummary();
+        await testDetectValueConflicts();
+        await testSuggestBasedOnValues();
+        await testGetValueStats();
+        console.log('\n========================================');
+        console.log('  所有测试通过 ✓');
+        console.log('========================================\n');
+    }
+    catch (err) {
+        console.error('\n测试失败:', err);
+        process.exit(1);
+    }
+}
+main();

package/dist/test/hybrid-integration-test.js

@@ -0,0 +1,118 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { IrohDiscoveryService } from '../network/iroh-discovery.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+const IPFS_API = 'http://127.0.0.1:5001';
+const IPFS_GATEWAY = 'http://127.0.0.1:8080';
+async function test() {
+    console.log('╔═══════════════════════════════════════════╗');
+    console.log('║   Hybrid P2P + DIAP Integration Test    ║');
+    console.log('╚═══════════════════════════════════════════╝\n');
+    let passed = 0;
+    let failed = 0;
+    console.log('[1] Generate DIAP identity...');
+    try {
+        const keyPair = KeyManager.generate();
+        console.log('    DID:', keyPair.did.substring(0, 30) + '...');
+        console.log('    ✅ Identity generated');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[2] Create AgentAuthManager...');
+    let authManager = null;
+    try {
+        authManager = await AgentAuthManager.newWithRemoteIpfs(IPFS_API, IPFS_GATEWAY);
+        console.log('    ✅ AuthManager created');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ⚠️  AuthManager failed (IPFS may not be running):', e);
+        console.log('    Continuing without full DIAP integration...');
+        passed++;
+    }
+    console.log('\n[3] Start IrohDiscoveryService...');
+    let discovery = null;
+    try {
+        if (authManager) {
+            const keyPair = KeyManager.generate();
+            discovery = new IrohDiscoveryService({
+                agentAuthManager: authManager,
+                keyPair: keyPair,
+                agentName: 'test-agent-' + Date.now(),
+            });
+            await discovery.start();
+            const nodeId = discovery.getOwnIrohNodeId();
+            console.log('    Iroh node ID:', nodeId?.substring(0, 20) + '...');
+            console.log('    ✅ Discovery started');
+            passed++;
+        }
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[4] Create HybridMessenger...');
+    try {
+        const messenger = new HybridMessenger();
+        console.log('    Config:', JSON.stringify(messenger.getConfig()));
+        console.log('    ✅ Messenger created');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[5] Test transport selection...');
+    try {
+        const messenger = new HybridMessenger();
+        const tests = [
+            { type: 'task', size: 100, expected: 'hyperswarm' },
+            { type: 'blob', size: 100 * 1024, expected: 'iroh' },
+            { type: 'relay', size: 100, expected: 'libp2p' },
+        ];
+        for (const test of tests) {
+            console.log(`    ${test.type} (${test.size}b) ->`, test.expected);
+        }
+        console.log('    ✅ Transport selection configured');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[6] Verify iroh transport is running...');
+    try {
+        console.log('    Node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+        console.log('    Running:', irohTransport.isRunning());
+        console.log('    Peers:', irohTransport.getPeers().length);
+        console.log('    ✅ Iroh transport is running');
+        passed++;
+    }
+    catch (e) {
+        console.log('    ❌ Failed:', e);
+        failed++;
+    }
+    console.log('\n[7] Cleanup...');
+    try {
+        if (discovery) {
+            await discovery.shutdown();
+        }
+        console.log('    ✅ Cleanup complete');
+    }
+    catch (e) {
+        console.log('    ⚠️  Cleanup warning:', e);
+    }
+    console.log('\n╔═══════════════════════════════════════════╗');
+    console.log(`║  Results: ${passed} passed, ${failed} failed         ║`);
+    console.log('╚═══════════════════════════════════════════╝');
+    if (failed > 0) {
+        process.exit(1);
+    }
+}
+test().catch((e) => {
+    console.error('Test error:', e);
+    process.exit(1);
+});

package/dist/test/hybrid-messenger-verify.js

@@ -0,0 +1,55 @@
+import { irohTransport } from '../network/iroh-transport.js';
+import { HybridMessenger } from '../network/hybrid-messenger.js';
+async function testHybridMessenger() {
+    console.log('=== HybridMessenger Verification ===\n');
+    console.log('[1] Starting iroh transport...');
+    await irohTransport.start();
+    console.log('    Iroh node ID:', irohTransport.getNodeId()?.substring(0, 16) + '...');
+    console.log('    ✅ Iroh started\n');
+    console.log('[2] Creating HybridMessenger...');
+    const messenger = new HybridMessenger({
+        preferIrohForLarge: true,
+        largeThresholdBytes: 64 * 1024,
+        enableRelay: true,
+    });
+    console.log('    ✅ Messenger created\n');
+    console.log('[3] Testing transport selection logic...');
+    const config = messenger.getConfig();
+    console.log('    Config:', JSON.stringify(config));
+    console.log('    ✅ Config correct\n');
+    console.log('[4] Testing message handlers...');
+    let handlerCalled = false;
+    messenger.onMessage('task', (msg) => {
+        handlerCalled = true;
+        console.log('    Handler called for:', msg.type);
+    });
+    messenger.onWildcard((msg) => {
+        console.log('    Wildcard called for:', msg.type);
+    });
+    messenger.dispatchMessage({
+        type: 'task',
+        payload: new TextEncoder().encode('test'),
+        from: 'test-peer',
+    });
+    messenger.dispatchMessage({
+        type: 'unknown',
+        payload: new TextEncoder().encode('test'),
+        from: 'test-peer',
+    });
+    console.log('    ✅ Handlers work\n');
+    console.log('[5] Testing config modification...');
+    messenger.setLargeThreshold(1024);
+    messenger.setPreferIrohForLarge(false);
+    const newConfig = messenger.getConfig();
+    console.log('    New threshold:', newConfig.largeThresholdBytes);
+    console.log('    Prefer iroh:', newConfig.preferIrohForLarge);
+    console.log('    ✅ Config modification works\n');
+    console.log('[6] Shutting down...');
+    await irohTransport.shutdown();
+    console.log('    ✅ Shutdown complete\n');
+    console.log('=== ✅ HybridMessenger Verification Passed ===');
+}
+testHybridMessenger().catch((e) => {
+    console.error('Test failed:', e);
+    process.exit(1);
+});

package/dist/test/iroh-bistream-debug.js

@@ -0,0 +1,38 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function main() {
+    console.log('=== iroh Debug Bi-stream ===\n');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log('[Server] ID:', server.nodeId());
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log('[Client] ID:', client.nodeId());
+    console.log('\n[Connect] Client connecting...');
+    const clientConn = await client.connect(server.nodeId(), IROH_ALPN);
+    console.log('[Client] Connected!');
+    console.log('[Accept] Server accepting...');
+    const serverConn = await server.accept();
+    console.log('[Server] Accepted!');
+    console.log('\n[Bi-stream] Client opening...');
+    const clientBi = await clientConn.openBi();
+    console.log('[Client] Bi-stream opened');
+    console.log('[Bi-stream] Server accepting (with 2s timeout)...');
+    const acceptPromise = serverConn.acceptBi();
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('acceptBi timeout')), 2000));
+    try {
+        const serverBi = await Promise.race([acceptPromise, timeoutPromise]);
+        console.log('[Server] Bi-stream accepted!');
+    }
+    catch (e) {
+        console.log('[Server] Bi-stream accept error:', e.message);
+        console.log('[Debug] Checking serverConn state...');
+        console.log('  serverConn:', !!serverConn);
+        console.log('  serverConn.remoteNodeId:', serverConn?.remoteNodeId?.());
+    }
+    console.log('\n[Cleanup]');
+    clientConn.close();
+    await server.close();
+    await client.close();
+}
+main().catch(console.error);

package/dist/test/iroh-communication.test.js

@@ -0,0 +1,66 @@
+import { irohTransport } from '../network/iroh-transport.js';
+async function testTwoNodesCommunication() {
+    console.log('=== Two Node Communication Test ===\n');
+    // 启动第一个节点 (server)
+    console.log('[Node1] Starting...');
+    const node1 = await irohTransport.start();
+    console.log('[Node1] Node ID:', node1.nodeId.substring(0, 16) + '...');
+    console.log('[Node1] Addr:', node1.addr.substring(0, 32) + '...\n');
+    // 注册消息处理器
+    let messageCount = 0;
+    const messages = [];
+    irohTransport.onMessage('hello', (msg) => {
+        messageCount++;
+        messages.push(msg);
+        console.log(`[Node1] Received message #${messageCount} from ${msg.from.substring(0, 8)}...`);
+        console.log(`[Node1] Payload: ${new TextDecoder().decode(msg.payload)}`);
+    });
+    // 模拟第二个节点连接并发送消息
+    // 注意: 在实际场景中，两个节点需要在不同进程/机器上运行
+    // 这里我们测试的是单节点的消息处理能力
+    console.log('[Node1] Listening for incoming connections...\n');
+    // 等待一段时间看是否有连接
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    console.log(`[Node1] Messages received: ${messageCount}`);
+    // 测试发送消息 API (模拟)
+    console.log('\n[Node1] Testing sendMessage API...');
+    const fakeTargetId = 'c0b07356bcf4a505000000000000000000000000';
+    // 注意: 这会失败因为目标节点不存在，但测试 API 是否正常调用
+    try {
+        await irohTransport.sendMessage(fakeTargetId, 'test', new TextEncoder().encode('test'));
+    }
+    catch (e) {
+        console.log('[Node1] Expected failure:', e.message);
+    }
+    await irohTransport.shutdown();
+    console.log('\n=== Test Complete ===');
+}
+async function testMessageParsing() {
+    console.log('=== Message Parsing Test ===\n');
+    await irohTransport.start();
+    // 测试不同的消息格式
+    const testCases = [
+        { type: 'task', payload: '{"id":"1","type":"summarize"}' },
+        { type: 'relay', payload: 'forward-data' },
+        { type: 'blob', payload: 'binary-data-here' },
+    ];
+    for (const tc of testCases) {
+        const encoded = new TextEncoder().encode(tc.payload);
+        const formatted = tc.type + ':' + tc.payload;
+        console.log(`Parsed: type=${tc.type}, payload_len=${encoded.length}`);
+    }
+    await irohTransport.shutdown();
+    console.log('\n=== Parsing Test Complete ===');
+}
+runTests();
+async function runTests() {
+    try {
+        await testTwoNodesCommunication();
+        await testMessageParsing();
+        console.log('\n✅ All communication tests passed');
+    }
+    catch (e) {
+        console.error('❌ Test failed:', e);
+        process.exit(1);
+    }
+}

package/dist/test/iroh-debug-test.js

@@ -0,0 +1,57 @@
+import { Endpoint } from '@rayhanadev/iroh';
+const IROH_ALPN = 'bolloon/iroh/1';
+async function testConnection() {
+    console.log('=== iroh Connection Debug Test ===\n');
+    console.log('[1] Starting server...');
+    const server = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await server.online();
+    console.log(`    Server ID: ${server.nodeId()}`);
+    console.log(`    Server addr: ${server.addr()}`);
+    let acceptResult = null;
+    const acceptPromise = server.accept().then(conn => {
+        acceptResult = conn;
+        console.log('[Server] ✅ Connection accepted!');
+        return conn;
+    }).catch(e => {
+        console.log('[Server] ❌ Accept error:', e.message || e);
+    });
+    console.log('\n[2] Starting client...');
+    const client = await Endpoint.createWithOptions({ alpns: [IROH_ALPN] });
+    await client.online();
+    console.log(`    Client ID: ${client.nodeId()}`);
+    console.log('\n[3] Client connecting to server...');
+    const connectPromise = client.connect(server.nodeId(), IROH_ALPN)
+        .then(conn => {
+        console.log('[Client] ✅ Connected!');
+        return conn;
+    })
+        .catch(e => {
+        console.log('[Client] ❌ Connection error:', e.message || e);
+        return null;
+    });
+    console.log('    Waiting 20s for connection...');
+    const timeout = new Promise(r => setTimeout(r, 20000));
+    const result = await Promise.race([connectPromise, timeout]);
+    if (result && result !== timeout) {
+        console.log('\n[4] Connection established, testing message...');
+        const { send, recv } = await result.openBi();
+        await send.writeAll(Buffer.from('test:hello'));
+        await send.finish();
+        console.log('    Message sent');
+        await new Promise(r => setTimeout(r, 2000));
+        if (acceptResult) {
+            const data = await recv.readToEnd(1024);
+            console.log(`    ✅ Received: "${new TextDecoder().decode(data)}"`);
+            console.log('\n✅ TEST PASSED');
+        }
+    }
+    else if (!result) {
+        console.log('\n❌ Connection failed');
+    }
+    else {
+        console.log('\n⏳ Connection timed out');
+    }
+    await server.close().catch(() => { });
+    await client.close().catch(() => { });
+}
+testConnection().catch(console.error);

package/dist/test/iroh-diap-test.js

@@ -0,0 +1,71 @@
+import { AgentAuthManager, KeyManager } from '@diap/sdk';
+import { initIrohIntegration } from '../network/iroh-integration.js';
+const IPFS_API = 'http://127.0.0.1:5001';
+const IPFS_GATEWAY = 'http://127.0.0.1:8080';
+async function main() {
+    console.log('╔═══════════════════════════════════════════╗');
+    console.log('║       iroh + DIAP Integration Test       ║');
+    console.log('╚═══════════════════════════════════════════╝\n');
+    console.log('[1] Generating DIAP identity...');
+    const keyPair = KeyManager.generate();
+    console.log(`    DID: ${keyPair.did}`);
+    console.log(`    Name: test-agent-${keyPair.did.substring(0, 4)}`);
+    console.log('\n[2] Creating AgentAuthManager...');
+    const authManager = await AgentAuthManager.newWithRemoteIpfs(IPFS_API, IPFS_GATEWAY);
+    console.log('    AuthManager ready');
+    console.log('\n[3] Initializing iroh integration...');
+    const integration = await initIrohIntegration({
+        agentAuthManager: authManager,
+        keyPair: keyPair,
+        agentName: `test-agent-${keyPair.did.substring(0, 4)}`,
+        agentDescription: 'Test agent with iroh P2P transport',
+        agentTags: ['test', 'iroh'],
+        refreshIntervalMs: 5 * 60 * 1000,
+        discoveryIntervalMs: 30 * 1000,
+    });
+    const nodeId = integration.getNodeId();
+    console.log(`\n    ✅ Iroh Node ID: ${nodeId}`);
+    const registration = integration.getRegistration();
+    if (registration) {
+        console.log(`    ✅ DIAP CID: ${registration.cid}`);
+    }
+    console.log('\n[4] Setting up message handlers...');
+    integration.onMessage('ping', (msg, from) => {
+        console.log(`\n    📥 Ping from ${from.substring(0, 12)}...`);
+        console.log(`    Payload: "${new TextDecoder().decode(msg.payload)}"`);
+        console.log('    📤 Sending pong...');
+        integration.sendTo(from, 'pong', new TextEncoder().encode('pong from ' + nodeId?.substring(0, 8)));
+    });
+    integration.onMessage('task', (msg, from) => {
+        console.log(`\n    📥 Task from ${from.substring(0, 12)}...`);
+        const taskData = new TextDecoder().decode(msg.payload);
+        console.log(`    Task: ${taskData.substring(0, 80)}...`);
+    });
+    integration.onMessage('response', (msg, from) => {
+        console.log(`\n    📥 Response from ${from.substring(0, 12)}...`);
+        console.log(`    Response: "${new TextDecoder().decode(msg.payload)}"`);
+    });
+    console.log('    Handlers registered for: ping, task, response');
+    console.log('\n[5] Connection info for other peers:');
+    console.log('    ───────────────────────────────────────');
+    console.log(`    Node ID: ${nodeId}`);
+    console.log('    ───────────────────────────────────────');
+    console.log('\n    To connect another peer, use this Node ID.');
+    console.log('\n[6] Waiting for connections (60s)...');
+    let tick = 0;
+    const ticker = setInterval(() => {
+        tick++;
+        const peers = integration.getDiscoveredPeers();
+        const connected = integration.getConnectedPeers();
+        process.stdout.write(`\r    [${tick}s] Discovered: ${peers.length}, Connected: ${connected.length}   `);
+    }, 1000);
+    await new Promise(resolve => setTimeout(resolve, 60000));
+    clearInterval(ticker);
+    console.log('\n\n[7] Shutting down...');
+    await integration.shutdown();
+    console.log('Done');
+}
+main().catch(e => {
+    console.error('Error:', e);
+    process.exit(1);
+});