opc-agent 1.3.1 → 1.3.2

package/tests/mcp.test.ts

@@ -1,54 +1,54 @@
-import { describe, it, expect } from 'vitest';
-import { MCPToolRegistry, createMCPTool } from '../src/tools/mcp';
-
-describe('MCP Tool System', () => {
-  it('should register and list tools', () => {
-    const registry = new MCPToolRegistry();
-    const tool = createMCPTool('calculator', 'Basic calculator', {
-      type: 'object',
-      properties: { expression: { type: 'string' } },
-    }, async (input) => ({ content: `Result: ${input.expression}` }));
-
-    registry.register(tool);
-    expect(registry.has('calculator')).toBe(true);
-    expect(registry.list().length).toBe(1);
-    expect(registry.list()[0].name).toBe('calculator');
-  });
-
-  it('should execute a tool', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('echo', 'Echo tool', {}, async (input) => ({
-      content: `Echo: ${input.text}`,
-    })));
-
-    const result = await registry.execute('echo', { text: 'hello' });
-    expect(result.content).toBe('Echo: hello');
-    expect(result.isError).toBeUndefined();
-  });
-
-  it('should return error for missing tool', async () => {
-    const registry = new MCPToolRegistry();
-    const result = await registry.execute('nonexistent', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('not found');
-  });
-
-  it('should handle tool execution errors', async () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('failing', 'Fails', {}, async () => {
-      throw new Error('boom');
-    }));
-
-    const result = await registry.execute('failing', {});
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain('boom');
-  });
-
-  it('should unregister tools', () => {
-    const registry = new MCPToolRegistry();
-    registry.register(createMCPTool('temp', 'Temp', {}, async () => ({ content: '' })));
-    expect(registry.has('temp')).toBe(true);
-    registry.unregister('temp');
-    expect(registry.has('temp')).toBe(false);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { MCPToolRegistry, createMCPTool } from '../src/tools/mcp';
+
+describe('MCP Tool System', () => {
+  it('should register and list tools', () => {
+    const registry = new MCPToolRegistry();
+    const tool = createMCPTool('calculator', 'Basic calculator', {
+      type: 'object',
+      properties: { expression: { type: 'string' } },
+    }, async (input) => ({ content: `Result: ${input.expression}` }));
+
+    registry.register(tool);
+    expect(registry.has('calculator')).toBe(true);
+    expect(registry.list().length).toBe(1);
+    expect(registry.list()[0].name).toBe('calculator');
+  });
+
+  it('should execute a tool', async () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('echo', 'Echo tool', {}, async (input) => ({
+      content: `Echo: ${input.text}`,
+    })));
+
+    const result = await registry.execute('echo', { text: 'hello' });
+    expect(result.content).toBe('Echo: hello');
+    expect(result.isError).toBeUndefined();
+  });
+
+  it('should return error for missing tool', async () => {
+    const registry = new MCPToolRegistry();
+    const result = await registry.execute('nonexistent', {});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('not found');
+  });
+
+  it('should handle tool execution errors', async () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('failing', 'Fails', {}, async () => {
+      throw new Error('boom');
+    }));
+
+    const result = await registry.execute('failing', {});
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('boom');
+  });
+
+  it('should unregister tools', () => {
+    const registry = new MCPToolRegistry();
+    registry.register(createMCPTool('temp', 'Temp', {}, async () => ({ content: '' })));
+    expect(registry.has('temp')).toBe(true);
+    registry.unregister('temp');
+    expect(registry.has('temp')).toBe(false);
+  });
+});

package/tests/oad.test.ts

