opc-agent 1.3.2 → 2.0.0

package/tests/runtime.test.ts

@@ -1,42 +1,42 @@
-import { describe, it, expect } from 'vitest';
-import { AgentRuntime } from '../src/core/runtime';
-import { createCustomerServiceConfig } from '../src/templates/customer-service';
-
-describe('AgentRuntime', () => {
-  it('should initialize from config object', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    const agent = await runtime.initialize(config);
-    expect(agent.name).toBe('customer-service');
-    expect(agent.state).toBe('ready');
-  });
-
-  it('should throw if no config loaded', async () => {
-    const runtime = new AgentRuntime();
-    await expect(runtime.initialize()).rejects.toThrow('No config loaded');
-  });
-
-  it('should register skills after initialization', async () => {
-    const runtime = new AgentRuntime();
-    const config = createCustomerServiceConfig();
-    await runtime.initialize(config);
-
-    runtime.registerSkill({
-      name: 'test-skill',
-      description: 'Test',
-      execute: async () => ({ handled: false, confidence: 0 }),
-    });
-    // No throw = success
-  });
-
-  it('should throw registering skill before init', () => {
-    const runtime = new AgentRuntime();
-    expect(() =>
-      runtime.registerSkill({
-        name: 'test',
-        description: 'Test',
-        execute: async () => ({ handled: false, confidence: 0 }),
-      })
-    ).toThrow('Agent not initialized');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { AgentRuntime } from '../src/core/runtime';
+import { createCustomerServiceConfig } from '../src/templates/customer-service';
+
+describe('AgentRuntime', () => {
+  it('should initialize from config object', async () => {
+    const runtime = new AgentRuntime();
+    const config = createCustomerServiceConfig();
+    const agent = await runtime.initialize(config);
+    expect(agent.name).toBe('customer-service');
+    expect(agent.state).toBe('ready');
+  });
+
+  it('should throw if no config loaded', async () => {
+    const runtime = new AgentRuntime();
+    await expect(runtime.initialize()).rejects.toThrow('No config loaded');
+  });
+
+  it('should register skills after initialization', async () => {
+    const runtime = new AgentRuntime();
+    const config = createCustomerServiceConfig();
+    await runtime.initialize(config);
+
+    runtime.registerSkill({
+      name: 'test-skill',
+      description: 'Test',
+      execute: async () => ({ handled: false, confidence: 0 }),
+    });
+    // No throw = success
+  });
+
+  it('should throw registering skill before init', () => {
+    const runtime = new AgentRuntime();
+    expect(() =>
+      runtime.registerSkill({
+        name: 'test',
+        description: 'Test',
+        execute: async () => ({ handled: false, confidence: 0 }),
+      })
+    ).toThrow('Agent not initialized');
+  });
+});

package/tests/sandbox.test.ts

@@ -1,46 +1,46 @@
-import { describe, it, expect } from 'vitest';
-import { Sandbox } from '../src/core/sandbox';
-
-describe('Security Sandbox', () => {
-  it('should create sandbox with trust level', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.trustLevel).toBe('sandbox');
-  });
-
-  it('should restrict shell in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(false);
-  });
-
-  it('should allow shell in certified mode', () => {
-    const sb = new Sandbox({ trustLevel: 'certified', agentDir: '/tmp/agent' });
-    expect(sb.checkShellAccess()).toBe(true);
-  });
-
-  it('should restrict network in sandbox mode', () => {
-    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://api.openai.com')).toBe(false);
-  });
-
-  it('should allow network with allowlist', () => {
-    const sb = new Sandbox({
-      trustLevel: 'sandbox',
-      agentDir: '/tmp/agent',
-      networkAllowlist: ['api.openai.com'],
-    });
-    expect(sb.checkNetworkAccess('https://api.openai.com/v1/chat')).toBe(true);
-    expect(sb.checkNetworkAccess('https://evil.com')).toBe(false);
-  });
-
-  it('should allow wildcard network in listed mode', () => {
-    const sb = new Sandbox({ trustLevel: 'listed', agentDir: '/tmp/agent' });
-    expect(sb.checkNetworkAccess('https://anything.com')).toBe(true);
-  });
-
-  it('should return restrictions snapshot', () => {
-    const sb = new Sandbox({ trustLevel: 'verified', agentDir: '/tmp/agent' });
-    const r = sb.getRestrictions();
-    expect(r.shell).toBe(false);
-    expect(r.network.allowed.length).toBeGreaterThan(0);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { Sandbox } from '../src/core/sandbox';
+
+describe('Security Sandbox', () => {
+  it('should create sandbox with trust level', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.trustLevel).toBe('sandbox');
+  });
+
+  it('should restrict shell in sandbox mode', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.checkShellAccess()).toBe(false);
+  });
+
+  it('should allow shell in certified mode', () => {
+    const sb = new Sandbox({ trustLevel: 'certified', agentDir: '/tmp/agent' });
+    expect(sb.checkShellAccess()).toBe(true);
+  });
+
+  it('should restrict network in sandbox mode', () => {
+    const sb = new Sandbox({ trustLevel: 'sandbox', agentDir: '/tmp/agent' });
+    expect(sb.checkNetworkAccess('https://api.openai.com')).toBe(false);
+  });
+
+  it('should allow network with allowlist', () => {
+    const sb = new Sandbox({
+      trustLevel: 'sandbox',
+      agentDir: '/tmp/agent',
+      networkAllowlist: ['api.openai.com'],
+    });
+    expect(sb.checkNetworkAccess('https://api.openai.com/v1/chat')).toBe(true);
+    expect(sb.checkNetworkAccess('https://evil.com')).toBe(false);
+  });
+
+  it('should allow wildcard network in listed mode', () => {
+    const sb = new Sandbox({ trustLevel: 'listed', agentDir: '/tmp/agent' });
+    expect(sb.checkNetworkAccess('https://anything.com')).toBe(true);
+  });
+
+  it('should return restrictions snapshot', () => {
+    const sb = new Sandbox({ trustLevel: 'verified', agentDir: '/tmp/agent' });
+    const r = sb.getRestrictions();
+    expect(r.shell).toBe(false);
+    expect(r.network.allowed.length).toBeGreaterThan(0);
+  });
+});

