opc-agent 3.0.1 → 4.0.0

package/src/channels/nostr.ts

@@ -0,0 +1,33 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface NostrChannelConfig {
+  privateKey?: string;
+  relays?: string[];
+}
+
+export class NostrChannel extends BaseChannel {
+  readonly type = 'nostr';
+  private config: NostrChannelConfig;
+
+  constructor(config: NostrChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('nostr-tools');
+    } catch {
+      throw new Error('Install nostr-tools to use the NostrChannel. Run: npm install nostr-tools');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('NostrChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/qq.ts

@@ -0,0 +1,34 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface QQChannelConfig {
+  appId?: string;
+  token?: string;
+  sandbox?: boolean;
+}
+
+export class QQChannel extends BaseChannel {
+  readonly type = 'qq';
+  private config: QQChannelConfig;
+
+  constructor(config: QQChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('qq-bot-sdk');
+    } catch {
+      throw new Error('Install qq-bot-sdk to use the QQChannel. Run: npm install qq-bot-sdk');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('QQChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/signal.ts

@@ -0,0 +1,33 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface SignalChannelConfig {
+  signalCliPath?: string;
+  phoneNumber?: string;
+}
+
+export class SignalChannel extends BaseChannel {
+  readonly type = 'signal';
+  private config: SignalChannelConfig;
+
+  constructor(config: SignalChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('signal-cli');
+    } catch {
+      throw new Error('Install signal-cli to use the SignalChannel. Run: npm install signal-cli');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('SignalChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/sms.ts

@@ -0,0 +1,34 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface SMSChannelConfig {
+  accountSid?: string;
+  authToken?: string;
+  fromNumber?: string;
+}
+
+export class SMSChannel extends BaseChannel {
+  readonly type = 'sms';
+  private config: SMSChannelConfig;
+
+  constructor(config: SMSChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('twilio');
+    } catch {
+      throw new Error('Install twilio to use the SMSChannel. Run: npm install twilio');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('SMSChannel: not yet connected. Call start() first.');
+  }
+}

package/src/channels/twitch.ts

@@ -0,0 +1,65 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface TwitchChannelConfig {
+  username: string;
+  oauthToken: string;
+  channels: string[];
+}
+
+export class TwitchChannel extends BaseChannel {
+  readonly type = 'twitch';
+  private config: TwitchChannelConfig;
+  private client: any = null;
+  private running = false;
+
+  constructor(config: TwitchChannelConfig) {
+    super();
+    if (!config.username || !config.oauthToken || !config.channels?.length) {
+      throw new Error('TwitchChannel requires username, oauthToken, and channels in config');
+    }
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    let tmi: any;
+    try {
+      tmi = require('tmi.js');
+    } catch {
+      throw new Error('Install tmi.js to use the TwitchChannel. Run: npm install tmi.js');
+    }
+    this.client = new tmi.Client({
+      identity: { username: this.config.username, password: this.config.oauthToken },
+      channels: this.config.channels,
+    });
+    await this.client.connect();
+    this.running = true;
+
+    this.client.on('message', async (channel: string, tags: any, message: string, self: boolean) => {
+      if (self || !this.handler) return;
+      const msg: Message = {
+        id: tags.id || Date.now().toString(),
+        role: 'user',
+        content: message,
+        timestamp: Date.now(),
+        metadata: { channel, username: tags.username, tags },
+      };
+      await this.handler(msg);
+    });
+  }
+
+  async stop(): Promise<void> {
+    if (this.client) {
+      await this.client.disconnect();
+      this.client = null;
+    }
+    this.running = false;
+  }
+
+  async send(channel: string, text: string): Promise<void> {
+    if (!this.running || !this.client) {
+      throw new Error('TwitchChannel: not started. Call start() first.');
+    }
+    await this.client.say(channel, text);
+  }
+}

package/src/channels/voice-call.ts

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'events';
+import { randomUUID } from 'crypto';
+
+export interface VoiceCallConfig {
+  provider: 'twilio' | 'vonage' | 'webrtc' | 'sip';
+  credentials?: Record<string, string>;
+  sttProvider?: string;
+  ttsProvider?: string;
+}
+
+interface ActiveCall {
+  callId: string;
+  from: string;
+  to: string;
+  status: 'ringing' | 'active' | 'ended';
+  startedAt: number;
+}
+
+export class VoiceCallManager extends EventEmitter {
+  private config: VoiceCallConfig;
+  private calls = new Map<string, ActiveCall>();
+  private audioListeners = new Map<string, ((audio: Buffer) => void)[]>();
+
+  constructor(config: VoiceCallConfig) {
+    super();
+    this.config = config;
+  }
+
+  private ensureCredentials(): void {
+    if (!this.config.credentials || Object.keys(this.config.credentials).length === 0) {
+      throw new Error(
+        `Voice call provider "${this.config.provider}" requires credentials. ` +
+        `Please configure credentials for ${this.config.provider} in your VoiceCallConfig.`
+      );
+    }
+  }
+
+  async startCall(to: string): Promise<string> {
+    this.ensureCredentials();
+    const callId = randomUUID();
+    const call: ActiveCall = {
+      callId,
+      from: 'self',
+      to,
+      status: 'ringing',
+      startedAt: Date.now(),
+    };
+    this.calls.set(callId, call);
+    // Simulate connection
+    setTimeout(() => {
+      const c = this.calls.get(callId);
+      if (c && c.status === 'ringing') c.status = 'active';
+    }, 100);
+    return callId;
+  }
+
+  async endCall(callId: string): Promise<void> {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    call.status = 'ended';
+    this.audioListeners.delete(callId);
+  }
+
+  onIncoming(callback: (callId: string, from: string) => void): void {
+    this.on('incoming', callback);
+  }
+
+  simulateIncoming(from: string): string {
+    const callId = randomUUID();
+    const call: ActiveCall = { callId, from, to: 'self', status: 'ringing', startedAt: Date.now() };
+    this.calls.set(callId, call);
+    this.emit('incoming', callId, from);
+    return callId;
+  }
+
+  async sendAudio(callId: string, audio: Buffer): Promise<void> {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    if (call.status !== 'active') throw new Error(`Call ${callId} is not active`);
+    // Stub: would send audio to provider
+  }
+
+  onAudio(callId: string, callback: (audio: Buffer) => void): void {
+    const listeners = this.audioListeners.get(callId) || [];
+    listeners.push(callback);
+    this.audioListeners.set(callId, listeners);
+  }
+
+  getCallStatus(callId: string): 'ringing' | 'active' | 'ended' {
+    const call = this.calls.get(callId);
+    if (!call) throw new Error(`Call ${callId} not found`);
+    return call.status;
+  }
+
+  listActiveCalls(): Array<{ callId: string; from: string; startedAt: number }> {
+    return Array.from(this.calls.values())
+      .filter(c => c.status !== 'ended')
+      .map(({ callId, from, startedAt }) => ({ callId, from, startedAt }));
+  }
+}

package/src/channels/whatsapp.ts

@@ -0,0 +1,33 @@
+import { BaseChannel } from './index';
+import type { Message } from '../core/types';
+
+export interface WhatsAppChannelConfig {
+  phoneNumber?: string;
+  authDir?: string;
+}
+
+export class WhatsAppChannel extends BaseChannel {
+  readonly type = 'whatsapp';
+  private config: WhatsAppChannelConfig;
+
+  constructor(config: WhatsAppChannelConfig = {}) {
+    super();
+    this.config = config;
+  }
+
+  async start(): Promise<void> {
+    try {
+      require('@whiskeysockets/baileys');
+    } catch {
+      throw new Error('Install @whiskeysockets/baileys to use the WhatsAppChannel. Run: npm install @whiskeysockets/baileys');
+    }
+  }
+
+  async stop(): Promise<void> {
+    // cleanup
+  }
+
+  async send(chatId: string, text: string): Promise<void> {
+    throw new Error('WhatsAppChannel: not yet connected. Call start() first.');
+  }
+}

package/src/cli.ts

@@ -901,6 +901,46 @@ program
     console.log(`\n   ${color.dim('Press Ctrl+C to stop.')}\n`);
   });
 
+// ── Serve command (OpenAI-compatible API) ────────────────────
+
+program
+  .command('serve')
+  .description('Start OpenAI-compatible API server')
+  .option('-f, --file <file>', 'OAD file', 'oad.yaml')
+  .option('-p, --port <port>', 'Port', '8080')
+  .option('-H, --host <host>', 'Host', '0.0.0.0')
+  .option('-k, --api-key <key>', 'API key for auth')
+  .action(async (opts: { file: string; port: string; host: string; apiKey?: string }) => {
+    loadDotEnv();
+    const { APIServer } = require('./core/api-server');
+    const runtime = new AgentRuntime();
+    await runtime.loadConfig(opts.file);
+    await runtime.initialize();
+    await runtime.start();
+    const agent = runtime.getAgent();
+
+    const server = new APIServer({
+      port: parseInt(opts.port) || 8080,
+      host: opts.host,
+      apiKey: opts.apiKey ?? process.env.OPC_API_KEY,
+      agent,
+    });
+    await server.start();
+
+    const name = agent?.name ?? 'unknown';
+    console.log(`\n${icon.rocket} OpenAI-compatible API server running`);
+    console.log(`   Agent: ${color.bold(name)}`);
+    console.log(`   URL:   ${color.cyan(`http://${opts.host}:${opts.port}`)}`);
+    console.log(`   Auth:  ${opts.apiKey ? color.green('enabled') : color.yellow('disabled')}`);
+    console.log(`\n   Endpoints:`);
+    console.log(`     POST /v1/chat/completions`);
+    console.log(`     GET  /v1/models`);
+    console.log(`     POST /v1/embeddings`);
+    console.log(`     GET  /health`);
+    console.log(`     GET  /v1/agent/status`);
+    console.log(`\n   ${color.dim('Press Ctrl+C to stop.')}\n`);
+  });
+
 // ── Info command ─────────────────────────────────────────────
 
 program

package/src/core/api-server.ts

@@ -0,0 +1,277 @@
+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));
+    }
+  }
+}