opc-agent 4.1.1 → 4.1.3

package/tests/agent.test.ts

@@ -1,72 +0,0 @@
-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/agui-protocol.test.ts

@@ -1,246 +0,0 @@
-// AG-UI Protocol Tests
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import {
-  AGUIEventEmitter,
-  AGUIServer,
-  AGUIClient,
-  AGUI_EVENT_TYPES,
-  isValidEventType,
-} from '../src/protocols/agui';
-import type { AGUIEvent, AGUIRunRequest } from '../src/protocols/agui';
-
-// ─── Mock ServerResponse ─────────────────────────────────────
-
-function createMockRes() {
-  const chunks: string[] = [];
-  return {
-    chunks,
-    writeHead: vi.fn(),
-    write: vi.fn((data: string) => { chunks.push(data); return true; }),
-    end: vi.fn(),
-  };
-}
-
-function parseSSEChunks(chunks: string[]): AGUIEvent[] {
-  return chunks
-    .filter(c => c.startsWith('data: '))
-    .map(c => JSON.parse(c.slice(6).trim()));
-}
-
-// ─── Tests ───────────────────────────────────────────────────
-
-describe('AG-UI Protocol', () => {
-  describe('isValidEventType', () => {
-    it('should validate known event types', () => {
-      expect(isValidEventType('TEXT_MESSAGE_START')).toBe(true);
-      expect(isValidEventType('RUN_FINISHED')).toBe(true);
-      expect(isValidEventType('CUSTOM')).toBe(true);
-    });
-
-    it('should reject unknown event types', () => {
-      expect(isValidEventType('UNKNOWN')).toBe(false);
-      expect(isValidEventType('')).toBe(false);
-    });
-
-    it('should have all 15 event types', () => {
-      expect(AGUI_EVENT_TYPES.length).toBe(15);
-    });
-  });
-
-  describe('AGUIEventEmitter', () => {
-    let res: ReturnType<typeof createMockRes>;
-    let emitter: AGUIEventEmitter;
-
-    beforeEach(() => {
-      res = createMockRes();
-      emitter = new AGUIEventEmitter(res as any);
-    });
-
-    it('should emit SSE-formatted events', () => {
-      emitter.emit({ type: 'RUN_STARTED', runId: 'r1', timestamp: '2025-01-01T00:00:00Z' });
-      expect(res.chunks.length).toBe(1);
-      expect(res.chunks[0]).toMatch(/^data: \{.*\}\n\n$/);
-      const parsed = JSON.parse(res.chunks[0].slice(6));
-      expect(parsed.type).toBe('RUN_STARTED');
-      expect(parsed.runId).toBe('r1');
-    });
-
-    it('should emit textStart/textContent/textEnd flow', () => {
-      emitter.textStart('msg1');
-      emitter.textContent('msg1', 'Hello');
-      emitter.textContent('msg1', ' world');
-      emitter.textEnd('msg1');
-      const events = parseSSEChunks(res.chunks);
-      expect(events.length).toBe(4);
-      expect(events[0].type).toBe('TEXT_MESSAGE_START');
-      expect(events[0].messageId).toBe('msg1');
-      expect((events[0] as any).role).toBe('assistant');
-      expect(events[1].type).toBe('TEXT_MESSAGE_CONTENT');
-      expect((events[1] as any).delta).toBe('Hello');
-      expect(events[2].type).toBe('TEXT_MESSAGE_CONTENT');
-      expect((events[2] as any).delta).toBe(' world');
-      expect(events[3].type).toBe('TEXT_MESSAGE_END');
-    });
-
-    it('should emit tool call flow', () => {
-      emitter.toolCallStart('tc1', 'search');
-      emitter.toolCallArgs('tc1', '{"q":"test"}');
-      emitter.toolCallEnd('tc1');
-      const events = parseSSEChunks(res.chunks);
-      expect(events.length).toBe(3);
-      expect(events[0].type).toBe('TOOL_CALL_START');
-      expect((events[0] as any).toolCallName).toBe('search');
-      expect(events[1].type).toBe('TOOL_CALL_ARGS');
-      expect(events[2].type).toBe('TOOL_CALL_END');
-    });
-
-    it('should emit runStarted/runFinished', () => {
-      emitter.runStarted('r1', 'thread1');
-      emitter.runFinished('r1');
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('RUN_STARTED');
-      expect((events[0] as any).threadId).toBe('thread1');
-      expect(events[1].type).toBe('RUN_FINISHED');
-    });
-
-    it('should emit runError', () => {
-      emitter.runError('r1', 'Something went wrong', 'INTERNAL');
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('RUN_ERROR');
-      expect((events[0] as any).message).toBe('Something went wrong');
-      expect((events[0] as any).code).toBe('INTERNAL');
-    });
-
-    it('should emit stateSnapshot', () => {
-      emitter.stateSnapshot({ count: 42 });
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('STATE_SNAPSHOT');
-      expect((events[0] as any).snapshot.count).toBe(42);
-    });
-
-    it('should emit stateDelta', () => {
-      emitter.stateDelta([{ op: 'replace', path: '/count', value: 43 }]);
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('STATE_DELTA');
-      expect((events[0] as any).delta[0].op).toBe('replace');
-    });
-
-    it('should not emit after close', () => {
-      emitter.close();
-      emitter.textStart('msg1');
-      expect(res.chunks.length).toBe(0);
-      expect(res.end).toHaveBeenCalled();
-    });
-
-    it('should include timestamp on convenience methods', () => {
-      emitter.textStart('msg1');
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].timestamp).toBeDefined();
-      expect(typeof events[0].timestamp).toBe('string');
-    });
-
-    it('should emit step events', () => {
-      emitter.stepStarted('s1', 'process');
-      emitter.stepFinished('s1');
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('STEP_STARTED');
-      expect((events[0] as any).stepName).toBe('process');
-      expect(events[1].type).toBe('STEP_FINISHED');
-    });
-
-    it('should emit custom events', () => {
-      emitter.custom('my_event', { foo: 'bar' });
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('CUSTOM');
-      expect((events[0] as any).name).toBe('my_event');
-      expect((events[0] as any).value.foo).toBe('bar');
-    });
-
-    it('should emit messagesSnapshot', () => {
-      emitter.messagesSnapshot([{ id: 'm1', role: 'user', content: 'hi' }]);
-      const events = parseSSEChunks(res.chunks);
-      expect(events[0].type).toBe('MESSAGES_SNAPSHOT');
-      expect((events[0] as any).messages[0].content).toBe('hi');
-    });
-  });
-
-  describe('AGUIServer', () => {
-    it('should construct with default path', () => {
-      const mockAgent = { handleMessage: vi.fn(), handleMessageStream: vi.fn() };
-      const server = new AGUIServer(mockAgent as any);
-      expect(server).toBeDefined();
-    });
-
-    it('should handle run request with mock agent', async () => {
-      const mockAgent = {
-        handleMessage: vi.fn().mockResolvedValue({ content: 'Hello!' }),
-        handleMessageStream: async function* () { yield 'Hel'; yield 'lo!'; },
-      };
-      const server = new AGUIServer(mockAgent as any);
-      const res = createMockRes();
-
-      // Simulate request
-      const body = JSON.stringify({
-        messages: [{ id: 'msg1', role: 'user', content: 'Hi' }],
-      });
-      const req = {
-        [Symbol.asyncIterator]: async function* () { yield body; },
-      };
-
-      await server.handleRun(req as any, res as any);
-
-      expect(res.writeHead).toHaveBeenCalledWith(200, expect.objectContaining({
-        'Content-Type': 'text/event-stream',
-      }));
-
-      const events = parseSSEChunks(res.chunks);
-      const types = events.map(e => e.type);
-      expect(types).toContain('RUN_STARTED');
-      expect(types).toContain('TEXT_MESSAGE_START');
-      expect(types).toContain('TEXT_MESSAGE_CONTENT');
-      expect(types).toContain('TEXT_MESSAGE_END');
-      expect(types).toContain('RUN_FINISHED');
-    });
-
-    it('should return 400 for invalid JSON', async () => {
-      const mockAgent = { handleMessage: vi.fn() };
-      const server = new AGUIServer(mockAgent as any);
-      const res = createMockRes();
-      const req = { [Symbol.asyncIterator]: async function* () { yield 'not json'; } };
-
-      await server.handleRun(req as any, res as any);
-      expect(res.writeHead).toHaveBeenCalledWith(400, expect.any(Object));
-    });
-
-    it('should return 400 for missing messages', async () => {
-      const mockAgent = { handleMessage: vi.fn() };
-      const server = new AGUIServer(mockAgent as any);
-      const res = createMockRes();
-      const req = { [Symbol.asyncIterator]: async function* () { yield '{}'; } };
-
-      await server.handleRun(req as any, res as any);
-      expect(res.writeHead).toHaveBeenCalledWith(400, expect.any(Object));
-    });
-  });
-
-  describe('AGUIClient', () => {
-    it('should construct with endpoint', () => {
-      const client = new AGUIClient('http://localhost:3000/agui');
-      expect(client).toBeDefined();
-    });
-
-    it('should abort cleanly', () => {
-      const client = new AGUIClient('http://localhost:3000/agui');
-      // Should not throw when no active request
-      client.abort();
-    });
-  });
-
-  describe('Protocol list includes agui', () => {
-    it('should have agui in AGUI_EVENT_TYPES constants', () => {
-      expect(AGUI_EVENT_TYPES).toContain('TEXT_MESSAGE_START');
-      expect(AGUI_EVENT_TYPES).toContain('RUN_STARTED');
-      expect(AGUI_EVENT_TYPES).toContain('TOOL_CALL_START');
-    });
-  });
-});

