opc-agent 1.4.0 → 1.4.1

package/src/channels/voice.ts

@@ -1,106 +1,106 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-import { Logger } from '../core/logger';
-
-// ── Voice Channel Types ─────────────────────────────────────
-
-export interface STTProvider {
-  name: string;
-  transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
-}
-
-export interface TTSProvider {
-  name: string;
-  synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
-}
-
-export interface STTOptions {
-  language?: string;
-  model?: string;
-}
-
-export interface TTSOptions {
-  voice?: string;
-  speed?: number;
-  language?: string;
-}
-
-export interface VoiceChannelConfig {
-  sttProvider?: STTProvider;
-  ttsProvider?: TTSProvider;
-  sampleRate?: number;
-  language?: string;
-}
-
-// ── Voice Channel ───────────────────────────────────────────
-
-export class VoiceChannel extends BaseChannel {
-  type = 'voice';
-  private config: VoiceChannelConfig;
-  private logger = new Logger('voice-channel');
-  private running = false;
-
-  constructor(config?: VoiceChannelConfig) {
-    super();
-    this.config = config ?? {};
-  }
-
-  async start(): Promise<void> {
-    this.running = true;
-    this.logger.info('Voice channel started', {
-      stt: this.config.sttProvider?.name ?? 'none',
-      tts: this.config.ttsProvider?.name ?? 'none',
-    });
-  }
-
-  async stop(): Promise<void> {
-    this.running = false;
-    this.logger.info('Voice channel stopped');
-  }
-
-  isRunning(): boolean {
-    return this.running;
-  }
-
-  /** Process audio input: STT → Agent → TTS */
-  async processAudio(audio: Buffer): Promise<{ text: string; response: string; audioResponse?: Buffer }> {
-    if (!this.handler) throw new Error('No message handler set');
-
-    // STT
-    let text: string;
-    if (this.config.sttProvider) {
-      text = await this.config.sttProvider.transcribe(audio, { language: this.config.language });
-    } else {
-      text = audio.toString('utf-8'); // Fallback: treat as text
-    }
-
-    this.logger.debug('STT result', { text });
-
-    // Create message and send to agent
-    const message: Message = {
-      id: `voice_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'user',
-      content: text,
-      timestamp: Date.now(),
-      metadata: { channel: 'voice' },
-    };
-
-    const response = await this.handler(message);
-
-    // TTS
-    let audioResponse: Buffer | undefined;
-    if (this.config.ttsProvider) {
-      audioResponse = await this.config.ttsProvider.synthesize(response.content, { language: this.config.language });
-    }
-
-    return { text, response: response.content, audioResponse };
-  }
-
-  setSTTProvider(provider: STTProvider): void {
-    this.config.sttProvider = provider;
-  }
-
-  setTTSProvider(provider: TTSProvider): void {
-    this.config.ttsProvider = provider;
-  }
-}
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+import { Logger } from '../core/logger';
+
+// ── Voice Channel Types ─────────────────────────────────────
+
+export interface STTProvider {
+  name: string;
+  transcribe(audio: Buffer, options?: STTOptions): Promise<string>;
+}
+
+export interface TTSProvider {
+  name: string;
+  synthesize(text: string, options?: TTSOptions): Promise<Buffer>;
+}
+
+export interface STTOptions {
+  language?: string;
+  model?: string;
+}
+
+export interface TTSOptions {
+  voice?: string;
+  speed?: number;
+  language?: string;
+}
+
+export interface VoiceChannelConfig {
+  sttProvider?: STTProvider;
+  ttsProvider?: TTSProvider;
+  sampleRate?: number;
+  language?: string;
+}
+
+// ── Voice Channel ───────────────────────────────────────────
+
+export class VoiceChannel extends BaseChannel {
+  type = 'voice';
+  private config: VoiceChannelConfig;
+  private logger = new Logger('voice-channel');
+  private running = false;
+
+  constructor(config?: VoiceChannelConfig) {
+    super();
+    this.config = config ?? {};
+  }
+
+  async start(): Promise<void> {
+    this.running = true;
+    this.logger.info('Voice channel started', {
+      stt: this.config.sttProvider?.name ?? 'none',
+      tts: this.config.ttsProvider?.name ?? 'none',
+    });
+  }
+
+  async stop(): Promise<void> {
+    this.running = false;
+    this.logger.info('Voice channel stopped');
+  }
+
+  isRunning(): boolean {
+    return this.running;
+  }
+
+  /** Process audio input: STT → Agent → TTS */
+  async processAudio(audio: Buffer): Promise<{ text: string; response: string; audioResponse?: Buffer }> {
+    if (!this.handler) throw new Error('No message handler set');
+
+    // STT
+    let text: string;
+    if (this.config.sttProvider) {
+      text = await this.config.sttProvider.transcribe(audio, { language: this.config.language });
+    } else {
+      text = audio.toString('utf-8'); // Fallback: treat as text
+    }
+
+    this.logger.debug('STT result', { text });
+
+    // Create message and send to agent
+    const message: Message = {
+      id: `voice_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content: text,
+      timestamp: Date.now(),
+      metadata: { channel: 'voice' },
+    };
+
+    const response = await this.handler(message);
+
+    // TTS
+    let audioResponse: Buffer | undefined;
+    if (this.config.ttsProvider) {
+      audioResponse = await this.config.ttsProvider.synthesize(response.content, { language: this.config.language });
+    }
+
+    return { text, response: response.content, audioResponse };
+  }
+
+  setSTTProvider(provider: STTProvider): void {
+    this.config.sttProvider = provider;
+  }
+
+  setTTSProvider(provider: TTSProvider): void {
+    this.config.ttsProvider = provider;
+  }
+}