package/tests/security.test.ts

@@ -1,60 +1,60 @@
-import { describe, it, expect } from 'vitest';
-import { sanitizeInput, detectInjection, APIKeyManager } from '../src/core/security';
-
-describe('Security', () => {
-  describe('sanitizeInput', () => {
-    it('strips script tags', () => {
-      expect(sanitizeInput('<script>alert(1)</script>hello')).not.toContain('<script');
-    });
-    it('encodes HTML entities', () => {
-      const result = sanitizeInput('a < b & c > d');
-      expect(result).toContain('&lt;');
-      expect(result).toContain('&amp;');
-      expect(result).toContain('&gt;');
-    });
-  });
-
-  describe('detectInjection', () => {
-    it('detects XSS', () => {
-      const r = detectInjection('<script>alert(1)</script>');
-      expect(r.safe).toBe(false);
-      expect(r.threats).toContain('xss');
-    });
-    it('passes clean input', () => {
-      expect(detectInjection('Hello world')).toEqual({ safe: true, threats: [] });
-    });
-  });
-
-  describe('APIKeyManager', () => {
-    it('add, validate, revoke', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('key1', { label: 'test' });
-      expect(mgr.isValid('key1')).toBe(true);
-      expect(mgr.isValid('key2')).toBe(false);
-      mgr.revokeKey('key1');
-      expect(mgr.isValid('key1')).toBe(false);
-    });
-
-    it('rotate key', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('old');
-      expect(mgr.rotateKey('old', 'new')).toBe(true);
-      expect(mgr.isValid('old')).toBe(false);
-      expect(mgr.isValid('new')).toBe(true);
-    });
-
-    it('expires keys', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('expired', { expiresAt: Date.now() - 1000 });
-      expect(mgr.isValid('expired')).toBe(false);
-    });
-
-    it('listActive filters', () => {
-      const mgr = new APIKeyManager();
-      mgr.addKey('a');
-      mgr.addKey('b');
-      mgr.revokeKey('b');
-      expect(mgr.listActive().length).toBe(1);
-    });
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { sanitizeInput, detectInjection, APIKeyManager } from '../src/core/security';
+
+describe('Security', () => {
+  describe('sanitizeInput', () => {
+    it('strips script tags', () => {
+      expect(sanitizeInput('<script>alert(1)</script>hello')).not.toContain('<script');
+    });
+    it('encodes HTML entities', () => {
+      const result = sanitizeInput('a < b & c > d');
+      expect(result).toContain('&lt;');
+      expect(result).toContain('&amp;');
+      expect(result).toContain('&gt;');
+    });
+  });
+
+  describe('detectInjection', () => {
+    it('detects XSS', () => {
+      const r = detectInjection('<script>alert(1)</script>');
+      expect(r.safe).toBe(false);
+      expect(r.threats).toContain('xss');
+    });
+    it('passes clean input', () => {
+      expect(detectInjection('Hello world')).toEqual({ safe: true, threats: [] });
+    });
+  });
+
+  describe('APIKeyManager', () => {
+    it('add, validate, revoke', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('key1', { label: 'test' });
+      expect(mgr.isValid('key1')).toBe(true);
+      expect(mgr.isValid('key2')).toBe(false);
+      mgr.revokeKey('key1');
+      expect(mgr.isValid('key1')).toBe(false);
+    });
+
+    it('rotate key', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('old');
+      expect(mgr.rotateKey('old', 'new')).toBe(true);
+      expect(mgr.isValid('old')).toBe(false);
+      expect(mgr.isValid('new')).toBe(true);
+    });
+
+    it('expires keys', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('expired', { expiresAt: Date.now() - 1000 });
+      expect(mgr.isValid('expired')).toBe(false);
+    });
+
+    it('listActive filters', () => {
+      const mgr = new APIKeyManager();
+      mgr.addKey('a');
+      mgr.addKey('b');
+      mgr.revokeKey('b');
+      expect(mgr.listActive().length).toBe(1);
+    });
+  });
+});