package/tests/analytics.test.ts

@@ -1,50 +0,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/api-server.test.ts

@@ -1,148 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { APIServer } from '../src/core/api-server';
-
-function createMockAgent(overrides: any = {}) {
-  return {
-    name: 'test-agent',
-    state: 'running',
-    config: { model: 'test-model', name: 'test-agent' },
-    chat: async (msg: string) => `echo: ${msg}`,
-    ...overrides,
-  };
-}
-
-async function request(port: number, method: string, path: string, body?: any, headers?: Record<string, string>) {
-  const res = await fetch(`http://127.0.0.1:${port}${path}`, {
-    method,
-    headers: { 'Content-Type': 'application/json', ...headers },
-    body: body ? JSON.stringify(body) : undefined,
-  });
-  return res;
-}
-
-describe('APIServer', () => {
-  let server: APIServer;
-  const port = 19876;
-
-  beforeAll(async () => {
-    server = new APIServer({ port, host: '127.0.0.1', agent: createMockAgent() });
-    await server.start();
-  });
-  afterAll(async () => { await server.stop(); });
-
-  it('GET /health returns ok', async () => {
-    const res = await request(port, 'GET', '/health');
-    expect(res.status).toBe(200);
-    const data: any = await res.json();
-    expect(data.status).toBe('ok');
-  });
-
-  it('GET /v1/models lists models', async () => {
-    const res = await request(port, 'GET', '/v1/models');
-    const data: any = await res.json();
-    expect(data.object).toBe('list');
-    expect(data.data[0].id).toBe('test-model');
-  });
-
-  it('GET /v1/agent/status returns agent info', async () => {
-    const res = await request(port, 'GET', '/v1/agent/status');
-    const data: any = await res.json();
-    expect(data.name).toBe('test-agent');
-    expect(data.state).toBe('running');
-  });
-
-  it('POST /v1/chat/completions non-streaming', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', {
-      model: 'test-model',
-      messages: [{ role: 'user', content: 'hello' }],
-    });
-    expect(res.status).toBe(200);
-    const data: any = await res.json();
-    expect(data.choices[0].message.content).toBe('echo: hello');
-    expect(data.choices[0].finish_reason).toBe('stop');
-    expect(data.id).toMatch(/^chatcmpl-/);
-    expect(data.object).toBe('chat.completion');
-  });
-
-  it('POST /v1/chat/completions streaming', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', {
-      messages: [{ role: 'user', content: 'hi' }],
-      stream: true,
-    });
-    expect(res.status).toBe(200);
-    expect(res.headers.get('content-type')).toBe('text/event-stream');
-    const text = await res.text();
-    expect(text).toContain('data: ');
-    expect(text).toContain('[DONE]');
-    // Parse SSE chunks
-    const chunks = text.split('\n').filter(l => l.startsWith('data: ') && !l.includes('[DONE]'));
-    expect(chunks.length).toBeGreaterThan(0);
-    const first = JSON.parse(chunks[0].slice(6));
-    expect(first.object).toBe('chat.completion.chunk');
-  });
-
-  it('POST /v1/chat/completions rejects missing messages', async () => {
-    const res = await request(port, 'POST', '/v1/chat/completions', { model: 'x' });
-    expect(res.status).toBe(400);
-    const data: any = await res.json();
-    expect(data.error.type).toBe('invalid_request_error');
-  });
-
-  it('POST /v1/chat/completions rejects invalid JSON', async () => {
-    const res = await fetch(`http://127.0.0.1:${port}/v1/chat/completions`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: 'not json',
-    });
-    expect(res.status).toBe(400);
-  });
-
-  it('OPTIONS returns CORS headers', async () => {
-    const res = await fetch(`http://127.0.0.1:${port}/v1/models`, { method: 'OPTIONS' });
-    expect(res.status).toBe(204);
-    expect(res.headers.get('access-control-allow-origin')).toBe('*');
-  });
-
-  it('unknown route returns 404', async () => {
-    const res = await request(port, 'GET', '/v1/unknown');
-    expect(res.status).toBe(404);
-    const data: any = await res.json();
-    expect(data.error.code).toBe(404);
-  });
-
-  it('POST /v1/embeddings returns 501 without embed provider', async () => {
-    const res = await request(port, 'POST', '/v1/embeddings', { input: 'hello' });
-    expect(res.status).toBe(501);
-  });
-
-  it('POST /v1/embeddings rejects missing input', async () => {
-    const res = await request(port, 'POST', '/v1/embeddings', { model: 'x' });
-    expect(res.status).toBe(400);
-  });
-});
-
-describe('APIServer with auth', () => {
-  let server: APIServer;
-  const port = 19877;
-
-  beforeAll(async () => {
-    server = new APIServer({ port, host: '127.0.0.1', apiKey: 'secret-key', agent: createMockAgent() });
-    await server.start();
-  });
-  afterAll(async () => { await server.stop(); });
-
-  it('rejects unauthenticated requests', async () => {
-    const res = await request(port, 'GET', '/v1/models');
-    expect(res.status).toBe(401);
-  });
-
-  it('accepts valid Bearer token', async () => {
-    const res = await request(port, 'GET', '/v1/models', undefined, { Authorization: 'Bearer secret-key' });
-    expect(res.status).toBe(200);
-  });
-
-  it('health check works without auth', async () => {
-    const res = await request(port, 'GET', '/health');
-    expect(res.status).toBe(200);
-  });
-});