package/src/channels/web.ts

@@ -288,11 +288,6 @@ export class WebChannel extends BaseChannel {
   private port: number;
   private streamHandler: ((msg: Message, res: Response) => Promise<void>) | null = null;
   private agentName: string = 'OPC Agent';
-  private agentVersion: string = '1.0.0';
-  private memoryType: string = 'in-memory';
-  private skillNames: string[] = [];
-  private channelNames: string[] = ['web'];
-  private analyticsProvider: (() => any) | null = null;
   private currentProvider: string = 'openai';
   private stats = { sessions: 0, messages: 0, totalResponseMs: 0, tokenUsage: 0, knowledgeFiles: 0, startedAt: Date.now(), errors: 0 };
   private eventHandlers: Map<string, Function[]> = new Map();
@@ -340,26 +335,6 @@ export class WebChannel extends BaseChannel {
     this.agentName = name;
   }
 
-  setAgentVersion(version: string): void {
-    this.agentVersion = version;
-  }
-
-  setMemoryType(type: string): void {
-    this.memoryType = type;
-  }
-
-  setSkillNames(names: string[]): void {
-    this.skillNames = names;
-  }
-
-  setChannelNames(names: string[]): void {
-    this.channelNames = names;
-  }
-
-  setAnalyticsProvider(fn: () => any): void {
-    this.analyticsProvider = fn;
-  }
-
   onStreamMessage(handler: (msg: Message, res: Response) => Promise<void>): void {
     this.streamHandler = handler;
   }
@@ -370,17 +345,7 @@ export class WebChannel extends BaseChannel {
     });
 
     this.app.get('/health', (_req: Request, res: Response) => {
-      res.json({
-        status: 'ok',
-        agent: this.agentName,
-        version: this.agentVersion,
-        uptime: Date.now() - this.stats.startedAt,
-        memory: this.memoryType,
-        skills: this.skillNames,
-        channels: this.channelNames,
-        analytics: this.analyticsProvider ? this.analyticsProvider() : null,
-        timestamp: Date.now(),
-      });
+      res.json({ status: 'ok', timestamp: Date.now() });
     });
 
     this.app.get('/api/info', (_req: Request, res: Response) => {
@@ -461,8 +426,7 @@ export class WebChannel extends BaseChannel {
     });
 
     this.app.get('/api/dashboard', (_req: Request, res: Response) => {
-      const analytics = this.analyticsProvider ? this.analyticsProvider() : null;
-      res.json({ ...this.stats, analytics });
+      res.json(this.stats);
     });
 
     // --- Knowledge Base Upload ---

package/src/channels/webhook.ts

@@ -1,199 +1,199 @@
-import { BaseChannel } from './index';
-import type { Message } from '../core/types';
-import { Logger } from '../core/logger';
-import * as http from 'http';
-import * as crypto from 'crypto';
-
-// ── Webhook Types ───────────────────────────────────────────
-
-export interface WebhookConfig {
-  port?: number;
-  path?: string;
-  secret?: string;
-  retryAttempts?: number;
-  retryDelayMs?: number;
-  outgoing?: WebhookOutgoing[];
-}
-
-export interface WebhookOutgoing {
-  name: string;
-  url: string;
-  secret?: string;
-  events: string[];
-}
-
-export interface WebhookPayload {
-  event: string;
-  data: unknown;
-  timestamp: number;
-  id: string;
-}
-
-// ── Webhook Channel ─────────────────────────────────────────
-
-export class WebhookChannel extends BaseChannel {
-  type = 'webhook';
-  private config: WebhookConfig;
-  private server: http.Server | null = null;
-  private logger = new Logger('webhook-channel');
-  private outgoing: WebhookOutgoing[] = [];
-
-  constructor(config?: WebhookConfig) {
-    super();
-    this.config = config ?? {};
-    this.outgoing = config?.outgoing ?? [];
-  }
-
-  async start(): Promise<void> {
-    const port = this.config.port ?? 3100;
-    const path = this.config.path ?? '/webhook';
-
-    this.server = http.createServer(async (req, res) => {
-      if (req.url !== path || req.method !== 'POST') {
-        res.writeHead(404);
-        res.end('Not found');
-        return;
-      }
-
-      try {
-        const body = await this.readBody(req);
-
-        // Verify signature if secret configured
-        if (this.config.secret) {
-          const signature = req.headers['x-webhook-signature'] as string;
-          if (!this.verifySignature(body, signature, this.config.secret)) {
-            res.writeHead(401);
-            res.end('Invalid signature');
-            return;
-          }
-        }
-
-        const payload: WebhookPayload = JSON.parse(body);
-        const message: Message = {
-          id: payload.id ?? `wh_${Date.now()}`,
-          role: 'user',
-          content: typeof payload.data === 'string' ? payload.data : JSON.stringify(payload.data),
-          timestamp: payload.timestamp ?? Date.now(),
-          metadata: { channel: 'webhook', event: payload.event },
-        };
-
-        if (this.handler) {
-          const response = await this.handler(message);
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ status: 'ok', response: response.content }));
-        } else {
-          res.writeHead(200, { 'Content-Type': 'application/json' });
-          res.end(JSON.stringify({ status: 'ok' }));
-        }
-      } catch (err) {
-        this.logger.error('Webhook error', { error: (err as Error).message });
-        res.writeHead(500);
-        res.end('Internal error');
-      }
-    });
-
-    return new Promise((resolve) => {
-      this.server!.listen(port, () => {
-        this.logger.info('Webhook channel started', { port, path });
-        resolve();
-      });
-    });
-  }
-
-  async stop(): Promise<void> {
-    return new Promise((resolve) => {
-      if (this.server) {
-        this.server.close(() => {
-          this.logger.info('Webhook channel stopped');
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-
-  /** Send a webhook to outgoing endpoints */
-  async send(event: string, data: unknown): Promise<void> {
-    const targets = this.outgoing.filter(o => o.events.includes(event) || o.events.includes('*'));
-
-    for (const target of targets) {
-      const payload: WebhookPayload = {
-        event,
-        data,
-        timestamp: Date.now(),
-        id: `wh_out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      };
-
-      await this.sendWithRetry(target, payload);
-    }
-  }
-
-  private async sendWithRetry(target: WebhookOutgoing, payload: WebhookPayload): Promise<void> {
-    const maxRetries = this.config.retryAttempts ?? 3;
-    const retryDelay = this.config.retryDelayMs ?? 1000;
-    const body = JSON.stringify(payload);
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        await this.httpPost(target.url, body, target.secret);
-        return;
-      } catch (err) {
-        if (attempt === maxRetries) {
-          this.logger.error('Webhook delivery failed', { target: target.name, error: (err as Error).message });
-          throw err;
-        }
-        await new Promise(r => setTimeout(r, retryDelay * Math.pow(2, attempt)));
-      }
-    }
-  }
-
-  private httpPost(url: string, body: string, secret?: string): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const urlObj = new URL(url);
-      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-      if (secret) {
-        headers['x-webhook-signature'] = this.createSignature(body, secret);
-      }
-
-      const req = http.request(
-        { hostname: urlObj.hostname, port: urlObj.port, path: urlObj.pathname, method: 'POST', headers },
-        (res) => {
-          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
-            resolve();
-          } else {
-            reject(new Error(`HTTP ${res.statusCode}`));
-          }
-          res.resume();
-        },
-      );
-      req.on('error', reject);
-      req.write(body);
-      req.end();
-    });
-  }
-
-  private readBody(req: http.IncomingMessage): Promise<string> {
-    return new Promise((resolve, reject) => {
-      const chunks: Buffer[] = [];
-      req.on('data', (c: Buffer) => chunks.push(c));
-      req.on('end', () => resolve(Buffer.concat(chunks).toString()));
-      req.on('error', reject);
-    });
-  }
-
-  verifySignature(body: string, signature: string, secret: string): boolean {
-    if (!signature) return false;
-    const expected = this.createSignature(body, secret);
-    if (signature.length !== expected.length) return false;
-    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
-  }
-
-  createSignature(body: string, secret: string): string {
-    return crypto.createHmac('sha256', secret).update(body).digest('hex');
-  }
-
-  addOutgoing(outgoing: WebhookOutgoing): void {
-    this.outgoing.push(outgoing);
-  }
-}
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+import { Logger } from '../core/logger';
+import * as http from 'http';
+import * as crypto from 'crypto';
+
+// ── Webhook Types ───────────────────────────────────────────
+
+export interface WebhookConfig {
+  port?: number;
+  path?: string;
+  secret?: string;
+  retryAttempts?: number;
+  retryDelayMs?: number;
+  outgoing?: WebhookOutgoing[];
+}
+
+export interface WebhookOutgoing {
+  name: string;
+  url: string;
+  secret?: string;
+  events: string[];
+}
+
+export interface WebhookPayload {
+  event: string;
+  data: unknown;
+  timestamp: number;
+  id: string;
+}
+
+// ── Webhook Channel ─────────────────────────────────────────
+
+export class WebhookChannel extends BaseChannel {
+  type = 'webhook';
+  private config: WebhookConfig;
+  private server: http.Server | null = null;
+  private logger = new Logger('webhook-channel');
+  private outgoing: WebhookOutgoing[] = [];
+
+  constructor(config?: WebhookConfig) {
+    super();
+    this.config = config ?? {};
+    this.outgoing = config?.outgoing ?? [];
+  }
+
+  async start(): Promise<void> {
+    const port = this.config.port ?? 3100;
+    const path = this.config.path ?? '/webhook';
+
+    this.server = http.createServer(async (req, res) => {
+      if (req.url !== path || req.method !== 'POST') {
+        res.writeHead(404);
+        res.end('Not found');
+        return;
+      }
+
+      try {
+        const body = await this.readBody(req);
+
+        // Verify signature if secret configured
+        if (this.config.secret) {
+          const signature = req.headers['x-webhook-signature'] as string;
+          if (!this.verifySignature(body, signature, this.config.secret)) {
+            res.writeHead(401);
+            res.end('Invalid signature');
+            return;
+          }
+        }
+
+        const payload: WebhookPayload = JSON.parse(body);
+        const message: Message = {
+          id: payload.id ?? `wh_${Date.now()}`,
+          role: 'user',
+          content: typeof payload.data === 'string' ? payload.data : JSON.stringify(payload.data),
+          timestamp: payload.timestamp ?? Date.now(),
+          metadata: { channel: 'webhook', event: payload.event },
+        };
+
+        if (this.handler) {
+          const response = await this.handler(message);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok', response: response.content }));
+        } else {
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ status: 'ok' }));
+        }
+      } catch (err) {
+        this.logger.error('Webhook error', { error: (err as Error).message });
+        res.writeHead(500);
+        res.end('Internal error');
+      }
+    });
+
+    return new Promise((resolve) => {
+      this.server!.listen(port, () => {
+        this.logger.info('Webhook channel started', { port, path });
+        resolve();
+      });
+    });
+  }
+
+  async stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => {
+          this.logger.info('Webhook channel stopped');
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  /** Send a webhook to outgoing endpoints */
+  async send(event: string, data: unknown): Promise<void> {
+    const targets = this.outgoing.filter(o => o.events.includes(event) || o.events.includes('*'));
+
+    for (const target of targets) {
+      const payload: WebhookPayload = {
+        event,
+        data,
+        timestamp: Date.now(),
+        id: `wh_out_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      };
+
+      await this.sendWithRetry(target, payload);
+    }
+  }
+
+  private async sendWithRetry(target: WebhookOutgoing, payload: WebhookPayload): Promise<void> {
+    const maxRetries = this.config.retryAttempts ?? 3;
+    const retryDelay = this.config.retryDelayMs ?? 1000;
+    const body = JSON.stringify(payload);
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        await this.httpPost(target.url, body, target.secret);
+        return;
+      } catch (err) {
+        if (attempt === maxRetries) {
+          this.logger.error('Webhook delivery failed', { target: target.name, error: (err as Error).message });
+          throw err;
+        }
+        await new Promise(r => setTimeout(r, retryDelay * Math.pow(2, attempt)));
+      }
+    }
+  }
+
+  private httpPost(url: string, body: string, secret?: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const headers: Record<string, string> = { 'Content-Type': 'application/json' };
+      if (secret) {
+        headers['x-webhook-signature'] = this.createSignature(body, secret);
+      }
+
+      const req = http.request(
+        { hostname: urlObj.hostname, port: urlObj.port, path: urlObj.pathname, method: 'POST', headers },
+        (res) => {
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve();
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}`));
+          }
+          res.resume();
+        },
+      );
+      req.on('error', reject);
+      req.write(body);
+      req.end();
+    });
+  }
+
+  private readBody(req: http.IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on('data', (c: Buffer) => chunks.push(c));
+      req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+      req.on('error', reject);
+    });
+  }
+
+  verifySignature(body: string, signature: string, secret: string): boolean {
+    if (!signature) return false;
+    const expected = this.createSignature(body, secret);
+    if (signature.length !== expected.length) return false;
+    return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+  }
+
+  createSignature(body: string, secret: string): string {
+    return crypto.createHmac('sha256', secret).update(body).digest('hex');
+  }
+
+  addOutgoing(outgoing: WebhookOutgoing): void {
+    this.outgoing.push(outgoing);
+  }
+}