opc-agent 1.2.0 → 1.2.1

package/tests/a2a.test.ts

@@ -1,66 +1,66 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { AgentRegistry } from '../src/core/a2a';
-import { BaseAgent } from '../src/core/agent';
-import { InMemoryStore } from '../src/memory';
-
-function createTestAgent(name: string): BaseAgent {
-  const agent = new BaseAgent({ name, model: 'test', systemPrompt: `I am ${name}` }, new InMemoryStore());
-  return agent;
-}
-
-describe('AgentRegistry (A2A)', () => {
-  let registry: AgentRegistry;
-
-  beforeEach(() => {
-    registry = new AgentRegistry();
-  });
-
-  it('should register and discover agents', () => {
-    const agent = createTestAgent('agent-1');
-    registry.register(agent, [{ name: 'summarize', description: 'Summarize text' }]);
-    
-    const all = registry.discover();
-    expect(all).toHaveLength(1);
-    expect(all[0].agentName).toBe('agent-1');
-  });
-
-  it('should discover by capability', () => {
-    const a1 = createTestAgent('a1');
-    const a2 = createTestAgent('a2');
-    registry.register(a1, [{ name: 'summarize', description: 'Summarize' }]);
-    registry.register(a2, [{ name: 'translate', description: 'Translate' }]);
-
-    const found = registry.discover('translate');
-    expect(found).toHaveLength(1);
-    expect(found[0].agentName).toBe('a2');
-  });
-
-  it('should unregister agents', () => {
-    const agent = createTestAgent('temp');
-    registry.register(agent, []);
-    registry.unregister('temp');
-    expect(registry.discover()).toHaveLength(0);
-  });
-
-  it('should handle request to unknown agent', async () => {
-    const response = await registry.call('a1', 'unknown', 'test', 'hello');
-    expect(response.status).toBe('error');
-  });
-
-  it('should send A2A request and get response', async () => {
-    const agent = createTestAgent('responder');
-    await agent.init();
-    registry.register(agent, [{ name: 'chat', description: 'Chat' }]);
-
-    const response = await registry.call('caller', 'responder', 'chat', 'hello');
-    expect(response.status).toBe('success');
-    expect(response.payload).toBeDefined();
-  });
-
-  it('should get agent by name', () => {
-    const agent = createTestAgent('finder');
-    registry.register(agent, []);
-    expect(registry.getAgent('finder')).toBeDefined();
-    expect(registry.getAgent('none')).toBeUndefined();
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AgentRegistry } from '../src/core/a2a';
+import { BaseAgent } from '../src/core/agent';
+import { InMemoryStore } from '../src/memory';
+
+function createTestAgent(name: string): BaseAgent {
+  const agent = new BaseAgent({ name, model: 'test', systemPrompt: `I am ${name}` }, new InMemoryStore());
+  return agent;
+}
+
+describe('AgentRegistry (A2A)', () => {
+  let registry: AgentRegistry;
+
+  beforeEach(() => {
+    registry = new AgentRegistry();
+  });
+
+  it('should register and discover agents', () => {
+    const agent = createTestAgent('agent-1');
+    registry.register(agent, [{ name: 'summarize', description: 'Summarize text' }]);
+    
+    const all = registry.discover();
+    expect(all).toHaveLength(1);
+    expect(all[0].agentName).toBe('agent-1');
+  });
+
+  it('should discover by capability', () => {
+    const a1 = createTestAgent('a1');
+    const a2 = createTestAgent('a2');
+    registry.register(a1, [{ name: 'summarize', description: 'Summarize' }]);
+    registry.register(a2, [{ name: 'translate', description: 'Translate' }]);
+
+    const found = registry.discover('translate');
+    expect(found).toHaveLength(1);
+    expect(found[0].agentName).toBe('a2');
+  });
+
+  it('should unregister agents', () => {
+    const agent = createTestAgent('temp');
+    registry.register(agent, []);
+    registry.unregister('temp');
+    expect(registry.discover()).toHaveLength(0);
+  });
+
+  it('should handle request to unknown agent', async () => {
+    const response = await registry.call('a1', 'unknown', 'test', 'hello');
+    expect(response.status).toBe('error');
+  });
+
+  it('should send A2A request and get response', async () => {
+    const agent = createTestAgent('responder');
+    await agent.init();
+    registry.register(agent, [{ name: 'chat', description: 'Chat' }]);
+
+    const response = await registry.call('caller', 'responder', 'chat', 'hello');
+    expect(response.status).toBe('success');
+    expect(response.payload).toBeDefined();
+  });
+
+  it('should get agent by name', () => {
+    const agent = createTestAgent('finder');
+    registry.register(agent, []);
+    expect(registry.getAgent('finder')).toBeDefined();
+    expect(registry.getAgent('none')).toBeUndefined();
+  });
+});

package/tests/agent.test.ts

@@ -1,72 +1,72 @@
-import { describe, it, expect } from 'vitest';
-import { BaseAgent } from '../src/core/agent';
-
-describe('BaseAgent', () => {
-  it('should start in init state', () => {
-    const agent = new BaseAgent({ name: 'test' });
-    expect(agent.state).toBe('init');
-    expect(agent.name).toBe('test');
-  });
-
-  it('should transition through lifecycle', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    const states: string[] = [];
-    agent.on('state:change', (_from, to) => states.push(to));
-
-    await agent.init();
-    expect(agent.state).toBe('ready');
-
-    await agent.start();
-    expect(agent.state).toBe('running');
-
-    await agent.stop();
-    expect(agent.state).toBe('stopped');
-
-    expect(states).toEqual(['ready', 'running', 'stopped']);
-  });
-
-  it('should not start if not ready', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    await expect(agent.start()).rejects.toThrow('Cannot start agent in state: init');
-  });
-
-  it('should handle messages with stub provider', async () => {
-    const agent = new BaseAgent({ name: 'test', systemPrompt: 'Be helpful' });
-    await agent.init();
-
-    const response = await agent.handleMessage({
-      id: 'msg_1',
-      role: 'user',
-      content: 'Hello',
-      timestamp: Date.now(),
-    });
-
-    expect(response.role).toBe('assistant');
-    expect(response.content).toContain('Hello');
-  });
-
-  it('should use skills before LLM fallback', async () => {
-    const agent = new BaseAgent({ name: 'test' });
-    await agent.init();
-
-    agent.registerSkill({
-      name: 'greeter',
-      description: 'Greets users',
-      execute: async (_ctx, msg) => {
-        if (msg.content.toLowerCase().includes('hello')) {
-          return { handled: true, response: 'Hi there!', confidence: 1.0 };
-        }
-        return { handled: false, confidence: 0 };
-      },
-    });
-
-    const response = await agent.handleMessage({
-      id: 'msg_1',
-      role: 'user',
-      content: 'Hello!',
-      timestamp: Date.now(),
-    });
-
-    expect(response.content).toBe('Hi there!');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { BaseAgent } from '../src/core/agent';
+
+describe('BaseAgent', () => {
+  it('should start in init state', () => {
+    const agent = new BaseAgent({ name: 'test' });
+    expect(agent.state).toBe('init');
+    expect(agent.name).toBe('test');
+  });
+
+  it('should transition through lifecycle', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    const states: string[] = [];
+    agent.on('state:change', (_from, to) => states.push(to));
+
+    await agent.init();
+    expect(agent.state).toBe('ready');
+
+    await agent.start();
+    expect(agent.state).toBe('running');
+
+    await agent.stop();
+    expect(agent.state).toBe('stopped');
+
+    expect(states).toEqual(['ready', 'running', 'stopped']);
+  });
+
+  it('should not start if not ready', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    await expect(agent.start()).rejects.toThrow('Cannot start agent in state: init');
+  });
+
+  it('should handle messages with stub provider', async () => {
+    const agent = new BaseAgent({ name: 'test', systemPrompt: 'Be helpful' });
+    await agent.init();
+
+    const response = await agent.handleMessage({
+      id: 'msg_1',
+      role: 'user',
+      content: 'Hello',
+      timestamp: Date.now(),
+    });
+
+    expect(response.role).toBe('assistant');
+    expect(response.content).toContain('Hello');
+  });
+
+  it('should use skills before LLM fallback', async () => {
+    const agent = new BaseAgent({ name: 'test' });
+    await agent.init();
+
+    agent.registerSkill({
+      name: 'greeter',
+      description: 'Greets users',
+      execute: async (_ctx, msg) => {
+        if (msg.content.toLowerCase().includes('hello')) {
+          return { handled: true, response: 'Hi there!', confidence: 1.0 };
+        }
+        return { handled: false, confidence: 0 };
+      },
+    });
+
+    const response = await agent.handleMessage({
+      id: 'msg_1',
+      role: 'user',
+      content: 'Hello!',
+      timestamp: Date.now(),
+    });
+
+    expect(response.content).toBe('Hi there!');
+  });
+});

package/tests/analytics.test.ts

@@ -1,50 +1,50 @@
-import { describe, it, expect } from 'vitest';
-import { Analytics } from '../src/analytics';
-
-describe('Analytics', () => {
-  it('should track messages', () => {
-    const analytics = new Analytics();
-    analytics.recordMessage(100);
-    analytics.recordMessage(200);
-    const snap = analytics.getSnapshot();
-    expect(snap.messagesProcessed).toBe(2);
-    expect(snap.avgResponseTimeMs).toBe(150);
-  });
-
-  it('should track skill usage', () => {
-    const analytics = new Analytics();
-    analytics.recordSkillUsage('faq');
-    analytics.recordSkillUsage('faq');
-    analytics.recordSkillUsage('handoff');
-    const snap = analytics.getSnapshot();
-    expect(snap.skillUsage['faq']).toBe(2);
-    expect(snap.skillUsage['handoff']).toBe(1);
-  });
-
-  it('should track errors', () => {
-    const analytics = new Analytics();
-    analytics.recordError();
-    analytics.recordError();
-    expect(analytics.getSnapshot().errorCount).toBe(2);
-  });
-
-  it('should track token usage', () => {
-    const analytics = new Analytics();
-    analytics.recordTokens(100, 50);
-    analytics.recordTokens(200, 100);
-    const snap = analytics.getSnapshot();
-    expect(snap.tokenUsage.input).toBe(300);
-    expect(snap.tokenUsage.output).toBe(150);
-    expect(snap.tokenUsage.total).toBe(450);
-  });
-
-  it('should reset analytics', () => {
-    const analytics = new Analytics();
-    analytics.recordMessage(100);
-    analytics.recordError();
-    analytics.reset();
-    const snap = analytics.getSnapshot();
-    expect(snap.messagesProcessed).toBe(0);
-    expect(snap.errorCount).toBe(0);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { Analytics } from '../src/analytics';
+
+describe('Analytics', () => {
+  it('should track messages', () => {
+    const analytics = new Analytics();
+    analytics.recordMessage(100);
+    analytics.recordMessage(200);
+    const snap = analytics.getSnapshot();
+    expect(snap.messagesProcessed).toBe(2);
+    expect(snap.avgResponseTimeMs).toBe(150);
+  });
+
+  it('should track skill usage', () => {
+    const analytics = new Analytics();
+    analytics.recordSkillUsage('faq');
+    analytics.recordSkillUsage('faq');
+    analytics.recordSkillUsage('handoff');
+    const snap = analytics.getSnapshot();
+    expect(snap.skillUsage['faq']).toBe(2);
+    expect(snap.skillUsage['handoff']).toBe(1);
+  });
+
+  it('should track errors', () => {
+    const analytics = new Analytics();
+    analytics.recordError();
+    analytics.recordError();
+    expect(analytics.getSnapshot().errorCount).toBe(2);
+  });
+
+  it('should track token usage', () => {
+    const analytics = new Analytics();
+    analytics.recordTokens(100, 50);
+    analytics.recordTokens(200, 100);
+    const snap = analytics.getSnapshot();
+    expect(snap.tokenUsage.input).toBe(300);
+    expect(snap.tokenUsage.output).toBe(150);
+    expect(snap.tokenUsage.total).toBe(450);
+  });
+
+  it('should reset analytics', () => {
+    const analytics = new Analytics();
+    analytics.recordMessage(100);
+    analytics.recordError();
+    analytics.reset();
+    const snap = analytics.getSnapshot();
+    expect(snap.messagesProcessed).toBe(0);
+    expect(snap.errorCount).toBe(0);
+  });
+});

package/tests/channel.test.ts

@@ -1,39 +1,39 @@
-import { describe, it, expect, afterEach } from 'vitest';
-import { WebChannel } from '../src/channels/web';
-
-describe('WebChannel', () => {
-  let channel: WebChannel | null = null;
-
-  afterEach(async () => {
-    if (channel) {
-      await channel.stop();
-      channel = null;
-    }
-  });
-
-  it('should create with default port', () => {
-    channel = new WebChannel();
-    expect(channel.type).toBe('web');
-  });
-
-  it('should start and stop', async () => {
-    channel = new WebChannel(0); // random port
-    channel.onMessage(async (msg) => ({
-      id: 'resp_1',
-      role: 'assistant',
-      content: `Echo: ${msg.content}`,
-      timestamp: Date.now(),
-    }));
-    await channel.start();
-    await channel.stop();
-    channel = null;
-  });
-
-  it('should handle health check', async () => {
-    channel = new WebChannel(0);
-    await channel.start();
-    // Channel is running — health endpoint is available
-    await channel.stop();
-    channel = null;
-  });
-});
+import { describe, it, expect, afterEach } from 'vitest';
+import { WebChannel } from '../src/channels/web';
+
+describe('WebChannel', () => {
+  let channel: WebChannel | null = null;
+
+  afterEach(async () => {
+    if (channel) {
+      await channel.stop();
+      channel = null;
+    }
+  });
+
+  it('should create with default port', () => {
+    channel = new WebChannel();
+    expect(channel.type).toBe('web');
+  });
+
+  it('should start and stop', async () => {
+    channel = new WebChannel(0); // random port
+    channel.onMessage(async (msg) => ({
+      id: 'resp_1',
+      role: 'assistant',
+      content: `Echo: ${msg.content}`,
+      timestamp: Date.now(),
+    }));
+    await channel.start();
+    await channel.stop();
+    channel = null;
+  });
+
+  it('should handle health check', async () => {
+    channel = new WebChannel(0);
+    await channel.start();
+    // Channel is running — health endpoint is available
+    await channel.stop();
+    channel = null;
+  });
+});