package/tests/subagent.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SubAgentManager } from '../src/core/subagent';
+import { BaseAgent } from '../src/core/agent';
+
+// Mock the provider so we don't need real API keys
+vi.mock('../src/providers', () => ({
+  createProvider: vi.fn(() => ({
+    name: 'mock',
+    chat: vi.fn().mockResolvedValue('mock response'),
+    chatStream: vi.fn(),
+  })),
+  SUPPORTED_PROVIDERS: ['openai'],
+}));
+
+describe('SubAgentManager', () => {
+  let manager: SubAgentManager;
+
+  beforeEach(() => {
+    manager = new SubAgentManager();
+  });
+
+  it('should spawn a sub-agent and return result', async () => {
+    const result = await manager.spawn({
+      name: 'test-agent',
+      task: 'Hello',
+    });
+
+    expect(result.name).toBe('test-agent');
+    expect(result.status).toBe('completed');
+    expect(result.result).toBe('mock response');
+    expect(result.duration).toBeGreaterThanOrEqual(0);
+    expect(result.id).toMatch(/^sub_/);
+  });
+
+  it('should track agents in list', async () => {
+    await manager.spawn({ name: 'agent-1', task: 'task 1' });
+    await manager.spawn({ name: 'agent-2', task: 'task 2' });
+
+    const list = manager.list();
+    expect(list).toHaveLength(2);
+    expect(list[0].status).toBe('completed');
+    expect(list[1].status).toBe('completed');
+  });
+
+  it('should spawn parallel agents', async () => {
+    const results = await manager.spawnParallel([
+      { name: 'p1', task: 'task 1' },
+      { name: 'p2', task: 'task 2' },
+      { name: 'p3', task: 'task 3' },
+    ]);
+
+    expect(results).toHaveLength(3);
+    results.forEach((r) => {
+      expect(r.status).toBe('completed');
+      expect(r.result).toBe('mock response');
+    });
+  });
+
+  it('should kill a sub-agent', async () => {
+    const result = await manager.spawn({ name: 'killable', task: 'task' });
+
+    expect(manager.kill(result.id)).toBe(true);
+    const list = manager.list();
+    const killed = list.find((a) => a.id === result.id);
+    expect(killed?.status).toBe('killed');
+  });
+
+  it('should return false when killing non-existent agent', () => {
+    expect(manager.kill('non-existent')).toBe(false);
+  });
+
+  it('should handle timeout', async () => {
+    const { createProvider } = await import('../src/providers');
+    (createProvider as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      name: 'mock-slow',
+      chat: () => new Promise((resolve) => setTimeout(() => resolve('late'), 5000)),
+      chatStream: vi.fn(),
+    });
+
+    const result = await manager.spawn({
+      name: 'slow-agent',
+      task: 'slow task',
+      timeout: 50,
+    });
+
+    expect(result.status).toBe('timeout');
+  });
+
+  it('should handle failed agents', async () => {
+    const { createProvider } = await import('../src/providers');
+    (createProvider as ReturnType<typeof vi.fn>).mockReturnValueOnce({
+      name: 'mock-fail',
+      chat: () => Promise.reject(new Error('provider error')),
+      chatStream: vi.fn(),
+    });
+
+    const result = await manager.spawn({
+      name: 'fail-agent',
+      task: 'fail task',
+    });
+
+    expect(result.status).toBe('failed');
+    expect(result.result).toBe('provider error');
+  });
+
+  it('should list empty when no agents spawned', () => {
+    expect(manager.list()).toEqual([]);
+  });
+
+  it('should use isolated memory by default', async () => {
+    const result = await manager.spawn({
+      name: 'isolated',
+      task: 'test',
+      isolated: true,
+    });
+    expect(result.status).toBe('completed');
+  });
+});
+
+describe('BaseAgent subagent methods', () => {
+  it('should have spawnSubAgent method', () => {
+    const agent = new BaseAgent({ name: 'parent' });
+    expect(typeof agent.spawnSubAgent).toBe('function');
+  });
+
+  it('should have spawnParallel method', () => {
+    const agent = new BaseAgent({ name: 'parent' });
+    expect(typeof agent.spawnParallel).toBe('function');
+  });
+});