@@ -1,68 +1,68 @@
-import { describe, it, expect } from 'vitest';
-import { OADSchema } from '../src/schema/oad';
-
-describe('OAD Schema', () => {
-  it('should parse a valid OAD document', () => {
-    const doc = OADSchema.parse({
-      apiVersion: 'opc/v1',
-      kind: 'Agent',
-      metadata: { name: 'test-agent' },
-      spec: {},
-    });
-    expect(doc.metadata.name).toBe('test-agent');
-    expect(doc.metadata.version).toBe('1.0.0');
-    expect(doc.spec.model).toBe('deepseek-chat');
-  });
-
-  it('should reject invalid apiVersion', () => {
-    expect(() =>
-      OADSchema.parse({
-        apiVersion: 'v2',
-        kind: 'Agent',
-        metadata: { name: 'test' },
-        spec: {},
-      })
-    ).toThrow();
-  });
-
-  it('should parse full document with all fields', () => {
-    const doc = OADSchema.parse({
-      apiVersion: 'opc/v1',
-      kind: 'Agent',
-      metadata: {
-        name: 'full-agent',
-        version: '2.0.0',
-        description: 'A full agent',
-        author: 'Test',
-        license: 'MIT',
-        marketplace: { certified: true, category: 'support' },
-      },
-      spec: {
-        provider: { default: 'openai', allowed: ['openai'] },
-        model: 'gpt-4',
-        systemPrompt: 'You are helpful.',
-        skills: [{ name: 'faq', description: 'FAQ skill' }],
-        channels: [{ type: 'web', port: 8080 }],
-        memory: { shortTerm: true, longTerm: true },
-        dtv: {
-          trust: { level: 'certified' },
-          value: { metrics: ['response_time'] },
-        },
-      },
-    });
-    expect(doc.metadata.version).toBe('2.0.0');
-    expect(doc.spec.channels[0].port).toBe(8080);
-    expect(doc.spec.dtv?.trust?.level).toBe('certified');
-  });
-
-  it('should reject missing metadata.name', () => {
-    expect(() =>
-      OADSchema.parse({
-        apiVersion: 'opc/v1',
-        kind: 'Agent',
-        metadata: {},
-        spec: {},
-      })
-    ).toThrow();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { OADSchema } from '../src/schema/oad';
+
+describe('OAD Schema', () => {
+  it('should parse a valid OAD document', () => {
+    const doc = OADSchema.parse({
+      apiVersion: 'opc/v1',
+      kind: 'Agent',
+      metadata: { name: 'test-agent' },
+      spec: {},
+    });
+    expect(doc.metadata.name).toBe('test-agent');
+    expect(doc.metadata.version).toBe('1.0.0');
+    expect(doc.spec.model).toBe('deepseek-chat');
+  });
+
+  it('should reject invalid apiVersion', () => {
+    expect(() =>
+      OADSchema.parse({
+        apiVersion: 'v2',
+        kind: 'Agent',
+        metadata: { name: 'test' },
+        spec: {},
+      })
+    ).toThrow();
+  });
+
+  it('should parse full document with all fields', () => {
+    const doc = OADSchema.parse({
+      apiVersion: 'opc/v1',
+      kind: 'Agent',
+      metadata: {
+        name: 'full-agent',
+        version: '2.0.0',
+        description: 'A full agent',
+        author: 'Test',
+        license: 'MIT',
+        marketplace: { certified: true, category: 'support' },
+      },
+      spec: {
+        provider: { default: 'openai', allowed: ['openai'] },
+        model: 'gpt-4',
+        systemPrompt: 'You are helpful.',
+        skills: [{ name: 'faq', description: 'FAQ skill' }],
+        channels: [{ type: 'web', port: 8080 }],
+        memory: { shortTerm: true, longTerm: true },
+        dtv: {
+          trust: { level: 'certified' },
+          value: { metrics: ['response_time'] },
+        },
+      },
+    });
+    expect(doc.metadata.version).toBe('2.0.0');
+    expect(doc.spec.channels[0].port).toBe(8080);
+    expect(doc.spec.dtv?.trust?.level).toBe('certified');
+  });
+
+  it('should reject missing metadata.name', () => {
+    expect(() =>
+      OADSchema.parse({
+        apiVersion: 'opc/v1',
+        kind: 'Agent',
+        metadata: {},
+        spec: {},
+      })
+    ).toThrow();
+  });
+});

package/tests/performance.test.ts

@@ -1,115 +1,115 @@
-import { describe, it, expect } from 'vitest';
-import { ConnectionPool, RequestBatcher, LazyLoader } from '../src/core/performance';
-
-describe('ConnectionPool', () => {
-  it('should acquire and release connections', () => {
-    const pool = new ConnectionPool(3);
-    const conn = pool.acquire('openai');
-    expect(conn.inUse).toBe(true);
-    pool.release(conn.id);
-    const stats = pool.getStats();
-    expect(stats['openai'].total).toBe(1);
-    expect(stats['openai'].inUse).toBe(0);
-  });
-
-  it('should reuse released connections', () => {
-    const pool = new ConnectionPool(2);
-    const c1 = pool.acquire('openai');
-    pool.release(c1.id);
-    const c2 = pool.acquire('openai');
-    expect(c2.id).toBe(c1.id);
-  });
-
-  it('should drain all connections', () => {
-    const pool = new ConnectionPool();
-    pool.acquire('openai');
-    pool.acquire('deepseek');
-    pool.drain();
-    expect(pool.getStats()).toEqual({});
-  });
-});
-
-describe('RequestBatcher', () => {
-  it('should batch requests', async () => {
-    const batcher = new RequestBatcher<string>(
-      async (batch) => batch.map(s => s.toUpperCase()),
-      2,
-      10,
-    );
-
-    const [r1, r2] = await Promise.all([
-      batcher.add('hello'),
-      batcher.add('world'),
-    ]);
-    expect(r1).toBe('HELLO');
-    expect(r2).toBe('WORLD');
-  });
-
-  it('should flush on timer', async () => {
-    const batcher = new RequestBatcher<number>(
-      async (batch) => batch.map(n => n * 2),
-      10,
-      20,
-    );
-
-    const result = await batcher.add(5);
-    expect(result).toBe(10);
-  });
-
-  it('should track pending count', () => {
-    const batcher = new RequestBatcher<string>(
-      async (batch) => batch,
-      100,
-      10000,
-    );
-    batcher.add('a');
-    batcher.add('b');
-    expect(batcher.pending).toBe(2);
-  });
-});
-
-describe('LazyLoader', () => {
-  it('should lazily load items', async () => {
-    const loader = new LazyLoader<string>();
-    let loadCount = 0;
-    loader.register('greeting', async () => { loadCount++; return 'hello'; });
-
-    expect(loader.isLoaded('greeting')).toBe(false);
-    const val = await loader.get('greeting');
-    expect(val).toBe('hello');
-    expect(loader.isLoaded('greeting')).toBe(true);
-
-    // Second call should use cache
-    await loader.get('greeting');
-    expect(loadCount).toBe(1);
-  });
-
-  it('should throw for unregistered items', async () => {
-    const loader = new LazyLoader();
-    await expect(loader.get('unknown')).rejects.toThrow('No loader registered');
-  });
-
-  it('should evict and reload', async () => {
-    const loader = new LazyLoader<number>();
-    let count = 0;
-    loader.register('counter', async () => ++count);
-    
-    await loader.get('counter');
-    expect(loader.loadedCount).toBe(1);
-    loader.evict('counter');
-    expect(loader.loadedCount).toBe(0);
-    await loader.get('counter');
-    expect(count).toBe(2);
-  });
-
-  it('should clear all', async () => {
-    const loader = new LazyLoader<string>();
-    loader.register('a', async () => 'a');
-    loader.register('b', async () => 'b');
-    await loader.get('a');
-    await loader.get('b');
-    loader.clear();
-    expect(loader.loadedCount).toBe(0);
-    expect(loader.registeredCount).toBe(2);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { ConnectionPool, RequestBatcher, LazyLoader } from '../src/core/performance';
+
+describe('ConnectionPool', () => {
+  it('should acquire and release connections', () => {
+    const pool = new ConnectionPool(3);
+    const conn = pool.acquire('openai');
+    expect(conn.inUse).toBe(true);
+    pool.release(conn.id);
+    const stats = pool.getStats();
+    expect(stats['openai'].total).toBe(1);
+    expect(stats['openai'].inUse).toBe(0);
+  });
+
+  it('should reuse released connections', () => {
+    const pool = new ConnectionPool(2);
+    const c1 = pool.acquire('openai');
+    pool.release(c1.id);
+    const c2 = pool.acquire('openai');
+    expect(c2.id).toBe(c1.id);
+  });
+
+  it('should drain all connections', () => {
+    const pool = new ConnectionPool();
+    pool.acquire('openai');
+    pool.acquire('deepseek');
+    pool.drain();
+    expect(pool.getStats()).toEqual({});
+  });
+});
+
+describe('RequestBatcher', () => {
+  it('should batch requests', async () => {
+    const batcher = new RequestBatcher<string>(
+      async (batch) => batch.map(s => s.toUpperCase()),
+      2,
+      10,
+    );
+
+    const [r1, r2] = await Promise.all([
+      batcher.add('hello'),
+      batcher.add('world'),
+    ]);
+    expect(r1).toBe('HELLO');
+    expect(r2).toBe('WORLD');
+  });
+
+  it('should flush on timer', async () => {
+    const batcher = new RequestBatcher<number>(
+      async (batch) => batch.map(n => n * 2),
+      10,
+      20,
+    );
+
+    const result = await batcher.add(5);
+    expect(result).toBe(10);
+  });
+
+  it('should track pending count', () => {
+    const batcher = new RequestBatcher<string>(
+      async (batch) => batch,
+      100,
+      10000,
+    );
+    batcher.add('a');
+    batcher.add('b');
+    expect(batcher.pending).toBe(2);
+  });
+});
+
+describe('LazyLoader', () => {
+  it('should lazily load items', async () => {
+    const loader = new LazyLoader<string>();
+    let loadCount = 0;
+    loader.register('greeting', async () => { loadCount++; return 'hello'; });
+
+    expect(loader.isLoaded('greeting')).toBe(false);
+    const val = await loader.get('greeting');
+    expect(val).toBe('hello');
+    expect(loader.isLoaded('greeting')).toBe(true);
+
+    // Second call should use cache
+    await loader.get('greeting');
+    expect(loadCount).toBe(1);
+  });
+
+  it('should throw for unregistered items', async () => {
+    const loader = new LazyLoader();
+    await expect(loader.get('unknown')).rejects.toThrow('No loader registered');
+  });
+
+  it('should evict and reload', async () => {
+    const loader = new LazyLoader<number>();
+    let count = 0;
+    loader.register('counter', async () => ++count);
+    
+    await loader.get('counter');
+    expect(loader.loadedCount).toBe(1);
+    loader.evict('counter');
+    expect(loader.loadedCount).toBe(0);
+    await loader.get('counter');
+    expect(count).toBe(2);
+  });
+
+  it('should clear all', async () => {
+    const loader = new LazyLoader<string>();
+    loader.register('a', async () => 'a');
+    loader.register('b', async () => 'b');
+    await loader.get('a');
+    await loader.get('b');
+    loader.clear();
+    expect(loader.loadedCount).toBe(0);
+    expect(loader.registeredCount).toBe(2);
+  });
+});

package/tests/plugin.test.ts

@@ -1,74 +1,74 @@
-import { describe, it, expect } from 'vitest';
-import { PluginManager } from '../src/plugins';
-import type { IPlugin } from '../src/plugins';
-
-describe('Plugin System', () => {
-  it('should register and list plugins', () => {
-    const pm = new PluginManager();
-    const plugin: IPlugin = { name: 'test-plugin', version: '1.0.0', description: 'Test' };
-    pm.register(plugin);
-    expect(pm.has('test-plugin')).toBe(true);
-    expect(pm.list().length).toBe(1);
-    expect(pm.list()[0].name).toBe('test-plugin');
-  });
-
-  it('should run lifecycle hooks', async () => {
-    const pm = new PluginManager();
-    const calls: string[] = [];
-
-    pm.register({
-      name: 'hook-plugin',
-      version: '1.0.0',
-      hooks: {
-        beforeInit: async () => { calls.push('beforeInit'); },
-        afterInit: async () => { calls.push('afterInit'); },
-        beforeShutdown: async () => { calls.push('beforeShutdown'); },
-      },
-    });
-
-    await pm.runHook('beforeInit');
-    await pm.runHook('afterInit');
-    await pm.runHook('beforeShutdown');
-    expect(calls).toEqual(['beforeInit', 'afterInit', 'beforeShutdown']);
-  });
-
-  it('should collect skills from plugins', () => {
-    const pm = new PluginManager();
-    pm.register({
-      name: 'skill-plugin',
-      version: '1.0.0',
-      skills: [{
-        name: 'test-skill',
-        description: 'Test',
-        execute: async () => ({ handled: false, confidence: 0 }),
-      }],
-    });
-
-    expect(pm.getAllSkills().length).toBe(1);
-    expect(pm.getAllSkills()[0].name).toBe('test-skill');
-  });
-
-  it('should unregister plugins', () => {
-    const pm = new PluginManager();
-    pm.register({ name: 'temp', version: '1.0.0' });
-    pm.unregister('temp');
-    expect(pm.has('temp')).toBe(false);
-  });
-
-  it('should run hooks from multiple plugins in order', async () => {
-    const pm = new PluginManager();
-    const order: string[] = [];
-
-    pm.register({
-      name: 'p1', version: '1.0.0',
-      hooks: { beforeInit: async () => { order.push('p1'); } },
-    });
-    pm.register({
-      name: 'p2', version: '1.0.0',
-      hooks: { beforeInit: async () => { order.push('p2'); } },
-    });
-
-    await pm.runHook('beforeInit');
-    expect(order).toEqual(['p1', 'p2']);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { PluginManager } from '../src/plugins';
+import type { IPlugin } from '../src/plugins';
+
+describe('Plugin System', () => {
+  it('should register and list plugins', () => {
+    const pm = new PluginManager();
+    const plugin: IPlugin = { name: 'test-plugin', version: '1.0.0', description: 'Test' };
+    pm.register(plugin);
+    expect(pm.has('test-plugin')).toBe(true);
+    expect(pm.list().length).toBe(1);
+    expect(pm.list()[0].name).toBe('test-plugin');
+  });
+
+  it('should run lifecycle hooks', async () => {
+    const pm = new PluginManager();
+    const calls: string[] = [];
+
+    pm.register({
+      name: 'hook-plugin',
+      version: '1.0.0',
+      hooks: {
+        beforeInit: async () => { calls.push('beforeInit'); },
+        afterInit: async () => { calls.push('afterInit'); },
+        beforeShutdown: async () => { calls.push('beforeShutdown'); },
+      },
+    });
+
+    await pm.runHook('beforeInit');
+    await pm.runHook('afterInit');
+    await pm.runHook('beforeShutdown');
+    expect(calls).toEqual(['beforeInit', 'afterInit', 'beforeShutdown']);
+  });
+
+  it('should collect skills from plugins', () => {
+    const pm = new PluginManager();
+    pm.register({
+      name: 'skill-plugin',
+      version: '1.0.0',
+      skills: [{
+        name: 'test-skill',
+        description: 'Test',
+        execute: async () => ({ handled: false, confidence: 0 }),
+      }],
+    });
+
+    expect(pm.getAllSkills().length).toBe(1);
+    expect(pm.getAllSkills()[0].name).toBe('test-skill');
+  });
+
+  it('should unregister plugins', () => {
+    const pm = new PluginManager();
+    pm.register({ name: 'temp', version: '1.0.0' });
+    pm.unregister('temp');
+    expect(pm.has('temp')).toBe(false);
+  });
+
+  it('should run hooks from multiple plugins in order', async () => {
+    const pm = new PluginManager();
+    const order: string[] = [];
+
+    pm.register({
+      name: 'p1', version: '1.0.0',
+      hooks: { beforeInit: async () => { order.push('p1'); } },
+    });
+    pm.register({
+      name: 'p2', version: '1.0.0',
+      hooks: { beforeInit: async () => { order.push('p2'); } },
+    });
+
+    await pm.runHook('beforeInit');
+    expect(order).toEqual(['p1', 'p2']);
+  });
+});