package/tests/approvals.test.ts

@@ -1,89 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ExecApprovalManager } from '../src/security/approvals';
-
-describe('ExecApprovalManager', () => {
-  it('should default to elevated-only policy', () => {
-    const mgr = new ExecApprovalManager();
-    expect(mgr.getPolicy()).toBe('elevated-only');
-    mgr.destroy();
-  });
-
-  it('should require approval for elevated commands in elevated-only mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'elevated-only' });
-    expect(mgr.needsApproval('ls', true)).toBe(true);
-    expect(mgr.needsApproval('ls', false)).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should always require approval in always mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'always' });
-    expect(mgr.needsApproval('ls', false)).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should never require approval in never mode', () => {
-    const mgr = new ExecApprovalManager({ policy: 'never' });
-    expect(mgr.needsApproval('rm -rf /', true)).toBe(false);
-    mgr.destroy();
-  });
-
-  it('should skip approval for allowlisted commands', () => {
-    const mgr = new ExecApprovalManager({ policy: 'allowlist', allowedCommands: ['git ', 'npm test'] });
-    expect(mgr.needsApproval('git pull', false)).toBe(false);
-    expect(mgr.needsApproval('rm -rf /', false)).toBe(true);
-    mgr.destroy();
-  });
-
-  it('should create and approve requests', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('sudo reboot', true);
-    expect(req.status).toBe('pending');
-    expect(mgr.getPending()).toHaveLength(1);
-    const approved = mgr.approve(req.id, 'admin');
-    expect(approved.status).toBe('approved');
-    expect(mgr.getPending()).toHaveLength(0);
-    expect(mgr.getHistory()).toHaveLength(1);
-    mgr.destroy();
-  });
-
-  it('should deny requests', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('rm -rf /', true);
-    const denied = mgr.deny(req.id, 'admin', 'too dangerous');
-    expect(denied.status).toBe('denied');
-    expect(denied.reason).toBe('too dangerous');
-    mgr.destroy();
-  });
-
-  it('should throw on double approve', () => {
-    const mgr = new ExecApprovalManager();
-    const req = mgr.request('test', false);
-    mgr.approve(req.id, 'admin');
-    expect(() => mgr.approve(req.id, 'admin')).toThrow();
-    mgr.destroy();
-  });
-
-  it('should expire pending requests', () => {
-    const mgr = new ExecApprovalManager({ expiryMs: 1 });
-    const req = mgr.request('test', false);
-    // Wait a tick then check
-    return new Promise<void>(resolve => {
-      setTimeout(() => {
-        mgr.checkExpiry();
-        expect(mgr.getPending()).toHaveLength(0);
-        const found = mgr.getRequest(req.id);
-        expect(found?.status).toBe('expired');
-        mgr.destroy();
-        resolve();
-      }, 10);
-    });
-  });
-
-  it('should fire onRequest callback', () => {
-    let called = false;
-    const mgr = new ExecApprovalManager({ onRequest: () => { called = true; } });
-    mgr.request('test', false);
-    expect(called).toBe(true);
-    mgr.destroy();
-  });
-});

