opc-agent 1.3.2 → 2.0.0

package/dist/core/agent.d.ts

@@ -1,6 +1,10 @@
 import { EventEmitter } from 'events';
 import type { AgentState, IAgent, IChannel, ISkill, Message, MemoryStore } from './types';
 import { type LLMProvider } from '../providers';
+import { SkillLearner } from '../skills/auto-learn';
+import type { MCPTool } from '../tools/mcp';
+import { MCPToolRegistry } from '../tools/mcp';
+import { type SubAgentConfig, type SubAgentResult } from './subagent';
 export declare class BaseAgent extends EventEmitter implements IAgent {
     readonly name: string;
     private _state;
@@ -10,6 +14,11 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private _provider;
     private systemPrompt;
     private historyLimit;
+    private toolRegistry;
+    private maxToolRounds;
+    private skillLearner?;
+    private autoLearnConfig;
+    private _subAgentManager?;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -17,11 +26,21 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
         model?: string;
         memory?: MemoryStore;
         historyLimit?: number;
+        skillsDir?: string;
+        learning?: {
+            autoSkillCreation?: boolean;
+            minConversationLength?: number;
+            improveOnUse?: boolean;
+        };
+        maxToolRounds?: number;
     });
     get state(): AgentState;
     get provider(): LLMProvider;
     getSystemPrompt(): string;
     getMemory(): MemoryStore;
+    getSkillLearner(): SkillLearner | undefined;
+    getToolRegistry(): MCPToolRegistry;
+    registerTool(tool: MCPTool): void;
     private transition;
     init(): Promise<void>;
     start(): Promise<void>;
@@ -29,7 +48,11 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     registerSkill(skill: ISkill): void;
     bindChannel(channel: IChannel): void;
     getChannels(): IChannel[];
+    private getSubAgentManager;
+    spawnSubAgent(config: SubAgentConfig): Promise<SubAgentResult>;
+    spawnParallel(configs: SubAgentConfig[]): Promise<SubAgentResult[]>;
     handleMessage(message: Message): Promise<Message>;
+    private parseToolCall;
     handleMessageStream(message: Message): AsyncIterable<string>;
     private createResponse;
 }

package/dist/core/agent.js

@@ -4,6 +4,9 @@ exports.BaseAgent = void 0;
 const events_1 = require("events");
 const memory_1 = require("../memory");
 const providers_1 = require("../providers");
