opc-agent 4.1.2 → 4.1.4

package/src/core/analytics-engine.ts

@@ -1,186 +0,0 @@
-/**
- * Analytics Engine - Persistent analytics with JSON file storage.
- * Tracks every message, LLM call, tool use, and error with timestamps.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface AnalyticsEvent {
-  type: 'message' | 'llm_call' | 'tool_use' | 'error';
-  timestamp: number;
-  data: Record<string, any>;
-}
-
-export interface AnalyticsStats {
-  totalMessages: number;
-  totalLLMCalls: number;
-  totalToolUses: number;
-  totalErrors: number;
-  avgResponseTimeMs: number;
-  totalTokens: { input: number; output: number; total: number };
-  topSkills: { name: string; count: number }[];
-  topErrors: { message: string; count: number }[];
-  messagesPerDay: Record<string, number>;
-  period: { from: number; to: number };
-}
-
-export class AnalyticsEngine {
-  private dataDir: string;
-  private eventsFile: string;
-  private events: AnalyticsEvent[] = [];
-
-  constructor(dataDir: string = '.') {
-    this.dataDir = path.resolve(dataDir, 'data');
-    this.eventsFile = path.join(this.dataDir, 'analytics.json');
-    this.load();
-  }
-
-  private load(): void {
-    try {
-      if (fs.existsSync(this.eventsFile)) {
-        const raw = fs.readFileSync(this.eventsFile, 'utf-8');
-        this.events = JSON.parse(raw);
-      }
-    } catch {
-      this.events = [];
-    }
-  }
-
-  private save(): void {
-    if (!fs.existsSync(this.dataDir)) {
-      fs.mkdirSync(this.dataDir, { recursive: true });
-    }
-    // Keep last 10000 events to prevent unbounded growth
-    if (this.events.length > 10000) {
-      this.events = this.events.slice(-10000);
-    }
-    fs.writeFileSync(this.eventsFile, JSON.stringify(this.events, null, 2));
-  }
-
-  track(type: AnalyticsEvent['type'], data: Record<string, any>): void {
-    this.events.push({ type, timestamp: Date.now(), data });
-    this.save();
-  }
-
-  trackMessage(userId: string, responseTimeMs: number, tokensIn: number, tokensOut: number): void {
-    this.track('message', { userId, responseTimeMs, tokensIn, tokensOut });
-  }
-
-  trackLLMCall(provider: string, model: string, tokensIn: number, tokensOut: number, latencyMs: number): void {
-    this.track('llm_call', { provider, model, tokensIn, tokensOut, latencyMs });
-  }
-
-  trackToolUse(toolName: string, success: boolean, latencyMs: number): void {
-    this.track('tool_use', { toolName, success, latencyMs });
-  }
-
-  trackError(error: string, context?: string): void {
-    this.track('error', { error, context });
-  }
-
-  getStats(fromTs?: number, toTs?: number): AnalyticsStats {
-    const now = Date.now();
-    const from = fromTs ?? 0;
-    const to = toTs ?? now;
-    const filtered = this.events.filter(e => e.timestamp >= from && e.timestamp <= to);
-
-    const messages = filtered.filter(e => e.type === 'message');
-    const llmCalls = filtered.filter(e => e.type === 'llm_call');
-    const toolUses = filtered.filter(e => e.type === 'tool_use');
-    const errors = filtered.filter(e => e.type === 'error');
-
-    // Avg response time
-    const totalResponseTime = messages.reduce((sum, e) => sum + (e.data.responseTimeMs ?? 0), 0);
-    const avgResponseTimeMs = messages.length > 0 ? Math.round(totalResponseTime / messages.length) : 0;
-
-    // Total tokens
-    const totalTokensIn = llmCalls.reduce((sum, e) => sum + (e.data.tokensIn ?? 0), 0);
-    const totalTokensOut = llmCalls.reduce((sum, e) => sum + (e.data.tokensOut ?? 0), 0);
-
-    // Top skills (from tool_use)
-    const skillCounts: Record<string, number> = {};
-    for (const e of toolUses) {
-      const name = e.data.toolName ?? 'unknown';
-      skillCounts[name] = (skillCounts[name] ?? 0) + 1;
-    }
-    const topSkills = Object.entries(skillCounts)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10)
-      .map(([name, count]) => ({ name, count }));
-
-    // Top errors
-    const errorCounts: Record<string, number> = {};
-    for (const e of errors) {
-      const msg = e.data.error ?? 'unknown';
-      errorCounts[msg] = (errorCounts[msg] ?? 0) + 1;
-    }
-    const topErrors = Object.entries(errorCounts)
-      .sort((a, b) => b[1] - a[1])
-      .slice(0, 10)
-      .map(([message, count]) => ({ message, count }));
-
-    // Messages per day
-    const messagesPerDay: Record<string, number> = {};
-    for (const e of messages) {
-      const day = new Date(e.timestamp).toISOString().slice(0, 10);
-      messagesPerDay[day] = (messagesPerDay[day] ?? 0) + 1;
-    }
-
-    return {
-      totalMessages: messages.length,
-      totalLLMCalls: llmCalls.length,
-      totalToolUses: toolUses.length,
-      totalErrors: errors.length,
-      avgResponseTimeMs,
-      totalTokens: { input: totalTokensIn, output: totalTokensOut, total: totalTokensIn + totalTokensOut },
-      topSkills,
-      topErrors,
-      messagesPerDay,
-      period: { from, to },
-    };
-  }
-
-  getRecentEvents(limit: number = 50): AnalyticsEvent[] {
-    return this.events.slice(-limit);
-  }
-
-  clear(): void {
-    this.events = [];
-    this.save();
-  }
-
-  /**
-   * Format stats for CLI display.
-   */
-  static formatStats(stats: AnalyticsStats): string {
-    const lines: string[] = [];
-    lines.push('');
-    lines.push('══════════════════════════════════════════');
-    lines.push('  OPC Agent Analytics');
-    lines.push('══════════════════════════════════════════');
-    lines.push('');
-    lines.push(`  📨 Messages:        ${stats.totalMessages}`);
-    lines.push(`  🤖 LLM Calls:       ${stats.totalLLMCalls}`);
-    lines.push(`  🔧 Tool Uses:        ${stats.totalToolUses}`);
-    lines.push(`  ❌ Errors:           ${stats.totalErrors}`);
-    lines.push(`  ⏱  Avg Response:     ${stats.avgResponseTimeMs}ms`);
-    lines.push(`  🪙 Tokens:           ${stats.totalTokens.total} (in: ${stats.totalTokens.input}, out: ${stats.totalTokens.output})`);
-    lines.push('');
-    if (stats.topSkills.length > 0) {
-      lines.push('  Top Skills:');
-      for (const s of stats.topSkills.slice(0, 5)) {
-        lines.push(`    • ${s.name}: ${s.count}`);
-      }
-      lines.push('');
-    }
-    if (stats.topErrors.length > 0) {
-      lines.push('  Top Errors:');
-      for (const e of stats.topErrors.slice(0, 3)) {
-        lines.push(`    • ${e.message}: ${e.count}`);
-      }
-      lines.push('');
-    }
-    lines.push('──────────────────────────────────────────');
-    return lines.join('\n');
-  }
-}

