opc-agent 1.2.0 → 1.2.1

package/tests/voice.test.ts

@@ -1,61 +1,61 @@
-import { describe, it, expect } from 'vitest';
-import { VoiceChannel } from '../src/channels/voice';
-import type { STTProvider, TTSProvider } from '../src/channels/voice';
-
-describe('VoiceChannel', () => {
-  it('should start and stop', async () => {
-    const channel = new VoiceChannel();
-    await channel.start();
-    expect(channel.isRunning()).toBe(true);
-    await channel.stop();
-    expect(channel.isRunning()).toBe(false);
-  });
-
-  it('should process audio with STT/TTS providers', async () => {
-    const stt: STTProvider = {
-      name: 'mock-stt',
-      transcribe: async (audio) => audio.toString('utf-8'),
-    };
-    const tts: TTSProvider = {
-      name: 'mock-tts',
-      synthesize: async (text) => Buffer.from(`audio:${text}`),
-    };
-
-    const channel = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
-    channel.onMessage(async (msg) => ({
-      id: 'r1', role: 'assistant', content: `Reply: ${msg.content}`, timestamp: Date.now(),
-    }));
-    await channel.start();
-
-    const result = await channel.processAudio(Buffer.from('hello'));
-    expect(result.text).toBe('hello');
-    expect(result.response).toBe('Reply: hello');
-    expect(result.audioResponse?.toString()).toBe('audio:Reply: hello');
-  });
-
-  it('should work without providers (text fallback)', async () => {
-    const channel = new VoiceChannel();
-    channel.onMessage(async (msg) => ({
-      id: 'r1', role: 'assistant', content: msg.content, timestamp: Date.now(),
-    }));
-    await channel.start();
-
-    const result = await channel.processAudio(Buffer.from('test'));
-    expect(result.text).toBe('test');
-    expect(result.audioResponse).toBeUndefined();
-  });
-
-  it('should throw without handler', async () => {
-    const channel = new VoiceChannel();
-    await expect(channel.processAudio(Buffer.from('test'))).rejects.toThrow('No message handler');
-  });
-
-  it('should allow setting providers after construction', () => {
-    const channel = new VoiceChannel();
-    const stt: STTProvider = { name: 'stt', transcribe: async () => 'text' };
-    const tts: TTSProvider = { name: 'tts', synthesize: async () => Buffer.from('audio') };
-    channel.setSTTProvider(stt);
-    channel.setTTSProvider(tts);
-    expect(channel.type).toBe('voice');
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { VoiceChannel } from '../src/channels/voice';
+import type { STTProvider, TTSProvider } from '../src/channels/voice';
+
+describe('VoiceChannel', () => {
+  it('should start and stop', async () => {
+    const channel = new VoiceChannel();
+    await channel.start();
+    expect(channel.isRunning()).toBe(true);
+    await channel.stop();
+    expect(channel.isRunning()).toBe(false);
+  });
+
+  it('should process audio with STT/TTS providers', async () => {
+    const stt: STTProvider = {
+      name: 'mock-stt',
+      transcribe: async (audio) => audio.toString('utf-8'),
+    };
+    const tts: TTSProvider = {
+      name: 'mock-tts',
+      synthesize: async (text) => Buffer.from(`audio:${text}`),
+    };
+
+    const channel = new VoiceChannel({ sttProvider: stt, ttsProvider: tts });
+    channel.onMessage(async (msg) => ({
+      id: 'r1', role: 'assistant', content: `Reply: ${msg.content}`, timestamp: Date.now(),
+    }));
+    await channel.start();
+
+    const result = await channel.processAudio(Buffer.from('hello'));
+    expect(result.text).toBe('hello');
+    expect(result.response).toBe('Reply: hello');
+    expect(result.audioResponse?.toString()).toBe('audio:Reply: hello');
+  });
+
+  it('should work without providers (text fallback)', async () => {
+    const channel = new VoiceChannel();
+    channel.onMessage(async (msg) => ({
+      id: 'r1', role: 'assistant', content: msg.content, timestamp: Date.now(),
+    }));
+    await channel.start();
+
+    const result = await channel.processAudio(Buffer.from('test'));
+    expect(result.text).toBe('test');
+    expect(result.audioResponse).toBeUndefined();
+  });
+
+  it('should throw without handler', async () => {
+    const channel = new VoiceChannel();
+    await expect(channel.processAudio(Buffer.from('test'))).rejects.toThrow('No message handler');
+  });
+
+  it('should allow setting providers after construction', () => {
+    const channel = new VoiceChannel();
+    const stt: STTProvider = { name: 'stt', transcribe: async () => 'text' };
+    const tts: TTSProvider = { name: 'tts', synthesize: async () => Buffer.from('audio') };
+    channel.setSTTProvider(stt);
+    channel.setTTSProvider(tts);
+    expect(channel.type).toBe('voice');
+  });
+});

package/tests/webhook.test.ts

@@ -1,29 +1,29 @@
-import { describe, it, expect } from 'vitest';
-import { WebhookChannel } from '../src/channels/webhook';
-
-describe('WebhookChannel', () => {
-  it('should create with default config', () => {
-    const channel = new WebhookChannel();
-    expect(channel.type).toBe('webhook');
-  });
-
-  it('should verify signatures', () => {
-    const channel = new WebhookChannel({ secret: 'test-secret' });
-    const body = '{"event":"test"}';
-    const sig = channel.createSignature(body, 'test-secret');
-    expect(channel.verifySignature(body, sig, 'test-secret')).toBe(true);
-    expect(channel.verifySignature(body, 'invalid', 'test-secret')).toBe(false);
-  });
-
-  it('should add outgoing webhooks', () => {
-    const channel = new WebhookChannel();
-    channel.addOutgoing({ name: 'test', url: 'http://localhost:9999', events: ['*'], secret: 'abc' });
-    expect(channel.type).toBe('webhook');
-  });
-
-  it('should start and stop server', async () => {
-    const channel = new WebhookChannel({ port: 0 }); // port 0 = random
-    await channel.start();
-    await channel.stop();
-  });
-});
+import { describe, it, expect } from 'vitest';
+import { WebhookChannel } from '../src/channels/webhook';
+
+describe('WebhookChannel', () => {
+  it('should create with default config', () => {
+    const channel = new WebhookChannel();
+    expect(channel.type).toBe('webhook');
+  });
+
+  it('should verify signatures', () => {
+    const channel = new WebhookChannel({ secret: 'test-secret' });
+    const body = '{"event":"test"}';
+    const sig = channel.createSignature(body, 'test-secret');
+    expect(channel.verifySignature(body, sig, 'test-secret')).toBe(true);
+    expect(channel.verifySignature(body, 'invalid', 'test-secret')).toBe(false);
+  });
+
+  it('should add outgoing webhooks', () => {
+    const channel = new WebhookChannel();
+    channel.addOutgoing({ name: 'test', url: 'http://localhost:9999', events: ['*'], secret: 'abc' });
+    expect(channel.type).toBe('webhook');
+  });
+
+  it('should start and stop server', async () => {
+    const channel = new WebhookChannel({ port: 0 }); // port 0 = random
+    await channel.start();
+    await channel.stop();
+  });
+});

package/tests/workflow.test.ts

@@ -1,143 +1,143 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { WorkflowEngine, WorkflowDefinition } from '../src/core/workflow';
-import { BaseSkill } from '../src/skills/base';
-import type { AgentContext, Message, SkillResult, MemoryStore } from '../src/core/types';
-
-class EchoSkill extends BaseSkill {
-  name = 'echo';
-  description = 'Echo input';
-  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
-    return this.match(`echo:${msg.content}`, 1.0);
-  }
-}
-
-class UpperSkill extends BaseSkill {
-  name = 'upper';
-  description = 'Uppercase';
-  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
-    return this.match(msg.content.toUpperCase(), 1.0);
-  }
-}
-
-class FailSkill extends BaseSkill {
-  name = 'fail';
-  description = 'Always fails';
-  async execute(): Promise<SkillResult> {
-    throw new Error('intentional failure');
-  }
-}
-
-const mockMemory: MemoryStore = {
-  get: async () => null,
-  set: async () => {},
-  getConversation: async () => [],
-  addMessage: async () => {},
-  clear: async () => {},
-};
-
-const mockContext: AgentContext = {
-  agentName: 'test',
-  sessionId: 'test-session',
-  messages: [],
-  memory: mockMemory,
-  metadata: {},
-};
-
-describe('WorkflowEngine', () => {
-  let engine: WorkflowEngine;
-
-  beforeEach(() => {
-    engine = new WorkflowEngine();
-    engine.registerSkill(new EchoSkill());
-    engine.registerSkill(new UpperSkill());
-    engine.registerSkill(new FailSkill());
-  });
-
-  it('should register and list workflows', () => {
-    const wf: WorkflowDefinition = { name: 'test', steps: [] };
-    engine.registerWorkflow(wf);
-    expect(engine.listWorkflows()).toHaveLength(1);
-    expect(engine.getWorkflow('test')).toBeDefined();
-  });
-
-  it('should run sequential steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'seq',
-      steps: [
-        { id: 's1', type: 'skill', name: 'echo' },
-        { id: 's2', type: 'skill', name: 'upper' },
-      ],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('seq', mockContext, 'hello');
-    expect(result.status).toBe('completed');
-    expect(result.steps).toHaveLength(2);
-  });
-
-  it('should handle parallel steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'par',
-      steps: [{
-        id: 'p1', type: 'parallel', name: 'parallel',
-        parallel: [
-          { id: 's1', type: 'skill', name: 'echo' },
-          { id: 's2', type: 'skill', name: 'upper' },
-        ],
-      }],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('par', mockContext, 'test');
-    expect(result.status).toBe('completed');
-  });
-
-  it('should handle conditional branching', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'cond',
-      steps: [{
-        id: 'c1', type: 'condition', name: 'check',
-        condition: 'contains:hello',
-        branches: {
-          if: [{ id: 's1', type: 'skill', name: 'echo' }],
-          else: [{ id: 's2', type: 'skill', name: 'upper' }],
-        },
-      }],
-    };
-    engine.registerWorkflow(wf);
-    const r1 = await engine.run('cond', mockContext, 'hello world');
-    expect(r1.steps.find(s => s.stepId === 's1')).toBeDefined();
-  });
-
-  it('should handle step failures with stop policy', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'fail-wf',
-      onError: 'stop',
-      steps: [
-        { id: 's1', type: 'skill', name: 'fail' },
-        { id: 's2', type: 'skill', name: 'echo' },
-      ],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('fail-wf', mockContext, 'test');
-    expect(result.status).toBe('failed');
-  });
-
-  it('should retry failed steps', async () => {
-    const wf: WorkflowDefinition = {
-      name: 'retry-wf',
-      steps: [{ id: 's1', type: 'skill', name: 'fail', retries: 2 }],
-    };
-    engine.registerWorkflow(wf);
-    const result = await engine.run('retry-wf', mockContext, 'test');
-    expect(result.steps[0].status).toBe('error');
-  });
-
-  it('should throw on unknown workflow', async () => {
-    await expect(engine.run('nonexistent', mockContext)).rejects.toThrow();
-  });
-
-  it('should unregister workflows', () => {
-    engine.registerWorkflow({ name: 'temp', steps: [] });
-    engine.unregisterWorkflow('temp');
-    expect(engine.getWorkflow('temp')).toBeUndefined();
-  });
-});
+import { describe, it, expect, beforeEach } from 'vitest';
+import { WorkflowEngine, WorkflowDefinition } from '../src/core/workflow';
+import { BaseSkill } from '../src/skills/base';
+import type { AgentContext, Message, SkillResult, MemoryStore } from '../src/core/types';
+
+class EchoSkill extends BaseSkill {
+  name = 'echo';
+  description = 'Echo input';
+  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
+    return this.match(`echo:${msg.content}`, 1.0);
+  }
+}
+
+class UpperSkill extends BaseSkill {
+  name = 'upper';
+  description = 'Uppercase';
+  async execute(_ctx: AgentContext, msg: Message): Promise<SkillResult> {
+    return this.match(msg.content.toUpperCase(), 1.0);
+  }
+}
+
+class FailSkill extends BaseSkill {
+  name = 'fail';
+  description = 'Always fails';
+  async execute(): Promise<SkillResult> {
+    throw new Error('intentional failure');
+  }
+}
+
+const mockMemory: MemoryStore = {
+  get: async () => null,
+  set: async () => {},
+  getConversation: async () => [],
+  addMessage: async () => {},
+  clear: async () => {},
+};
+
+const mockContext: AgentContext = {
+  agentName: 'test',
+  sessionId: 'test-session',
+  messages: [],
+  memory: mockMemory,
+  metadata: {},
+};
+
+describe('WorkflowEngine', () => {
+  let engine: WorkflowEngine;
+
+  beforeEach(() => {
+    engine = new WorkflowEngine();
+    engine.registerSkill(new EchoSkill());
+    engine.registerSkill(new UpperSkill());
+    engine.registerSkill(new FailSkill());
+  });
+
+  it('should register and list workflows', () => {
+    const wf: WorkflowDefinition = { name: 'test', steps: [] };
+    engine.registerWorkflow(wf);
+    expect(engine.listWorkflows()).toHaveLength(1);
+    expect(engine.getWorkflow('test')).toBeDefined();
+  });
+
+  it('should run sequential steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'seq',
+      steps: [
+        { id: 's1', type: 'skill', name: 'echo' },
+        { id: 's2', type: 'skill', name: 'upper' },
+      ],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('seq', mockContext, 'hello');
+    expect(result.status).toBe('completed');
+    expect(result.steps).toHaveLength(2);
+  });
+
+  it('should handle parallel steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'par',
+      steps: [{
+        id: 'p1', type: 'parallel', name: 'parallel',
+        parallel: [
+          { id: 's1', type: 'skill', name: 'echo' },
+          { id: 's2', type: 'skill', name: 'upper' },
+        ],
+      }],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('par', mockContext, 'test');
+    expect(result.status).toBe('completed');
+  });
+
+  it('should handle conditional branching', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'cond',
+      steps: [{
+        id: 'c1', type: 'condition', name: 'check',
+        condition: 'contains:hello',
+        branches: {
+          if: [{ id: 's1', type: 'skill', name: 'echo' }],
+          else: [{ id: 's2', type: 'skill', name: 'upper' }],
+        },
+      }],
+    };
+    engine.registerWorkflow(wf);
+    const r1 = await engine.run('cond', mockContext, 'hello world');
+    expect(r1.steps.find(s => s.stepId === 's1')).toBeDefined();
+  });
+
+  it('should handle step failures with stop policy', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'fail-wf',
+      onError: 'stop',
+      steps: [
+        { id: 's1', type: 'skill', name: 'fail' },
+        { id: 's2', type: 'skill', name: 'echo' },
+      ],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('fail-wf', mockContext, 'test');
+    expect(result.status).toBe('failed');
+  });
+
+  it('should retry failed steps', async () => {
+    const wf: WorkflowDefinition = {
+      name: 'retry-wf',
+      steps: [{ id: 's1', type: 'skill', name: 'fail', retries: 2 }],
+    };
+    engine.registerWorkflow(wf);
+    const result = await engine.run('retry-wf', mockContext, 'test');
+    expect(result.steps[0].status).toBe('error');
+  });
+
+  it('should throw on unknown workflow', async () => {
+    await expect(engine.run('nonexistent', mockContext)).rejects.toThrow();
+  });
+
+  it('should unregister workflows', () => {
+    engine.registerWorkflow({ name: 'temp', steps: [] });
+    engine.unregisterWorkflow('temp');
+    expect(engine.getWorkflow('temp')).toBeUndefined();
+  });
+});

package/tsconfig.json

@@ -1,19 +1,19 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "commonjs",
-    "lib": ["ES2022"],
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "lib": ["ES2022"],
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -1,9 +1,9 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['tests/**/*.test.ts'],
-  },
-});
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+  },
+});