opc-agent 3.0.1 → 4.0.1

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

package/dist/core/audio.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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>;
+export declare class AudioProcessor {
+    private transcribeFn?;
+    private synthesizeFn?;
+    constructor(options?: {
+        transcribe?: TranscribeFunction;
+        synthesize?: SynthesizeFunction;
+    });
+    /** Detect audio format from buffer header */
+    static detectFormat(audio: Buffer): AudioFormat;
+    /** Estimate duration in seconds for WAV files (for others returns undefined) */
+    static estimateDuration(audio: Buffer): number | undefined;
+    /** Split audio buffer into chunks of roughly `chunkBytes` size */
+    static split(audio: Buffer, chunkBytes: number): Buffer[];
+    transcribe(audio: Buffer, options?: TranscribeOptions): Promise<TranscribeResult>;
+    synthesize(text: string, options?: SynthesizeOptions): Promise<SynthesizeResult>;
+}
+//# sourceMappingURL=audio.d.ts.map

package/dist/core/audio.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Audio Processor - v1.0.0
+ * Audio transcription/synthesis wrappers with format detection, duration, split.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioProcessor = void 0;
+const FORMAT_SIGNATURES = [
+    [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'],
+];
+class AudioProcessor {
+    transcribeFn;
+    synthesizeFn;
+    constructor(options) {
+        this.transcribeFn = options?.transcribe;
+        this.synthesizeFn = options?.synthesize;
+    }
+    /** Detect audio format from buffer header */
+    static detectFormat(audio) {
+        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) {
+        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, chunkBytes) {
+        if (chunkBytes <= 0)
+            throw new Error('chunkBytes must be positive');
+        const chunks = [];
+        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, options) {
+        if (!this.transcribeFn)
+            throw new Error('No transcribe provider configured');
+        return this.transcribeFn(audio, options);
+    }
+    async synthesize(text, options) {
+        if (!this.synthesizeFn)
+            throw new Error('No synthesize provider configured');
+        return this.synthesizeFn(text, options);
+    }
+}
+exports.AudioProcessor = AudioProcessor;
+//# sourceMappingURL=audio.js.map

package/dist/core/context-discovery.d.ts

@@ -0,0 +1,16 @@
+export interface ContextFile {
+    path: string;
+    type: 'agents' | 'soul' | 'user' | 'memory' | 'tools' | 'identity' | 'heartbeat' | 'bootstrap' | 'custom';
+    content: string;
+}
+export declare class ContextDiscovery {
+    static STANDARD_FILES: string[];
+    private customFiles;
+    private watchers;
+    discover(workDir?: string): ContextFile[];
+    load(files: ContextFile[]): string;
+    watch(workDir: string, onChange: Function): void;
+    stopWatching(): void;
+    addCustomFile(filePath: string): void;
+}
+//# sourceMappingURL=context-discovery.d.ts.map

package/dist/core/context-discovery.js

@@ -0,0 +1,107 @@
+"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.ContextDiscovery = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FILE_TYPE_MAP = {
+    'AGENTS.md': 'agents',
+    'SOUL.md': 'soul',
+    'USER.md': 'user',
+    'MEMORY.md': 'memory',
+    'TOOLS.md': 'tools',
+    'IDENTITY.md': 'identity',
+    'HEARTBEAT.md': 'heartbeat',
+    'BOOTSTRAP.md': 'bootstrap',
+    '.opc.md': 'custom',
+    '.opc/config.md': 'custom',
+};
+class ContextDiscovery {
+    static STANDARD_FILES = [
+        'AGENTS.md', 'SOUL.md', 'USER.md', 'MEMORY.md', 'TOOLS.md',
+        'IDENTITY.md', 'HEARTBEAT.md', 'BOOTSTRAP.md',
+        '.opc.md', '.opc/config.md',
+    ];
+    customFiles = [];
+    watchers = [];
+    discover(workDir) {
+        const dir = workDir || process.cwd();
+        const found = [];
+        for (const file of ContextDiscovery.STANDARD_FILES) {
+            const fullPath = path.join(dir, file);
+            if (fs.existsSync(fullPath)) {
+                found.push({
+                    path: fullPath,
+                    type: FILE_TYPE_MAP[file] || 'custom',
+                    content: fs.readFileSync(fullPath, 'utf-8'),
+                });
+            }
+        }
+        for (const file of this.customFiles) {
+            const fullPath = path.isAbsolute(file) ? file : path.join(dir, file);
+            if (fs.existsSync(fullPath)) {
+                found.push({
+                    path: fullPath,
+                    type: 'custom',
+                    content: fs.readFileSync(fullPath, 'utf-8'),
+                });
+            }
+        }
+        return found;
+    }
+    load(files) {
+        return files.map(f => `# ${f.type.toUpperCase()}\n${f.content}`).join('\n\n');
+    }
+    watch(workDir, onChange) {
+        const watcher = fs.watch(workDir, { recursive: false }, (event, filename) => {
+            if (filename && ContextDiscovery.STANDARD_FILES.includes(filename)) {
+                onChange(filename, event);
+            }
+        });
+        this.watchers.push(watcher);
+    }
+    stopWatching() {
+        for (const w of this.watchers)
+            w.close();
+        this.watchers = [];
+    }
+    addCustomFile(filePath) {
+        if (!this.customFiles.includes(filePath)) {
+            this.customFiles.push(filePath);
+        }
+    }
+}
+exports.ContextDiscovery = ContextDiscovery;
+//# sourceMappingURL=context-discovery.js.map

package/dist/core/context-refs.d.ts

@@ -0,0 +1,29 @@
+export type RefType = 'file' | 'folder' | 'url' | 'git-diff' | 'git-log';
+export interface ContextRef {
+    type: RefType;
+    path: string;
+    content?: string;
+}
+export interface Message {
+    role: string;
+    content: string;
+    [key: string]: unknown;
+}
+export declare class ContextRefResolver {
+    /**
+     * Parse @-references from text without resolving content.
+     */
+    parseRefs(text: string): ContextRef[];
+    /**
+     * Resolve content for each ref. Returns new array with content filled in.
+     */
+    resolveRefs(refs: ContextRef[]): Promise<ContextRef[]>;
+    private resolveOne;
+    private listDir;
+    private fetchUrl;
+    /**
+     * Inject resolved refs as system messages before the user's last message.
+     */
+    injectRefs(messages: Message[], refs: ContextRef[]): Message[];
+}
+//# sourceMappingURL=context-refs.d.ts.map