package/src/core/api-server.ts

@@ -1,277 +0,0 @@
-import * as http from 'http';
-import { randomUUID } from 'crypto';
-
-export interface APIServerConfig {
-  port: number;
-  host: string;
-  apiKey?: string;
-  agent: any;
-}
-
-interface OpenAIError {
-  error: { message: string; type: string; code: string | number };
-}
-
-function jsonError(message: string, type: string, code: string | number): OpenAIError {
-  return { error: { message, type, code } };
-}
-
-function corsHeaders(): Record<string, string> {
-  return {
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-  };
-}
-
-function parseBody(req: http.IncomingMessage): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    req.on('data', (c) => chunks.push(c));
-    req.on('end', () => resolve(Buffer.concat(chunks).toString()));
-    req.on('error', reject);
-  });
-}
-
-function sendJSON(res: http.ServerResponse, status: number, data: unknown): void {
-  const body = JSON.stringify(data);
-  res.writeHead(status, { ...corsHeaders(), 'Content-Type': 'application/json' });
-  res.end(body);
-}
-
-export class APIServer {
-  private server: http.Server | null = null;
-  private config: APIServerConfig;
-
-  constructor(config: Partial<APIServerConfig> & { agent: any }) {
-    this.config = {
-      port: config.port ?? 8080,
-      host: config.host ?? '0.0.0.0',
-      apiKey: config.apiKey,
-      agent: config.agent,
-    };
-  }
-
-  private authenticate(req: http.IncomingMessage): boolean {
-    if (!this.config.apiKey) return true;
-    const auth = req.headers['authorization'] ?? '';
-    return auth === `Bearer ${this.config.apiKey}`;
-  }
-
-  async start(): Promise<void> {
-    return new Promise((resolve) => {
-      this.server = http.createServer((req, res) => this.handleRequest(req, res));
-      this.server.listen(this.config.port, this.config.host, () => resolve());
-    });
-  }
-
-  async stop(): Promise<void> {
-    return new Promise((resolve) => {
-      if (this.server) this.server.close(() => resolve());
-      else resolve();
-    });
-  }
-
-  getPort(): number { return this.config.port; }
-  getHost(): string { return this.config.host; }
-
-  private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    const url = req.url ?? '/';
-    const method = req.method ?? 'GET';
-
-    // CORS preflight
-    if (method === 'OPTIONS') {
-      res.writeHead(204, corsHeaders());
-      res.end();
-      return;
-    }
-
-    // Health check (no auth)
-    if (method === 'GET' && url === '/health') {
-      sendJSON(res, 200, { status: 'ok', timestamp: new Date().toISOString() });
-      return;
-    }
-
-    // Auth check for all other endpoints
-    if (!this.authenticate(req)) {
-      sendJSON(res, 401, jsonError('Invalid API key', 'authentication_error', 401));
-      return;
-    }
-
-    try {
-      if (method === 'GET' && url === '/v1/models') {
-        return this.handleModels(res);
-      }
-      if (method === 'GET' && url === '/v1/agent/status') {
-        return this.handleAgentStatus(res);
-      }
-      if (method === 'POST' && url === '/v1/chat/completions') {
-        return await this.handleChatCompletions(req, res);
-      }
-      if (method === 'POST' && url === '/v1/embeddings') {
-        return await this.handleEmbeddings(req, res);
-      }
-
-      sendJSON(res, 404, jsonError('Not found', 'not_found', 404));
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      sendJSON(res, 500, jsonError(msg, 'internal_error', 500));
-    }
-  }
-
-  private handleModels(res: http.ServerResponse): void {
-    const agent = this.config.agent;
-    const modelId = agent?.config?.model ?? agent?.model ?? 'default';
-    sendJSON(res, 200, {
-      object: 'list',
-      data: [{ id: modelId, object: 'model', created: Math.floor(Date.now() / 1000), owned_by: 'opc-agent' }],
-    });
-  }
-
-  private handleAgentStatus(res: http.ServerResponse): void {
-    const agent = this.config.agent;
-    sendJSON(res, 200, {
-      name: agent?.name ?? agent?.config?.name ?? 'unknown',
-      state: agent?.state ?? 'unknown',
-      uptime: process.uptime(),
-    });
-  }
-
-  private async handleChatCompletions(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    let body: any;
-    try {
-      body = JSON.parse(await parseBody(req));
-    } catch {
-      sendJSON(res, 400, jsonError('Invalid JSON body', 'invalid_request_error', 400));
-      return;
-    }
-
-    const { model, messages, temperature, max_tokens, stream, tools } = body;
-    if (!messages || !Array.isArray(messages)) {
-      sendJSON(res, 400, jsonError('messages is required and must be an array', 'invalid_request_error', 400));
-      return;
-    }
-
-    const agent = this.config.agent;
-    const requestId = `chatcmpl-${randomUUID().replace(/-/g, '').slice(0, 24)}`;
-    const modelId = model ?? agent?.config?.model ?? agent?.model ?? 'default';
-
-    if (stream) {
-      // SSE streaming
-      res.writeHead(200, {
-        ...corsHeaders(),
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-      });
-
-      try {
-        const responseText = await this.getAgentResponse(agent, messages, { temperature, max_tokens, tools });
-        // Stream in chunks
-        const chunkSize = 10;
-        for (let i = 0; i < responseText.length; i += chunkSize) {
-          const delta = responseText.slice(i, i + chunkSize);
-          const chunk = {
-            id: requestId,
-            object: 'chat.completion.chunk',
-            created: Math.floor(Date.now() / 1000),
-            model: modelId,
-            choices: [{ index: 0, delta: { content: delta }, finish_reason: null }],
-          };
-          res.write(`data: ${JSON.stringify(chunk)}\n\n`);
-        }
-        // Final chunk
-        const finalChunk = {
-          id: requestId,
-          object: 'chat.completion.chunk',
-          created: Math.floor(Date.now() / 1000),
-          model: modelId,
-          choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
-        };
-        res.write(`data: ${JSON.stringify(finalChunk)}\n\n`);
-        res.write('data: [DONE]\n\n');
-      } catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
-        res.write(`data: ${JSON.stringify({ error: { message: errMsg } })}\n\n`);
-      }
-      res.end();
-    } else {
-      // Non-streaming
-      const responseText = await this.getAgentResponse(agent, messages, { temperature, max_tokens, tools });
-      sendJSON(res, 200, {
-        id: requestId,
-        object: 'chat.completion',
-        created: Math.floor(Date.now() / 1000),
-        model: modelId,
-        choices: [{
-          index: 0,
-          message: { role: 'assistant', content: responseText },
-          finish_reason: 'stop',
-        }],
-        usage: {
-          prompt_tokens: messages.reduce((a: number, m: any) => a + (m.content?.length ?? 0), 0),
-          completion_tokens: responseText.length,
-          total_tokens: messages.reduce((a: number, m: any) => a + (m.content?.length ?? 0), 0) + responseText.length,
-        },
-      });
-    }
-  }
-
-  private async getAgentResponse(agent: any, messages: any[], options: any): Promise<string> {
-    // Try various agent interfaces
-    if (agent?.chat) {
-      const lastUserMsg = [...messages].reverse().find((m: any) => m.role === 'user');
-      return await agent.chat(lastUserMsg?.content ?? '', options);
-    }
-    if (agent?.processMessage) {
-      const lastUserMsg = [...messages].reverse().find((m: any) => m.role === 'user');
-      const result = await agent.processMessage({ id: 'api', role: 'user', content: lastUserMsg?.content ?? '', timestamp: Date.now() });
-      return result?.response ?? result?.content ?? String(result);
-    }
-    if (agent?.provider?.chat) {
-      const formatted = messages.map((m: any) => ({ id: 'x', role: m.role, content: m.content, timestamp: Date.now() }));
-      return await agent.provider.chat(formatted, agent.systemPrompt ?? '');
-    }
-    return 'Agent does not support chat interface';
-  }
-
-  private async handleEmbeddings(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    let body: any;
-    try {
-      body = JSON.parse(await parseBody(req));
-    } catch {
-      sendJSON(res, 400, jsonError('Invalid JSON body', 'invalid_request_error', 400));
-      return;
-    }
-
-    const { input, model } = body;
-    if (!input) {
-      sendJSON(res, 400, jsonError('input is required', 'invalid_request_error', 400));
-      return;
-    }
-
-    const agent = this.config.agent;
-    const inputs = Array.isArray(input) ? input : [input];
-
-    try {
-      if (agent?.embed || agent?.provider?.embed) {
-        const embedFn = agent.embed?.bind(agent) ?? agent.provider.embed.bind(agent.provider);
-        const data = await Promise.all(inputs.map(async (text: string, i: number) => {
-          const embedding = await embedFn(text);
-          return { object: 'embedding', embedding, index: i };
-        }));
-        sendJSON(res, 200, {
-          object: 'list',
-          data,
-          model: model ?? 'default',
-          usage: { prompt_tokens: inputs.join('').length, total_tokens: inputs.join('').length },
-        });
-      } else {
-        sendJSON(res, 501, jsonError('Embedding provider not configured', 'not_implemented', 501));
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      sendJSON(res, 500, jsonError(msg, 'internal_error', 500));
-    }
-  }
-}

