opc-agent 4.1.2 → 4.1.3

package/tests/oad.test.ts

@@ -1,68 +0,0 @@
-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 +0,0 @@
-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-a2a-enhanced.test.ts

@@ -1,230 +0,0 @@
-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');
-  });
-});

package/tests/plugin.test.ts

@@ -1,74 +0,0 @@
-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']);
-  });
-});

package/tests/profiles.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { ProfileManager } from '../src/core/profiles';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-describe('ProfileManager', () => {
-  let tmpDir: string;
-  let pm: ProfileManager;
-
-  beforeEach(() => {
-    tmpDir = path.join(os.tmpdir(), `opc-profiles-test-${Date.now()}`);
-    pm = new ProfileManager(tmpDir);
-  });
-
-  afterEach(() => {
-    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
-  });
-
-  it('should create a profile', () => {
-    const p = pm.create('test-profile', { model: 'gpt-4o' });
-    expect(p.name).toBe('test-profile');
-    expect(p.config.model).toBe('gpt-4o');
-  });
-
-  it('should throw on duplicate create', () => {
-    pm.create('dup');
-    expect(() => pm.create('dup')).toThrow('already exists');
-  });
-
-  it('should list profiles', () => {
-    pm.create('a');
-    pm.create('b');
-    const list = pm.list();
-    expect(list).toHaveLength(2);
-    expect(list.map(p => p.name).sort()).toEqual(['a', 'b']);
-  });
-
-  it('should switch profiles', () => {
-    pm.create('prof1');
-    pm.create('prof2');
-    pm.switch('prof1');
-    expect(pm.current().name).toBe('prof1');
-    pm.switch('prof2');
-    expect(pm.current().name).toBe('prof2');
-  });
-
-  it('should delete a non-current profile', () => {
-    pm.create('keeper');
-    pm.create('goner');
-    pm.switch('keeper');
-    pm.delete('goner');
-    expect(pm.list()).toHaveLength(1);
-  });
-
-  it('should throw when deleting current profile', () => {
-    pm.create('active');
-    pm.switch('active');
-    expect(() => pm.delete('active')).toThrow('Cannot delete');
-  });
-});