opc-agent 1.4.0 → 2.0.0

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

@@ -11,6 +11,7 @@ export declare class AgentRuntime {
     private shutdownHandlers;
     private isShuttingDown;
     private analytics;
+    private scheduler;
     loadConfig(filePath: string): Promise<OADDocument>;
     setHistoryLimit(limit: number): void;
     initialize(config?: OADDocument): Promise<BaseAgent>;

package/dist/core/runtime.js

@@ -10,6 +10,7 @@ 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) {
@@ -26,6 +27,7 @@ class AgentRuntime {
     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 });
@@ -116,6 +118,40 @@ class AgentRuntime {
             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() {
@@ -123,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();

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

package/dist/core/subagent.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubAgentManager = void 0;
+const agent_1 = require("./agent");
+const memory_1 = require("../memory");
+class SubAgentManager {
+    agents = new Map();
+    async spawn(config, parentProvider) {
+        const id = `sub_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+        const timeout = config.timeout ?? 300000;
+        const isolated = config.isolated !== false;
+        const agent = new agent_1.BaseAgent({
+            name: config.name,
+            systemPrompt: config.systemPrompt ?? 'You are a helpful sub-agent.',
+            provider: config.provider ?? 'openai',
+            model: config.model,
+            memory: isolated ? new memory_1.InMemoryStore() : undefined,
+        });
+        this.agents.set(id, { agent, status: 'running', name: config.name });
+        const message = {
+            id: `msg_${Date.now()}`,
+            role: 'user',
+            content: config.task,
+            timestamp: Date.now(),
+            metadata: { subAgentId: id },
+        };
+        const start = Date.now();
+        try {
+            const result = await Promise.race([
+                agent.handleMessage(message),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('SubAgent timeout')), timeout)),
+            ]);
+            const duration = Date.now() - start;
+            this.agents.set(id, { agent, status: 'completed', name: config.name });
+            return { id, name: config.name, status: 'completed', result: result.content, duration };
+        }
+        catch (err) {
+            const duration = Date.now() - start;
+            const isTimeout = err.message.includes('timeout');
+            const status = isTimeout ? 'timeout' : 'failed';
+            this.agents.set(id, { agent, status, name: config.name });
+            return { id, name: config.name, status, result: err.message, duration };
+        }
+    }
+    async spawnParallel(configs, parentProvider) {
+        return Promise.all(configs.map((c) => this.spawn(c, parentProvider)));
+    }
+    list() {
+        return Array.from(this.agents.entries()).map(([id, entry]) => ({
+            id,
+            name: entry.name,
+            status: entry.status,
+        }));
+    }
+    kill(id) {
+        const entry = this.agents.get(id);
+        if (!entry)
+            return false;
+        entry.status = 'killed';
+        this.agents.set(id, entry);
+        return true;
+    }
+}
+exports.SubAgentManager = SubAgentManager;
+//# sourceMappingURL=subagent.js.map

package/dist/daemon.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=daemon.d.ts.map