package/src/core/audio.ts

@@ -1,98 +0,0 @@
-/**
- * Audio Processor - v1.0.0
- * Audio transcription/synthesis wrappers with format detection, duration, split.
- */
-
-export type AudioFormat = 'wav' | 'mp3' | 'ogg' | 'flac' | 'webm' | 'aac' | 'unknown';
-
-export interface TranscribeOptions {
-  language?: string;
-  model?: string;
-  provider?: string;
-}
-
-export interface SynthesizeOptions {
-  voice?: string;
-  speed?: number;
-  format?: AudioFormat;
-  provider?: string;
-}
-
-export interface TranscribeResult {
-  text: string;
-  language?: string;
-  duration?: number;
-  segments?: { start: number; end: number; text: string }[];
-}
-
-export interface SynthesizeResult {
-  audio: Buffer;
-  format: AudioFormat;
-  duration?: number;
-}
-
-export type TranscribeFunction = (audio: Buffer, options?: TranscribeOptions) => Promise<TranscribeResult>;
-export type SynthesizeFunction = (text: string, options?: SynthesizeOptions) => Promise<SynthesizeResult>;
-
-const FORMAT_SIGNATURES: [Buffer, AudioFormat][] = [
-  [Buffer.from('RIFF'), 'wav'],
-  [Buffer.from([0xff, 0xfb]), 'mp3'],
-  [Buffer.from([0xff, 0xf3]), 'mp3'],
-  [Buffer.from([0xff, 0xf2]), 'mp3'],
-  [Buffer.from([0x49, 0x44, 0x33]), 'mp3'], // ID3
-  [Buffer.from('OggS'), 'ogg'],
-  [Buffer.from('fLaC'), 'flac'],
-  [Buffer.from([0x1a, 0x45, 0xdf, 0xa3]), 'webm'],
-];
-
-export class AudioProcessor {
-  private transcribeFn?: TranscribeFunction;
-  private synthesizeFn?: SynthesizeFunction;
-
-  constructor(options?: { transcribe?: TranscribeFunction; synthesize?: SynthesizeFunction }) {
-    this.transcribeFn = options?.transcribe;
-    this.synthesizeFn = options?.synthesize;
-  }
-
-  /** Detect audio format from buffer header */
-  static detectFormat(audio: Buffer): AudioFormat {
-    for (const [sig, fmt] of FORMAT_SIGNATURES) {
-      if (audio.length >= sig.length && audio.subarray(0, sig.length).equals(sig)) return fmt;
-    }
-    return 'unknown';
-  }
-
-  /** Estimate duration in seconds for WAV files (for others returns undefined) */
-  static estimateDuration(audio: Buffer): number | undefined {
-    const fmt = AudioProcessor.detectFormat(audio);
-    if (fmt === 'wav' && audio.length >= 44) {
-      const sampleRate = audio.readUInt32LE(24);
-      const byteRate = audio.readUInt32LE(28);
-      if (byteRate > 0) {
-        const dataSize = audio.length - 44;
-        return dataSize / byteRate;
-      }
-    }
-    return undefined;
-  }
-
-  /** Split audio buffer into chunks of roughly `chunkBytes` size */
-  static split(audio: Buffer, chunkBytes: number): Buffer[] {
-    if (chunkBytes <= 0) throw new Error('chunkBytes must be positive');
-    const chunks: Buffer[] = [];
-    for (let i = 0; i < audio.length; i += chunkBytes) {
-      chunks.push(audio.subarray(i, Math.min(i + chunkBytes, audio.length)));
-    }
-    return chunks;
-  }
-
-  async transcribe(audio: Buffer, options?: TranscribeOptions): Promise<TranscribeResult> {
-    if (!this.transcribeFn) throw new Error('No transcribe provider configured');
-    return this.transcribeFn(audio, options);
-  }
-
-  async synthesize(text: string, options?: SynthesizeOptions): Promise<SynthesizeResult> {
-    if (!this.synthesizeFn) throw new Error('No synthesize provider configured');
-    return this.synthesizeFn(text, options);
-  }
-}

