opc-agent 3.0.1 → 4.0.0

package/dist/channels/signal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SignalChannel = void 0;
+const index_1 = require("./index");
+class SignalChannel extends index_1.BaseChannel {
+    type = 'signal';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('signal-cli');
+        }
+        catch {
+            throw new Error('Install signal-cli to use the SignalChannel. Run: npm install signal-cli');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('SignalChannel: not yet connected. Call start() first.');
+    }
+}
+exports.SignalChannel = SignalChannel;
+//# sourceMappingURL=signal.js.map

package/dist/channels/sms.d.ts

@@ -0,0 +1,15 @@
+import { BaseChannel } from './index';
+export interface SMSChannelConfig {
+    accountSid?: string;
+    authToken?: string;
+    fromNumber?: string;
+}
+export declare class SMSChannel extends BaseChannel {
+    readonly type = "sms";
+    private config;
+    constructor(config?: SMSChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(chatId: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=sms.d.ts.map

package/dist/channels/sms.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SMSChannel = void 0;
+const index_1 = require("./index");
+class SMSChannel extends index_1.BaseChannel {
+    type = 'sms';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('twilio');
+        }
+        catch {
+            throw new Error('Install twilio to use the SMSChannel. Run: npm install twilio');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('SMSChannel: not yet connected. Call start() first.');
+    }
+}
+exports.SMSChannel = SMSChannel;
+//# sourceMappingURL=sms.js.map

package/dist/channels/twitch.d.ts

@@ -0,0 +1,17 @@
+import { BaseChannel } from './index';
+export interface TwitchChannelConfig {
+    username: string;
+    oauthToken: string;
+    channels: string[];
+}
+export declare class TwitchChannel extends BaseChannel {
+    readonly type = "twitch";
+    private config;
+    private client;
+    private running;
+    constructor(config: TwitchChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(channel: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=twitch.d.ts.map

package/dist/channels/twitch.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TwitchChannel = void 0;
+const index_1 = require("./index");
+class TwitchChannel extends index_1.BaseChannel {
+    type = 'twitch';
+    config;
+    client = null;
+    running = false;
+    constructor(config) {
+        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() {
+        let tmi;
+        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, tags, message, self) => {
+            if (self || !this.handler)
+                return;
+            const msg = {
+                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() {
+        if (this.client) {
+            await this.client.disconnect();
+            this.client = null;
+        }
+        this.running = false;
+    }
+    async send(channel, text) {
+        if (!this.running || !this.client) {
+            throw new Error('TwitchChannel: not started. Call start() first.');
+        }
+        await this.client.say(channel, text);
+    }
+}
+exports.TwitchChannel = TwitchChannel;
+//# sourceMappingURL=twitch.js.map

package/dist/channels/voice-call.d.ts

@@ -0,0 +1,27 @@
+import { EventEmitter } from 'events';
+export interface VoiceCallConfig {
+    provider: 'twilio' | 'vonage' | 'webrtc' | 'sip';
+    credentials?: Record<string, string>;
+    sttProvider?: string;
+    ttsProvider?: string;
+}
+export declare class VoiceCallManager extends EventEmitter {
+    private config;
+    private calls;
+    private audioListeners;
+    constructor(config: VoiceCallConfig);
+    private ensureCredentials;
+    startCall(to: string): Promise<string>;
+    endCall(callId: string): Promise<void>;
+    onIncoming(callback: (callId: string, from: string) => void): void;
+    simulateIncoming(from: string): string;
+    sendAudio(callId: string, audio: Buffer): Promise<void>;
+    onAudio(callId: string, callback: (audio: Buffer) => void): void;
+    getCallStatus(callId: string): 'ringing' | 'active' | 'ended';
+    listActiveCalls(): Array<{
+        callId: string;
+        from: string;
+        startedAt: number;
+    }>;
+}
+//# sourceMappingURL=voice-call.d.ts.map

package/dist/channels/voice-call.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoiceCallManager = void 0;
+const events_1 = require("events");
+const crypto_1 = require("crypto");
+class VoiceCallManager extends events_1.EventEmitter {
+    config;
+    calls = new Map();
+    audioListeners = new Map();
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    ensureCredentials() {
+        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) {
+        this.ensureCredentials();
+        const callId = (0, crypto_1.randomUUID)();
+        const call = {
+            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) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error(`Call ${callId} not found`);
+        call.status = 'ended';
+        this.audioListeners.delete(callId);
+    }
+    onIncoming(callback) {
+        this.on('incoming', callback);
+    }
+    simulateIncoming(from) {
+        const callId = (0, crypto_1.randomUUID)();
+        const call = { callId, from, to: 'self', status: 'ringing', startedAt: Date.now() };
+        this.calls.set(callId, call);
+        this.emit('incoming', callId, from);
+        return callId;
+    }
+    async sendAudio(callId, audio) {
+        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, callback) {
+        const listeners = this.audioListeners.get(callId) || [];
+        listeners.push(callback);
+        this.audioListeners.set(callId, listeners);
+    }
+    getCallStatus(callId) {
+        const call = this.calls.get(callId);
+        if (!call)
+            throw new Error(`Call ${callId} not found`);
+        return call.status;
+    }
+    listActiveCalls() {
+        return Array.from(this.calls.values())
+            .filter(c => c.status !== 'ended')
+            .map(({ callId, from, startedAt }) => ({ callId, from, startedAt }));
+    }
+}
+exports.VoiceCallManager = VoiceCallManager;
+//# sourceMappingURL=voice-call.js.map

package/dist/channels/whatsapp.d.ts

@@ -0,0 +1,14 @@
+import { BaseChannel } from './index';
+export interface WhatsAppChannelConfig {
+    phoneNumber?: string;
+    authDir?: string;
+}
+export declare class WhatsAppChannel extends BaseChannel {
+    readonly type = "whatsapp";
+    private config;
+    constructor(config?: WhatsAppChannelConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    send(chatId: string, text: string): Promise<void>;
+}
+//# sourceMappingURL=whatsapp.d.ts.map

package/dist/channels/whatsapp.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsAppChannel = void 0;
+const index_1 = require("./index");
+class WhatsAppChannel extends index_1.BaseChannel {
+    type = 'whatsapp';
+    config;
+    constructor(config = {}) {
+        super();
+        this.config = config;
+    }
+    async start() {
+        try {
+            require('@whiskeysockets/baileys');
+        }
+        catch {
+            throw new Error('Install @whiskeysockets/baileys to use the WhatsAppChannel. Run: npm install @whiskeysockets/baileys');
+        }
+    }
+    async stop() {
+        // cleanup
+    }
+    async send(chatId, text) {
+        throw new Error('WhatsAppChannel: not yet connected. Call start() first.');
+    }
+}
+exports.WhatsAppChannel = WhatsAppChannel;
+//# sourceMappingURL=whatsapp.js.map

package/dist/cli.js

@@ -800,6 +800,42 @@ program
     console.log(`   ${color.dim('API:')}    POST http://localhost:3000/api/chat`);
     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) => {
+    loadDotEnv();
+    const { APIServer } = require('./core/api-server');
+    const runtime = new runtime_1.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
     .command('info')

package/dist/core/api-server.d.ts

@@ -0,0 +1,25 @@
+export interface APIServerConfig {
+    port: number;
+    host: string;
+    apiKey?: string;
+    agent: any;
+}
+export declare class APIServer {
+    private server;
+    private config;
+    constructor(config: Partial<APIServerConfig> & {
+        agent: any;
+    });
+    private authenticate;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getPort(): number;
+    getHost(): string;
+    private handleRequest;
+    private handleModels;
+    private handleAgentStatus;
+    private handleChatCompletions;
+    private getAgentResponse;
+    private handleEmbeddings;
+}
+//# sourceMappingURL=api-server.d.ts.map

package/dist/core/api-server.js

@@ -0,0 +1,286 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIServer = void 0;
+const http = __importStar(require("http"));
+const crypto_1 = require("crypto");
+function jsonError(message, type, code) {
+    return { error: { message, type, code } };
+}
+function corsHeaders() {
+    return {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+    };
+}
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (c) => chunks.push(c));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString()));
+        req.on('error', reject);
+    });
+}
+function sendJSON(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, { ...corsHeaders(), 'Content-Type': 'application/json' });
+    res.end(body);
+}
+class APIServer {
+    server = null;
+    config;
+    constructor(config) {
+        this.config = {
+            port: config.port ?? 8080,
+            host: config.host ?? '0.0.0.0',
+            apiKey: config.apiKey,
+            agent: config.agent,
+        };
+    }
+    authenticate(req) {
+        if (!this.config.apiKey)
+            return true;
+        const auth = req.headers['authorization'] ?? '';
+        return auth === `Bearer ${this.config.apiKey}`;
+    }
+    async start() {
+        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() {
+        return new Promise((resolve) => {
+            if (this.server)
+                this.server.close(() => resolve());
+            else
+                resolve();
+        });
+    }
+    getPort() { return this.config.port; }
+    getHost() { return this.config.host; }
+    async handleRequest(req, res) {
+        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));
+        }
+    }
+    handleModels(res) {
+        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' }],
+        });
+    }
+    handleAgentStatus(res) {
+        const agent = this.config.agent;
+        sendJSON(res, 200, {
+            name: agent?.name ?? agent?.config?.name ?? 'unknown',
+            state: agent?.state ?? 'unknown',
+            uptime: process.uptime(),
+        });
+    }
+    async handleChatCompletions(req, res) {
+        let body;
+        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-${(0, crypto_1.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, m) => a + (m.content?.length ?? 0), 0),
+                    completion_tokens: responseText.length,
+                    total_tokens: messages.reduce((a, m) => a + (m.content?.length ?? 0), 0) + responseText.length,
+                },
+            });
+        }
+    }
+    async getAgentResponse(agent, messages, options) {
+        // Try various agent interfaces
+        if (agent?.chat) {
+            const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
+            return await agent.chat(lastUserMsg?.content ?? '', options);
+        }
+        if (agent?.processMessage) {
+            const lastUserMsg = [...messages].reverse().find((m) => 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) => ({ 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';
+    }
+    async handleEmbeddings(req, res) {
+        let body;
+        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, i) => {
+                    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));
+        }
+    }
+}
+exports.APIServer = APIServer;
+//# sourceMappingURL=api-server.js.map