package/tests/audio.test.ts

@@ -1,40 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { AudioProcessor } from '../src/core/audio';
-
-describe('AudioProcessor', () => {
-  it('should detect WAV format', () => {
-    const wav = Buffer.from('RIFF\x00\x00\x00\x00WAVEfmt ');
-    expect(AudioProcessor.detectFormat(wav)).toBe('wav');
-  });
-
-  it('should detect MP3 format (ID3)', () => {
-    const mp3 = Buffer.from('ID3\x04\x00\x00\x00\x00\x00\x00');
-    expect(AudioProcessor.detectFormat(mp3)).toBe('mp3');
-  });
-
-  it('should return unknown for unrecognized format', () => {
-    const unknown = Buffer.from('NOTAFORMAT');
-    expect(AudioProcessor.detectFormat(unknown)).toBe('unknown');
-  });
-
-  it('should split buffer into chunks', () => {
-    const buf = Buffer.alloc(100, 0x42);
-    const chunks = AudioProcessor.split(buf, 30);
-    expect(chunks).toHaveLength(4);
-    expect(chunks[0].length).toBe(30);
-    expect(chunks[3].length).toBe(10);
-  });
-
-  it('should throw without provider on transcribe', async () => {
-    const proc = new AudioProcessor();
-    await expect(proc.transcribe(Buffer.alloc(0))).rejects.toThrow('No transcribe provider');
-  });
-
-  it('should call transcribe provider', async () => {
-    const proc = new AudioProcessor({
-      transcribe: async () => ({ text: 'hello world' }),
-    });
-    const result = await proc.transcribe(Buffer.alloc(10));
-    expect(result.text).toBe('hello world');
-  });
-});