package/tests/telegram-discord.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import { TelegramChannel } from '../src/channels/telegram';
+import { DiscordChannel } from '../src/channels/discord';
+
+describe('TelegramChannel', () => {
+  it('should create with default config (polling mode)', () => {
+    const channel = new TelegramChannel({ token: 'test-token' });
+    expect(channel.type).toBe('telegram');
+  });
+
+  it('should create with webhook mode', () => {
+    const channel = new TelegramChannel({
+      token: 'test-token',
+      mode: 'webhook',
+      webhookUrl: 'https://example.com',
+      port: 4000,
+    });
+    expect(channel.type).toBe('telegram');
+  });
+
+  it('should warn and return if no token on start', async () => {
+    const channel = new TelegramChannel({ token: '' });
+    // Should not throw, just warn
+    await channel.start();
+    await channel.stop();
+  });
+
+  it('should support onMessage handler', () => {
+    const channel = new TelegramChannel({ token: 'test-token' });
+    const handler = async (msg: any) => ({ ...msg, role: 'assistant' as const });
+    channel.onMessage(handler);
+    // No throw = success
+    expect(channel.type).toBe('telegram');
+  });
+});
+
+describe('DiscordChannel', () => {
+  it('should create with default config', () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    expect(channel.type).toBe('discord');
+  });
+
+  it('should warn and return if no token on start', async () => {
+    const channel = new DiscordChannel({ botToken: '' });
+    await channel.start();
+    await channel.stop();
+  });
+
+  it('should support onMessage handler', () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    const handler = async (msg: any) => ({ ...msg, role: 'assistant' as const });
+    channel.onMessage(handler);
+    expect(channel.type).toBe('discord');
+  });
+
+  it('should handle stop gracefully when not started', async () => {
+    const channel = new DiscordChannel({ botToken: 'test-token' });
+    await channel.stop(); // Should not throw
+  });
+});

package/tests/templates.test.ts