package/src/core/auth.ts

@@ -1,57 +0,0 @@
-import type { Request, Response, NextFunction } from 'express';
-
-export interface AuthConfig {
-  apiKeys: string[];
-  sessionIsolation?: boolean;
-}
-
-export interface AuthSession {
-  apiKey: string;
-  userId: string;
-  createdAt: number;
-}
-
-const sessions = new Map<string, AuthSession>();
-
-export function createAuthMiddleware(config: AuthConfig) {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    // Skip auth for non-API routes and health/metrics
-    if (!req.path.startsWith('/api/') || req.path === '/api/health' || req.path === '/api/metrics') {
-      next();
-      return;
-    }
-
-    const apiKey = req.headers['x-api-key'] as string
-      ?? req.headers['authorization']?.replace(/^Bearer\s+/i, '')
-      ?? (req.query as any).apiKey;
-
-    if (!apiKey || !config.apiKeys.includes(apiKey)) {
-      res.status(401).json({ error: 'Unauthorized. Provide a valid API key via X-API-Key header, Bearer token, or ?apiKey query.' });
-      return;
-    }
-
-    // Derive userId from API key for session isolation
-    const userId = `user_${hashKey(apiKey)}`;
-    if (!sessions.has(apiKey)) {
-      sessions.set(apiKey, { apiKey, userId, createdAt: Date.now() });
-    }
-
-    // Attach user info to request
-    (req as any).userId = userId;
-    (req as any).sessionPrefix = config.sessionIsolation ? `${userId}:` : '';
-
-    next();
-  };
-}
-
-function hashKey(key: string): string {
-  let h = 0;
-  for (let i = 0; i < key.length; i++) {
-    h = ((h << 5) - h + key.charCodeAt(i)) | 0;
-  }
-  return Math.abs(h).toString(36);
-}
-
-export function getActiveSessions(): AuthSession[] {
-  return Array.from(sessions.values());
-}