+const auto_learn_1 = require("../skills/auto-learn");
+const mcp_1 = require("../tools/mcp");
+const subagent_1 = require("./subagent");
 class BaseAgent extends events_1.EventEmitter {
     name;
     _state = 'init';
@@ -13,6 +16,11 @@ class BaseAgent extends events_1.EventEmitter {
     _provider;
     systemPrompt;
     historyLimit;
+    toolRegistry = new mcp_1.MCPToolRegistry();
+    maxToolRounds;
+    skillLearner;
+    autoLearnConfig;
+    _subAgentManager;
     constructor(options) {
         super();
         this.name = options.name;
@@ -20,6 +28,15 @@ class BaseAgent extends events_1.EventEmitter {
         this.memory = options.memory ?? new memory_1.InMemoryStore();
         this._provider = (0, providers_1.createProvider)(options.provider ?? 'openai', options.model);
         this.historyLimit = options.historyLimit ?? 50;
+        this.maxToolRounds = options.maxToolRounds ?? 10;
+        this.autoLearnConfig = {
+            enabled: options.learning?.autoSkillCreation !== false,
+            minConversationLength: options.learning?.minConversationLength ?? 3,
+            improveOnUse: options.learning?.improveOnUse !== false,
+        };
+        if (options.skillsDir) {
+            this.skillLearner = new auto_learn_1.SkillLearner(options.skillsDir);
+        }
     }
     get state() {
         return this._state;
@@ -33,12 +50,24 @@ class BaseAgent extends events_1.EventEmitter {
     getMemory() {
         return this.memory;
     }
+    getSkillLearner() {
+        return this.skillLearner;
+    }
+    getToolRegistry() {
+        return this.toolRegistry;
+    }
+    registerTool(tool) {
+        this.toolRegistry.register(tool);
+    }
     transition(to) {
         const from = this._state;
         this._state = to;
         this.emit('state:change', from, to);
     }
     async init() {
+        if (this.skillLearner) {
+            await this.skillLearner.loadLearnedSkills();
+        }
         this.transition('ready');
     }
     async start() {
@@ -66,6 +95,18 @@ class BaseAgent extends events_1.EventEmitter {
     getChannels() {
         return this.channels;
     }
+    getSubAgentManager() {
+        if (!this._subAgentManager) {
+            this._subAgentManager = new subagent_1.SubAgentManager();
+        }
+        return this._subAgentManager;
+    }
+    async spawnSubAgent(config) {
+        return this.getSubAgentManager().spawn(config, this._provider);
+    }
+    async spawnParallel(configs) {
+        return this.getSubAgentManager().spawnParallel(configs, this._provider);
+    }
     async handleMessage(message) {
         this.emit('message:in', message);
         const sessionId = message.metadata?.sessionId ?? 'default';
@@ -93,13 +134,89 @@ class BaseAgent extends events_1.EventEmitter {
                 this.emit('error', err instanceof Error ? err : new Error(String(err)));
             }
         }
-        // Fall back to LLM
-        const llmResponse = await this._provider.chat(context.messages, this.systemPrompt);
-        const response = this.createResponse(llmResponse, message);
+        // Check if a learned skill matches — prepend instructions to system prompt
+        let effectiveSystemPrompt = this.systemPrompt;
+        const matchedSkill = this.skillLearner?.matchSkill(message.content);
+        if (matchedSkill) {
+            matchedSkill.usageCount++;
+            matchedSkill.lastUsed = new Date();
+            effectiveSystemPrompt = `[Learned Skill: ${matchedSkill.name}]\n${matchedSkill.instructions}\n\n${this.systemPrompt}`;
+            this.emit('skill:matched', matchedSkill);
+        }
+        // Fall back to LLM with tool use loop
+        const tools = this.toolRegistry.list();
+        const llmMessages = [...context.messages];
+        let finalResponse = '';
+        for (let round = 0; round <= this.maxToolRounds; round++) {
+            const llmResponse = await this._provider.chat(llmMessages, effectiveSystemPrompt, { tools: tools.length > 0 ? tools : undefined });
+            const toolCall = this.parseToolCall(llmResponse);
+            if (!toolCall || tools.length === 0 || round === this.maxToolRounds) {
+                finalResponse = llmResponse;
+                break;
+            }
+            // Execute tool
+            const toolResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
+            this.emit('tool:execute', toolCall.name, toolResult);
+            // Add tool call and result to messages for next round
+            llmMessages.push({
+                id: `tool_call_${Date.now()}`,
+                role: 'assistant',
+                content: llmResponse,
+                timestamp: Date.now(),
+            });
+            llmMessages.push({
+                id: `tool_result_${Date.now()}`,
+                role: 'user',
+                content: `[Tool Result for ${toolCall.name}]: ${toolResult.content}`,
+                timestamp: Date.now(),
+            });
+        }
+        const response = this.createResponse(finalResponse, message);
         await this.memory.addMessage(sessionId, response);
         this.emit('message:out', response);
+        // After response, check if we should learn a skill
+        if (this.skillLearner &&
+            this.autoLearnConfig.enabled &&
+            context.messages.length >= this.autoLearnConfig.minConversationLength) {
+            this.skillLearner
+                .analyzeForSkillCreation(context.messages, this._provider)
+                .then(async (learnedSkill) => {
+                if (learnedSkill) {
+                    await this.skillLearner.saveSkill(learnedSkill);
+                    this.emit('skill:learned', learnedSkill);
+                }
+            })
+                .catch(() => { });
+        }
+        // Improve matched skill after use
+        if (matchedSkill && this.skillLearner && this.autoLearnConfig.improveOnUse) {
+            this.skillLearner
+                .improveSkill(matchedSkill, context.messages, this._provider)
+                .then(() => this.skillLearner.saveSkill(matchedSkill))
+                .catch(() => { });
+        }
         return response;
     }
+    parseToolCall(response) {
+        try {
+            const parsed = JSON.parse(response);
+            if (parsed.tool_call)
+                return parsed.tool_call;
+            if (parsed.name && parsed.arguments !== undefined)
+                return parsed;
+        }
+        catch { /* not JSON */ }
+        const match = response.match(/<tool_call>\s*(\{[\s\S]*?\})\s*<\/tool_call>/);
+        if (match) {
+            try {
+                const parsed = JSON.parse(match[1]);
+                if (parsed.name)
+                    return parsed;
+            }
+            catch { /* not valid JSON */ }
+        }
+        return null;
+    }
     async *handleMessageStream(message) {
         const sessionId = message.metadata?.sessionId ?? 'default';
         await this.memory.addMessage(sessionId, message);

package/dist/core/runtime.d.ts

@@ -1,4 +1,5 @@
 import { BaseAgent } from './agent';
+import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
 import type { ISkill } from './types';
 export declare function truncateOutput(output: string, maxChars?: number): string;
@@ -9,6 +10,8 @@ export declare class AgentRuntime {
     private historyLimit;
     private shutdownHandlers;
     private isShuttingDown;
+    private analytics;
+    private scheduler;
     loadConfig(filePath: string): Promise<OADDocument>;
     setHistoryLimit(limit: number): void;
     initialize(config?: OADDocument): Promise<BaseAgent>;
@@ -18,5 +21,7 @@ export declare class AgentRuntime {
     private setupGracefulShutdown;
     registerSkill(skill: ISkill): void;
     getAgent(): BaseAgent | null;
+    getAnalytics(): Analytics;
+    getConfig(): OADDocument | null;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/core/runtime.js

@@ -9,6 +9,8 @@ const web_1 = require("../channels/web");
 const telegram_1 = require("../channels/telegram");
 const websocket_1 = require("../channels/websocket");
 const deepbrain_1 = require("../memory/deepbrain");
+const analytics_1 = require("../analytics");
+const scheduler_1 = require("./scheduler");
 const MAX_TOOL_OUTPUT = 5000;
 const DEFAULT_HISTORY_LIMIT = 50;
 function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT) {
@@ -24,6 +26,8 @@ class AgentRuntime {
     historyLimit = DEFAULT_HISTORY_LIMIT;
     shutdownHandlers = [];
     isShuttingDown = false;
+    analytics = new analytics_1.Analytics();
+    scheduler = null;
     async loadConfig(filePath) {
         this.config = (0, config_1.loadOAD)(filePath);
         this.logger.info('Config loaded', { name: this.config.metadata.name });
@@ -58,6 +62,12 @@ class AgentRuntime {
                 const port = ch.port ?? 3000;
                 const webChannel = new web_1.WebChannel(port);
                 webChannel.setAgentName(cfg.metadata.name);
+                webChannel.setAgentVersion(cfg.metadata.version);
+                webChannel.setAnalyticsProvider(() => this.analytics.getSnapshot());
+                webChannel.setChannelNames(cfg.spec.channels.map((c) => c.type));
+                webChannel.setSkillNames(cfg.spec.skills.map((s) => s.name));
+                const memType = memCfg && typeof memCfg.longTerm === 'object' && memCfg.longTerm.provider === 'deepbrain' ? 'deepbrain' : 'in-memory';
+                webChannel.setMemoryType(memType);
                 // Wire streaming
                 webChannel.onStreamMessage(async (msg, res) => {
                     res.writeHead(200, {
@@ -66,15 +76,18 @@ class AgentRuntime {
                         Connection: 'keep-alive',
                         'Access-Control-Allow-Origin': '*',
                     });
+                    const startTime = Date.now();
                     try {
                         for await (const chunk of this.agent.handleMessageStream(msg)) {
                             res.write(`data: ${JSON.stringify({ content: chunk })}\n\n`);
                         }
                         res.write('data: [DONE]\n\n');
+                        this.analytics.recordMessage(Date.now() - startTime);
                     }
                     catch (err) {
                         const errMsg = err instanceof Error ? err.message : String(err);
                         res.write(`data: ${JSON.stringify({ error: errMsg })}\n\n`);
+                        this.analytics.recordError();
                     }
                     res.end();
                 });
@@ -94,7 +107,51 @@ class AgentRuntime {
             }
         }
         await this.agent.init();
+        // Wire analytics to agent events
+        this.agent.on('message:out', () => {
+            // responseTime is approximated; real timing is done via skill/llm events
+        });
+        this.agent.on('skill:execute', (skillName) => {
+            this.analytics.recordSkillUsage(skillName);
+        });
+        this.agent.on('error', () => {
+            this.analytics.recordError();
+        });
         this.logger.info('Agent initialized', { name: cfg.metadata.name });
+        // Initialize scheduler if jobs are configured
+        const schedulerCfg = cfg.spec.scheduler;
+        if (schedulerCfg?.jobs && Array.isArray(schedulerCfg.jobs) && schedulerCfg.jobs.length > 0) {
+            this.scheduler = new scheduler_1.Scheduler(async (job) => {
+                this.logger.info('Scheduler firing job', { name: job.name, task: job.task });
+                if (this.agent) {
+                    const msg = {
+                        id: `cron-${job.id}-${Date.now()}`,
+                        role: 'user',
+                        content: job.task,
+                        timestamp: Date.now(),
+                        metadata: { source: 'scheduler', jobId: job.id, jobName: job.name },
+                    };
+                    try {
+                        await this.agent.handleMessage(msg);
+                    }
+                    catch (err) {
+                        this.logger.error('Scheduler job failed', { name: job.name, error: err instanceof Error ? err.message : String(err) });
+                    }
+                }
+            });
+            for (let i = 0; i < schedulerCfg.jobs.length; i++) {
+                const j = schedulerCfg.jobs[i];
+                const id = j.id || j.name?.toLowerCase().replace(/\s+/g, '-') || `job-${i}`;
+                this.scheduler.addJob({
+                    id,
+                    name: j.name || id,
+                    schedule: j.schedule,
+                    task: j.task || '',
+                    enabled: j.enabled !== false,
+                });
+            }
+            this.logger.info('Scheduler configured', { jobs: schedulerCfg.jobs.length });
+        }
         return this.agent;
     }
     async start() {
@@ -102,12 +159,20 @@ class AgentRuntime {
             throw new Error('Agent not initialized.');
         this.setupGracefulShutdown();
         await this.agent.start();
+        if (this.scheduler) {
+            this.scheduler.start();
+            this.logger.info('Scheduler started');
+        }
         this.logger.info('Agent started');
     }
     async stop() {
         if (!this.agent)
             return;
         this.logger.info('Stopping agent...');
+        if (this.scheduler) {
+            this.scheduler.stop();
+            this.logger.info('Scheduler stopped');
+        }
         await this.agent.stop();
         for (const handler of this.shutdownHandlers) {
             await handler();
@@ -142,6 +207,12 @@ class AgentRuntime {
     getAgent() {
         return this.agent;
     }
+    getAnalytics() {
+        return this.analytics;
+    }
+    getConfig() {
+        return this.config;
+    }
 }
 exports.AgentRuntime = AgentRuntime;
 //# sourceMappingURL=runtime.js.map

package/dist/core/scheduler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    task: string;
+    enabled: boolean;
+    lastRun?: Date;
+    nextRun?: Date;
+}
+type CronField = {
+    type: 'any';
+} | {
+    type: 'every';
+    step: number;
+} | {
+    type: 'list';
+    values: number[];
+};
+interface ParsedCron {
+    minute: CronField;
+    hour: CronField;
+    dayOfMonth: CronField;
+    month: CronField;
+    dayOfWeek: CronField;
+}
+export declare function parseCron(expr: string): ParsedCron;
+export declare function cronMatches(parsed: ParsedCron, date: Date): boolean;
+export type JobHandler = (job: CronJob) => void | Promise<void>;
+export declare class Scheduler {
+    private jobs;
+    private parsed;
+    private timer;
+    private handler;
+    constructor(handler: JobHandler);
+    addJob(job: CronJob): void;
+    removeJob(id: string): void;
+    enableJob(id: string): void;
+    disableJob(id: string): void;
+    getJobs(): CronJob[];
+    getJob(id: string): CronJob | undefined;
+    /** Run a specific job immediately */
+    runJob(id: string): Promise<boolean>;
+    start(): void;
+    stop(): void;
+    private tick;
+}
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/core/scheduler.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+exports.parseCron = parseCron;
+exports.cronMatches = cronMatches;
+function parseField(field, min, max) {
+    if (field === '*')
+        return { type: 'any' };
+    if (field.startsWith('*/')) {
+        const step = parseInt(field.slice(2), 10);
+        if (isNaN(step) || step <= 0)
+            throw new Error(`Invalid cron step: ${field}`);
+        return { type: 'every', step };
+    }
+    // Could be comma-separated, each part could be a range
+    const values = [];
+    for (const part of field.split(',')) {
+        if (part.includes('-')) {
+            const [a, b] = part.split('-').map(Number);
+            if (isNaN(a) || isNaN(b))
+                throw new Error(`Invalid cron range: ${part}`);
+            for (let i = a; i <= b; i++)
+                values.push(i);
+        }
+        else {
+            const n = parseInt(part, 10);
+            if (isNaN(n))
+                throw new Error(`Invalid cron value: ${part}`);
+            values.push(n);
+        }
+    }
+    return { type: 'list', values };
+}
+function parseCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`Invalid cron expression (need 5 fields): ${expr}`);
+    return {
+        minute: parseField(parts[0], 0, 59),
+        hour: parseField(parts[1], 0, 23),
+        dayOfMonth: parseField(parts[2], 1, 31),
+        month: parseField(parts[3], 1, 12),
+        dayOfWeek: parseField(parts[4], 0, 6),
+    };
+}
+function fieldMatches(field, value) {
+    switch (field.type) {
+        case 'any': return true;
+        case 'every': return value % field.step === 0;
+        case 'list': return field.values.includes(value);
+    }
+}
+function cronMatches(parsed, date) {
+    return (fieldMatches(parsed.minute, date.getMinutes()) &&
+        fieldMatches(parsed.hour, date.getHours()) &&
+        fieldMatches(parsed.dayOfMonth, date.getDate()) &&
+        fieldMatches(parsed.month, date.getMonth() + 1) &&
+        fieldMatches(parsed.dayOfWeek, date.getDay()));
+}
+/** Compute approximate next run (scans forward up to 48h). */
+function computeNextRun(parsed, from) {
+    const d = new Date(from);
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    const limit = 48 * 60; // 48 hours in minutes
+    for (let i = 0; i < limit; i++) {
+        if (cronMatches(parsed, d))
+            return new Date(d);
+        d.setMinutes(d.getMinutes() + 1);
+    }
+    return undefined;
+}
+class Scheduler {
+    jobs = new Map();
+    parsed = new Map();
+    timer = null;
+    handler;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    addJob(job) {
+        const p = parseCron(job.schedule);
+        this.parsed.set(job.id, p);
+        job.nextRun = computeNextRun(p, new Date()) ?? undefined;
+        this.jobs.set(job.id, job);
+    }
+    removeJob(id) {
+        this.jobs.delete(id);
+        this.parsed.delete(id);
+    }
+    enableJob(id) {
+        const job = this.jobs.get(id);
+        if (job)
+            job.enabled = true;
+    }
+    disableJob(id) {
+        const job = this.jobs.get(id);
+        if (job)
+            job.enabled = false;
+    }
+    getJobs() {
+        return Array.from(this.jobs.values());
+    }
+    getJob(id) {
+        return this.jobs.get(id);
+    }
+    /** Run a specific job immediately */
+    async runJob(id) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return false;
+        job.lastRun = new Date();
+        await this.handler(job);
+        const parsed = this.parsed.get(id);
+        if (parsed)
+            job.nextRun = computeNextRun(parsed, new Date());
+        return true;
+    }
+    start() {
+        if (this.timer)
+            return;
+        // Check every 60 seconds
+        this.timer = setInterval(() => this.tick(), 60_000);
+        // Also tick immediately
+        this.tick();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    tick() {
+        const now = new Date();
+        for (const [id, job] of this.jobs) {
+            if (!job.enabled)
+                continue;
+            const parsed = this.parsed.get(id);
+            if (!parsed)
+                continue;
+            if (cronMatches(parsed, now)) {
+                // Avoid double-fire: check lastRun isn't same minute
+                if (job.lastRun) {
+                    const last = job.lastRun;
+                    if (last.getFullYear() === now.getFullYear() &&
+                        last.getMonth() === now.getMonth() &&
+                        last.getDate() === now.getDate() &&
+                        last.getHours() === now.getHours() &&
+                        last.getMinutes() === now.getMinutes()) {
+                        continue;
+                    }
+                }
+                job.lastRun = new Date(now);
+                job.nextRun = computeNextRun(parsed, now);
+                // Fire and forget (log errors)
+                Promise.resolve(this.handler(job)).catch((err) => {
+                    console.error(`[scheduler] Job "${job.name}" failed:`, err);
+                });
+            }
+        }
+    }
+}
+exports.Scheduler = Scheduler;
+//# sourceMappingURL=scheduler.js.map

package/dist/core/subagent.d.ts

@@ -0,0 +1,28 @@
+export interface SubAgentConfig {
+    name: string;
+    task: string;
+    systemPrompt?: string;
+    provider?: string;
+    model?: string;
+    timeout?: number;
+    isolated?: boolean;
+}
+export interface SubAgentResult {
+    id: string;
+    name: string;
+    status: 'completed' | 'failed' | 'timeout';
+    result: string;
+    duration: number;
+}
+export declare class SubAgentManager {
+    private agents;
+    spawn(config: SubAgentConfig, parentProvider?: any): Promise<SubAgentResult>;
+    spawnParallel(configs: SubAgentConfig[], parentProvider?: any): Promise<SubAgentResult[]>;
+    list(): Array<{
+        id: string;
+        name: string;
+        status: string;
+    }>;
+    kill(id: string): boolean;
+}
+//# sourceMappingURL=subagent.d.ts.map