@@ -1,77 +1,77 @@
-import { describe, it, expect } from 'vitest';
-import { createLegalAssistantConfig, ContractReviewSkill, ComplianceCheckSkill } from '../src/templates/legal-assistant';
-import { createFinancialAdvisorConfig, BudgetAnalysisSkill, FinancialPlanningSkill } from '../src/templates/financial-advisor';
-import { createExecutiveAssistantConfig, CalendarSkill, EmailDraftSkill, MeetingPrepSkill } from '../src/templates/executive-assistant';
-import type { AgentContext, Message, MemoryStore } from '../src/core/types';
-
-const mockMemory: MemoryStore = {
-  get: async () => null, set: async () => {}, getConversation: async () => [],
-  addMessage: async () => {}, clear: async () => {},
-};
-const ctx: AgentContext = { agentName: 'test', sessionId: 's1', messages: [], memory: mockMemory, metadata: {} };
-const msg = (content: string): Message => ({ id: '1', role: 'user', content, timestamp: Date.now() });
-
-describe('Legal Assistant Template', () => {
-  it('should create valid config', () => {
-    const config = createLegalAssistantConfig();
-    expect(config.metadata.name).toBe('legal-assistant');
-    expect(config.spec.skills).toHaveLength(2);
-  });
-
-  it('ContractReviewSkill matches contract terms', async () => {
-    const skill = new ContractReviewSkill();
-    const r = await skill.execute(ctx, msg('What is force majeure?'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('ComplianceCheckSkill matches GDPR', async () => {
-    const skill = new ComplianceCheckSkill();
-    const r = await skill.execute(ctx, msg('GDPR requirements'));
-    expect(r.handled).toBe(true);
-  });
-});
-
-describe('Financial Advisor Template', () => {
-  it('should create valid config', () => {
-    const config = createFinancialAdvisorConfig();
-    expect(config.metadata.name).toBe('financial-advisor');
-  });
-
-  it('BudgetAnalysisSkill matches budget queries', async () => {
-    const skill = new BudgetAnalysisSkill();
-    const r = await skill.execute(ctx, msg('Help with my budget'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('FinancialPlanningSkill matches investment queries', async () => {
-    const skill = new FinancialPlanningSkill();
-    const r = await skill.execute(ctx, msg('How to invest'));
-    expect(r.handled).toBe(true);
-  });
-});
-
-describe('Executive Assistant Template', () => {
-  it('should create valid config', () => {
-    const config = createExecutiveAssistantConfig();
-    expect(config.metadata.name).toBe('executive-assistant');
-    expect(config.spec.skills).toHaveLength(3);
-  });
-
-  it('CalendarSkill matches scheduling', async () => {
-    const skill = new CalendarSkill();
-    const r = await skill.execute(ctx, msg('Schedule a meeting'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('EmailDraftSkill matches email queries', async () => {
-    const skill = new EmailDraftSkill();
-    const r = await skill.execute(ctx, msg('Draft an email'));
-    expect(r.handled).toBe(true);
-  });
-
-  it('MeetingPrepSkill matches prep queries', async () => {
-    const skill = new MeetingPrepSkill();
-    const r = await skill.execute(ctx, msg('Prepare the agenda'));
-    expect(r.handled).toBe(true);
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { createLegalAssistantConfig, ContractReviewSkill, ComplianceCheckSkill } from '../src/templates/legal-assistant';
+import { createFinancialAdvisorConfig, BudgetAnalysisSkill, FinancialPlanningSkill } from '../src/templates/financial-advisor';
+import { createExecutiveAssistantConfig, CalendarSkill, EmailDraftSkill, MeetingPrepSkill } from '../src/templates/executive-assistant';
+import type { AgentContext, Message, MemoryStore } from '../src/core/types';
+
+const mockMemory: MemoryStore = {
+  get: async () => null, set: async () => {}, getConversation: async () => [],
+  addMessage: async () => {}, clear: async () => {},
+};
+const ctx: AgentContext = { agentName: 'test', sessionId: 's1', messages: [], memory: mockMemory, metadata: {} };
+const msg = (content: string): Message => ({ id: '1', role: 'user', content, timestamp: Date.now() });
+
+describe('Legal Assistant Template', () => {
+  it('should create valid config', () => {
+    const config = createLegalAssistantConfig();
+    expect(config.metadata.name).toBe('legal-assistant');
+    expect(config.spec.skills).toHaveLength(2);
+  });
+
+  it('ContractReviewSkill matches contract terms', async () => {
+    const skill = new ContractReviewSkill();
+    const r = await skill.execute(ctx, msg('What is force majeure?'));
+    expect(r.handled).toBe(true);
+  });
+
+  it('ComplianceCheckSkill matches GDPR', async () => {
+    const skill = new ComplianceCheckSkill();
+    const r = await skill.execute(ctx, msg('GDPR requirements'));
+    expect(r.handled).toBe(true);
+  });
+});
+
+describe('Financial Advisor Template', () => {
+  it('should create valid config', () => {
+    const config = createFinancialAdvisorConfig();
+    expect(config.metadata.name).toBe('financial-advisor');
+  });
+
+  it('BudgetAnalysisSkill matches budget queries', async () => {
+    const skill = new BudgetAnalysisSkill();
+    const r = await skill.execute(ctx, msg('Help with my budget'));
+    expect(r.handled).toBe(true);
+  });
+
+  it('FinancialPlanningSkill matches investment queries', async () => {
+    const skill = new FinancialPlanningSkill();
+    const r = await skill.execute(ctx, msg('How to invest'));
+    expect(r.handled).toBe(true);
+  });
+});
+
+describe('Executive Assistant Template', () => {
+  it('should create valid config', () => {
+    const config = createExecutiveAssistantConfig();
+    expect(config.metadata.name).toBe('executive-assistant');
+    expect(config.spec.skills).toHaveLength(3);
+  });
+
+  it('CalendarSkill matches scheduling', async () => {
+    const skill = new CalendarSkill();
+    const r = await skill.execute(ctx, msg('Schedule a meeting'));
+    expect(r.handled).toBe(true);
+  });
+
+  it('EmailDraftSkill matches email queries', async () => {
+    const skill = new EmailDraftSkill();
+    const r = await skill.execute(ctx, msg('Draft an email'));
+    expect(r.handled).toBe(true);
+  });
+
+  it('MeetingPrepSkill matches prep queries', async () => {
+    const skill = new MeetingPrepSkill();
+    const r = await skill.execute(ctx, msg('Prepare the agenda'));
+    expect(r.handled).toBe(true);
+  });
+});