opc-agent 4.1.0 → 4.1.1

package/tests/node-network.test.ts

@@ -1,74 +1,74 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { NodeNetwork } from '../src/core/node-network';
-
-describe('NodeNetwork', () => {
-  let network: NodeNetwork;
-
-  beforeEach(() => { network = new NodeNetwork(); });
-
-  it('should add a node', () => {
-    const node = network.addNode({ name: 'pi-1', type: 'pi', host: '192.168.1.10' });
-    expect(node.id).toBeTruthy();
-    expect(node.name).toBe('pi-1');
-    expect(network.listNodes().length).toBe(1);
-  });
-
-  it('should remove a node', () => {
-    const node = network.addNode({ name: 'test' });
-    network.removeNode(node.id);
-    expect(network.listNodes().length).toBe(0);
-  });
-
-  it('should throw on removing unknown node', () => {
-    expect(() => network.removeNode('unknown')).toThrow('not found');
-  });
-
-  it('should get node by id', () => {
-    const node = network.addNode({ name: 'desktop-1' });
-    expect(network.getNode(node.id)?.name).toBe('desktop-1');
-    expect(network.getNode('nonexistent')).toBeNull();
-  });
-
-  it('should pair a node', async () => {
-    const node = network.addNode({ name: 'phone', type: 'phone', status: 'pairing' });
-    const result = await network.pair(node.id, 'ABC123');
-    expect(result).toBe(true);
-    expect(network.getNode(node.id)?.status).toBe('online');
-  });
-
-  it('should fail pairing with short code', async () => {
-    const node = network.addNode({ name: 'phone', status: 'pairing' });
-    const result = await network.pair(node.id, 'ab');
-    expect(result).toBe(false);
-  });
-
-  it('should send command to online node', async () => {
-    const node = network.addNode({ name: 'vps', status: 'online' });
-    const result = await network.sendCommand(node.id, 'uptime');
-    expect(result.command).toBe('uptime');
-    expect(result.status).toBe('sent');
-  });
-
-  it('should throw sending to offline node', async () => {
-    const node = network.addNode({ name: 'offline', status: 'offline' });
-    await expect(network.sendCommand(node.id, 'test')).rejects.toThrow('offline');
-  });
-
-  it('should broadcast to online nodes', async () => {
-    network.addNode({ name: 'n1', status: 'online' });
-    network.addNode({ name: 'n2', status: 'online' });
-    network.addNode({ name: 'n3', status: 'offline' });
-    const results = await network.broadcast('ping');
-    expect(results.size).toBe(2);
-  });
-
-  it('should health check all nodes', async () => {
-    network.addNode({ name: 'up', status: 'online' });
-    network.addNode({ name: 'down', status: 'offline' });
-    const health = await network.healthCheck();
-    expect(health.size).toBe(2);
-    const vals = Array.from(health.values());
-    expect(vals).toContain(true);
-    expect(vals).toContain(false);
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { NodeNetwork } from '../src/core/node-network';
+
+describe('NodeNetwork', () => {
+  let network: NodeNetwork;
+
+  beforeEach(() => { network = new NodeNetwork(); });
+
+  it('should add a node', () => {
+    const node = network.addNode({ name: 'pi-1', type: 'pi', host: '192.168.1.10' });
+    expect(node.id).toBeTruthy();
+    expect(node.name).toBe('pi-1');
+    expect(network.listNodes().length).toBe(1);
+  });
+
+  it('should remove a node', () => {
+    const node = network.addNode({ name: 'test' });
+    network.removeNode(node.id);
+    expect(network.listNodes().length).toBe(0);
+  });
+
+  it('should throw on removing unknown node', () => {
+    expect(() => network.removeNode('unknown')).toThrow('not found');
+  });
+
+  it('should get node by id', () => {
+    const node = network.addNode({ name: 'desktop-1' });
+    expect(network.getNode(node.id)?.name).toBe('desktop-1');
+    expect(network.getNode('nonexistent')).toBeNull();
+  });
+
+  it('should pair a node', async () => {
+    const node = network.addNode({ name: 'phone', type: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ABC123');
+    expect(result).toBe(true);
+    expect(network.getNode(node.id)?.status).toBe('online');
+  });
+
+  it('should fail pairing with short code', async () => {
+    const node = network.addNode({ name: 'phone', status: 'pairing' });
+    const result = await network.pair(node.id, 'ab');
+    expect(result).toBe(false);
+  });
+
+  it('should send command to online node', async () => {
+    const node = network.addNode({ name: 'vps', status: 'online' });
+    const result = await network.sendCommand(node.id, 'uptime');
+    expect(result.command).toBe('uptime');
+    expect(result.status).toBe('sent');
+  });
+
+  it('should throw sending to offline node', async () => {
+    const node = network.addNode({ name: 'offline', status: 'offline' });
+    await expect(network.sendCommand(node.id, 'test')).rejects.toThrow('offline');
+  });
+
+  it('should broadcast to online nodes', async () => {
+    network.addNode({ name: 'n1', status: 'online' });
+    network.addNode({ name: 'n2', status: 'online' });
+    network.addNode({ name: 'n3', status: 'offline' });
+    const results = await network.broadcast('ping');
+    expect(results.size).toBe(2);
+  });
+
+  it('should health check all nodes', async () => {
+    network.addNode({ name: 'up', status: 'online' });
+    network.addNode({ name: 'down', status: 'offline' });
+    const health = await network.healthCheck();
+    expect(health.size).toBe(2);
+    const vals = Array.from(health.values());
+    expect(vals).toContain(true);
+    expect(vals).toContain(false);
+  });
+});

package/tests/plugin-a2a-enhanced.test.ts

@@ -1,230 +1,230 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { PluginManager } from '../src/plugins';
-import type { Plugin } from '../src/plugins';
-import { loggerPlugin } from '../src/plugins/logger';
-import { rateLimiterPlugin, createRateLimiterPlugin } from '../src/plugins/rate-limiter';
-import { contentFilterPlugin, createContentFilterPlugin } from '../src/plugins/content-filter';
-import { AgentCardRegistry } from '../src/core/a2a';
-import type { AgentCard } from '../src/core/a2a';
-
-// ── PluginManager Enhanced Tests ────────────────────────────
-
-describe('PluginManager (enhanced middleware)', () => {
-  let pm: PluginManager;
-
-  beforeEach(() => {
-    pm = new PluginManager();
-  });
-
-  it('should register and list enhanced plugins', () => {
-    const p: Plugin = { name: 'test', version: '1.0.0' };
-    pm.registerEnhanced(p);
-    expect(pm.has('test')).toBe(true);
-    expect(pm.listEnhanced()).toHaveLength(1);
-  });
-
-  it('should unregister enhanced plugins', () => {
-    pm.registerEnhanced({ name: 'tmp', version: '1.0.0' });
-    pm.unregisterEnhanced('tmp');
-    expect(pm.getEnhanced('tmp')).toBeUndefined();
-  });
-
-  it('should get enhanced plugin by name', () => {
-    pm.registerEnhanced({ name: 'foo', version: '2.0.0' });
-    expect(pm.getEnhanced('foo')?.version).toBe('2.0.0');
-  });
-
-  it('should run message middleware chain in order', async () => {
-    const order: number[] = [];
-    pm.registerEnhanced({
-      name: 'p1', version: '1.0.0',
-      onMessage: async (msg, next) => { order.push(1); return next({ ...msg, p1: true }); },
-    });
-    pm.registerEnhanced({
-      name: 'p2', version: '1.0.0',
-      onMessage: async (msg, next) => { order.push(2); return next({ ...msg, p2: true }); },
-    });
-
-    const result = await pm.runMessageMiddleware({ content: 'hi' });
-    expect(order).toEqual([1, 2]);
-    expect(result.p1).toBe(true);
-    expect(result.p2).toBe(true);
-  });
-
-  it('should run response middleware chain', async () => {
-    pm.registerEnhanced({
-      name: 'r1', version: '1.0.0',
-      onResponse: async (res, next) => next({ ...res, tagged: true }),
-    });
-
-    const result = await pm.runResponseMiddleware({ content: 'reply' });
-    expect(result.tagged).toBe(true);
-  });
-
-  it('should pass through when no middleware registered', async () => {
-    const msg = { content: 'hello' };
-    const result = await pm.runMessageMiddleware(msg);
-    expect(result).toEqual(msg);
-  });
-
-  it('middleware can short-circuit by not calling next', async () => {
-    pm.registerEnhanced({
-      name: 'blocker', version: '1.0.0',
-      onMessage: async (_msg, _next) => ({ content: 'blocked' }),
-    });
-    pm.registerEnhanced({
-      name: 'never', version: '1.0.0',
-      onMessage: async (msg, next) => { throw new Error('should not reach'); },
-    });
-
-    const result = await pm.runMessageMiddleware({ content: 'test' });
-    expect(result.content).toBe('blocked');
-  });
-
-  it('initAll calls onInit for enhanced plugins', async () => {
-    const inited: string[] = [];
-    pm.registerEnhanced({
-      name: 'init-test', version: '1.0.0',
-      onInit: async () => { inited.push('init-test'); },
-    });
-    await pm.initAll({});
-    expect(inited).toContain('init-test');
-  });
-
-  it('shutdownAll calls onShutdown for enhanced plugins', async () => {
-    const shutdown: string[] = [];
-    pm.registerEnhanced({
-      name: 'sd-test', version: '1.0.0',
-      onShutdown: async () => { shutdown.push('sd-test'); },
-    });
-    await pm.shutdownAll();
-    expect(shutdown).toContain('sd-test');
-  });
-
-  it('list() includes both legacy and enhanced plugins', () => {
-    pm.register({ name: 'legacy', version: '1.0.0' });
-    pm.registerEnhanced({ name: 'enhanced', version: '1.0.0' });
-    expect(pm.list()).toHaveLength(2);
-  });
-});
-
-// ── Built-in Plugin Tests ───────────────────────────────────
-
-describe('loggerPlugin', () => {
-  it('should log and pass through messages', async () => {
-    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const msg = { content: 'hello world' };
-    const result = await loggerPlugin.onMessage!(msg, async (m) => m);
-    expect(spy).toHaveBeenCalled();
-    expect(result.content).toBe('hello world');
-    spy.mockRestore();
-  });
-
-  it('should log and pass through responses', async () => {
-    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
-    const res = { content: 'response text' };
-    const result = await loggerPlugin.onResponse!(res, async (r) => r);
-    expect(spy).toHaveBeenCalled();
-    expect(result.content).toBe('response text');
-    spy.mockRestore();
-  });
-});
-
-describe('rateLimiterPlugin', () => {
-  it('should allow messages under limit', async () => {
-    const plugin = createRateLimiterPlugin(5);
-    const msg = { content: 'test', id: 'session-1' };
-    for (let i = 0; i < 5; i++) {
-      await plugin.onMessage!(msg, async (m) => m);
-    }
-  });
-
-  it('should reject messages over limit', async () => {
-    const plugin = createRateLimiterPlugin(2);
-    const msg = { content: 'test', id: 'session-rl' };
-    await plugin.onMessage!(msg, async (m) => m);
-    await plugin.onMessage!(msg, async (m) => m);
-    await expect(plugin.onMessage!(msg, async (m) => m)).rejects.toThrow('Rate limit exceeded');
-  });
-});
-
-describe('contentFilterPlugin', () => {
-  it('should pass clean messages', async () => {
-    const plugin = createContentFilterPlugin(['spam', 'abuse']);
-    const result = await plugin.onMessage!({ content: 'hello' }, async (m) => m);
-    expect(result.content).toBe('hello');
-  });
-
-  it('should block messages with blocked words', async () => {
-    const plugin = createContentFilterPlugin(['spam']);
-    await expect(
-      plugin.onMessage!({ content: 'this is spam' }, async (m) => m)
-    ).rejects.toThrow('Content blocked');
-  });
-});
-
-// ── AgentCardRegistry Tests ─────────────────────────────────
-
-describe('AgentCardRegistry', () => {
-  let registry: AgentCardRegistry;
-
-  beforeEach(() => {
-    registry = new AgentCardRegistry();
-  });
-
-  it('should register and list agent cards', () => {
-    registry.register({ name: 'bot', description: 'A bot', capabilities: ['chat'] });
-    expect(registry.list()).toHaveLength(1);
-  });
-
-  it('should unregister agent cards', () => {
-    registry.register({ name: 'tmp', description: 'Temp', capabilities: [] });
-    registry.unregister('tmp');
-    expect(registry.list()).toHaveLength(0);
-  });
-
-  it('should get agent by name', () => {
-    registry.register({ name: 'a1', description: 'Agent 1', capabilities: [] });
-    expect(registry.get('a1')?.name).toBe('a1');
-    expect(registry.get('missing')).toBeUndefined();
-  });
-
-  it('should find by name', () => {
-    registry.register({ name: 'search-bot', description: 'Searches', capabilities: ['search'] });
-    registry.register({ name: 'chat-bot', description: 'Chats', capabilities: ['chat'] });
-    expect(registry.find('search')).toHaveLength(1);
-    expect(registry.find('search')[0].name).toBe('search-bot');
-  });
-
-  it('should find by capability', () => {
-    registry.register({ name: 'translator', description: 'Translates', capabilities: ['translate', 'detect-lang'] });
-    const found = registry.find('translate');
-    expect(found).toHaveLength(1);
-    expect(found[0].name).toBe('translator');
-  });
-
-  it('should find by description', () => {
-    registry.register({ name: 'x', description: 'Summarizes documents', capabilities: [] });
-    expect(registry.find('summarize')).toHaveLength(1);
-  });
-
-  it('should send to local handler', async () => {
-    registry.register({
-      name: 'echo',
-      description: 'Echo agent',
-      capabilities: ['echo'],
-      handler: async (msg) => `echo: ${msg}`,
-    });
-    const result = await registry.send('echo', 'hello');
-    expect(result).toBe('echo: hello');
-  });
-
-  it('should throw when sending to unknown agent', async () => {
-    await expect(registry.send('ghost', 'hi')).rejects.toThrow("Agent 'ghost' not found");
-  });
-
-  it('should throw when agent has no handler or endpoint', async () => {
-    registry.register({ name: 'empty', description: 'No handler', capabilities: [] });
-    await expect(registry.send('empty', 'hi')).rejects.toThrow('has no handler or endpoint');
-  });
-});
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PluginManager } from '../src/plugins';
+import type { Plugin } from '../src/plugins';
+import { loggerPlugin } from '../src/plugins/logger';
+import { rateLimiterPlugin, createRateLimiterPlugin } from '../src/plugins/rate-limiter';
+import { contentFilterPlugin, createContentFilterPlugin } from '../src/plugins/content-filter';
+import { AgentCardRegistry } from '../src/core/a2a';
+import type { AgentCard } from '../src/core/a2a';
+
+// ── PluginManager Enhanced Tests ────────────────────────────
+
+describe('PluginManager (enhanced middleware)', () => {
+  let pm: PluginManager;
+
+  beforeEach(() => {
+    pm = new PluginManager();
+  });
+
+  it('should register and list enhanced plugins', () => {
+    const p: Plugin = { name: 'test', version: '1.0.0' };
+    pm.registerEnhanced(p);
+    expect(pm.has('test')).toBe(true);
+    expect(pm.listEnhanced()).toHaveLength(1);
+  });
+
+  it('should unregister enhanced plugins', () => {
+    pm.registerEnhanced({ name: 'tmp', version: '1.0.0' });
+    pm.unregisterEnhanced('tmp');
+    expect(pm.getEnhanced('tmp')).toBeUndefined();
+  });
+
+  it('should get enhanced plugin by name', () => {
+    pm.registerEnhanced({ name: 'foo', version: '2.0.0' });
+    expect(pm.getEnhanced('foo')?.version).toBe('2.0.0');
+  });
+
+  it('should run message middleware chain in order', async () => {
+    const order: number[] = [];
+    pm.registerEnhanced({
+      name: 'p1', version: '1.0.0',
+      onMessage: async (msg, next) => { order.push(1); return next({ ...msg, p1: true }); },
+    });
+    pm.registerEnhanced({
+      name: 'p2', version: '1.0.0',
+      onMessage: async (msg, next) => { order.push(2); return next({ ...msg, p2: true }); },
+    });
+
+    const result = await pm.runMessageMiddleware({ content: 'hi' });
+    expect(order).toEqual([1, 2]);
+    expect(result.p1).toBe(true);
+    expect(result.p2).toBe(true);
+  });
+
+  it('should run response middleware chain', async () => {
+    pm.registerEnhanced({
+      name: 'r1', version: '1.0.0',
+      onResponse: async (res, next) => next({ ...res, tagged: true }),
+    });
+
+    const result = await pm.runResponseMiddleware({ content: 'reply' });
+    expect(result.tagged).toBe(true);
+  });
+
+  it('should pass through when no middleware registered', async () => {
+    const msg = { content: 'hello' };
+    const result = await pm.runMessageMiddleware(msg);
+    expect(result).toEqual(msg);
+  });
+
+  it('middleware can short-circuit by not calling next', async () => {
+    pm.registerEnhanced({
+      name: 'blocker', version: '1.0.0',
+      onMessage: async (_msg, _next) => ({ content: 'blocked' }),
+    });
+    pm.registerEnhanced({
+      name: 'never', version: '1.0.0',
+      onMessage: async (msg, next) => { throw new Error('should not reach'); },
+    });
+
+    const result = await pm.runMessageMiddleware({ content: 'test' });
+    expect(result.content).toBe('blocked');
+  });
+
+  it('initAll calls onInit for enhanced plugins', async () => {
+    const inited: string[] = [];
+    pm.registerEnhanced({
+      name: 'init-test', version: '1.0.0',
+      onInit: async () => { inited.push('init-test'); },
+    });
+    await pm.initAll({});
+    expect(inited).toContain('init-test');
+  });
+
+  it('shutdownAll calls onShutdown for enhanced plugins', async () => {
+    const shutdown: string[] = [];
+    pm.registerEnhanced({
+      name: 'sd-test', version: '1.0.0',
+      onShutdown: async () => { shutdown.push('sd-test'); },
+    });
+    await pm.shutdownAll();
+    expect(shutdown).toContain('sd-test');
+  });
+
+  it('list() includes both legacy and enhanced plugins', () => {
+    pm.register({ name: 'legacy', version: '1.0.0' });
+    pm.registerEnhanced({ name: 'enhanced', version: '1.0.0' });
+    expect(pm.list()).toHaveLength(2);
+  });
+});
+
+// ── Built-in Plugin Tests ───────────────────────────────────
+
+describe('loggerPlugin', () => {
+  it('should log and pass through messages', async () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const msg = { content: 'hello world' };
+    const result = await loggerPlugin.onMessage!(msg, async (m) => m);
+    expect(spy).toHaveBeenCalled();
+    expect(result.content).toBe('hello world');
+    spy.mockRestore();
+  });
+
+  it('should log and pass through responses', async () => {
+    const spy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    const res = { content: 'response text' };
+    const result = await loggerPlugin.onResponse!(res, async (r) => r);
+    expect(spy).toHaveBeenCalled();
+    expect(result.content).toBe('response text');
+    spy.mockRestore();
+  });
+});
+
+describe('rateLimiterPlugin', () => {
+  it('should allow messages under limit', async () => {
+    const plugin = createRateLimiterPlugin(5);
+    const msg = { content: 'test', id: 'session-1' };
+    for (let i = 0; i < 5; i++) {
+      await plugin.onMessage!(msg, async (m) => m);
+    }
+  });
+
+  it('should reject messages over limit', async () => {
+    const plugin = createRateLimiterPlugin(2);
+    const msg = { content: 'test', id: 'session-rl' };
+    await plugin.onMessage!(msg, async (m) => m);
+    await plugin.onMessage!(msg, async (m) => m);
+    await expect(plugin.onMessage!(msg, async (m) => m)).rejects.toThrow('Rate limit exceeded');
+  });
+});
+
+describe('contentFilterPlugin', () => {
+  it('should pass clean messages', async () => {
+    const plugin = createContentFilterPlugin(['spam', 'abuse']);
+    const result = await plugin.onMessage!({ content: 'hello' }, async (m) => m);
+    expect(result.content).toBe('hello');
+  });
+
+  it('should block messages with blocked words', async () => {
+    const plugin = createContentFilterPlugin(['spam']);
+    await expect(
+      plugin.onMessage!({ content: 'this is spam' }, async (m) => m)
+    ).rejects.toThrow('Content blocked');
+  });
+});
+
+// ── AgentCardRegistry Tests ─────────────────────────────────
+
+describe('AgentCardRegistry', () => {
+  let registry: AgentCardRegistry;
+
+  beforeEach(() => {
+    registry = new AgentCardRegistry();
+  });
+
+  it('should register and list agent cards', () => {
+    registry.register({ name: 'bot', description: 'A bot', capabilities: ['chat'] });
+    expect(registry.list()).toHaveLength(1);
+  });
+
+  it('should unregister agent cards', () => {
+    registry.register({ name: 'tmp', description: 'Temp', capabilities: [] });
+    registry.unregister('tmp');
+    expect(registry.list()).toHaveLength(0);
+  });
+
+  it('should get agent by name', () => {
+    registry.register({ name: 'a1', description: 'Agent 1', capabilities: [] });
+    expect(registry.get('a1')?.name).toBe('a1');
+    expect(registry.get('missing')).toBeUndefined();
+  });
+
+  it('should find by name', () => {
+    registry.register({ name: 'search-bot', description: 'Searches', capabilities: ['search'] });
+    registry.register({ name: 'chat-bot', description: 'Chats', capabilities: ['chat'] });
+    expect(registry.find('search')).toHaveLength(1);
+    expect(registry.find('search')[0].name).toBe('search-bot');
+  });
+
+  it('should find by capability', () => {
+    registry.register({ name: 'translator', description: 'Translates', capabilities: ['translate', 'detect-lang'] });
+    const found = registry.find('translate');
+    expect(found).toHaveLength(1);
+    expect(found[0].name).toBe('translator');
+  });
+
+  it('should find by description', () => {
+    registry.register({ name: 'x', description: 'Summarizes documents', capabilities: [] });
+    expect(registry.find('summarize')).toHaveLength(1);
+  });
+
+  it('should send to local handler', async () => {
+    registry.register({
+      name: 'echo',
+      description: 'Echo agent',
+      capabilities: ['echo'],
+      handler: async (msg) => `echo: ${msg}`,
+    });
+    const result = await registry.send('echo', 'hello');
+    expect(result).toBe('echo: hello');
+  });
+
+  it('should throw when sending to unknown agent', async () => {
+    await expect(registry.send('ghost', 'hi')).rejects.toThrow("Agent 'ghost' not found");
+  });
+
+  it('should throw when agent has no handler or endpoint', async () => {
+    registry.register({ name: 'empty', description: 'No handler', capabilities: [] });
+    await expect(registry.send('empty', 'hi')).rejects.toThrow('has no handler or endpoint');
+  });
+});