opc-agent 2.0.0 → 2.0.1

package/dist/core/a2a.d.ts

@@ -1,6 +1,23 @@
 import { EventEmitter } from 'events';
 import { Room } from './room';
 import type { IAgent } from './types';
+export interface AgentCard {
+    name: string;
+    description: string;
+    capabilities: string[];
+    endpoint?: string;
+    handler?: (message: string) => Promise<string>;
+}
+export declare class AgentCardRegistry {
+    private cards;
+    private logger;
+    register(card: AgentCard): void;
+    unregister(name: string): void;
+    get(name: string): AgentCard | undefined;
+    find(query: string): AgentCard[];
+    send(agentName: string, message: string): Promise<string>;
+    list(): AgentCard[];
+}
 export interface AgentCapability {
     name: string;
     description: string;

package/dist/core/a2a.js

@@ -1,9 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AgentRegistry = void 0;
+exports.AgentRegistry = exports.AgentCardRegistry = void 0;
 const events_1 = require("events");
 const room_1 = require("./room");
 const logger_1 = require("./logger");
+class AgentCardRegistry {
+    cards = new Map();
+    logger = new logger_1.Logger('a2a:cards');
+    register(card) {
+        this.cards.set(card.name, card);
+        this.logger.info('AgentCard registered', { name: card.name });
+    }
+    unregister(name) {
+        this.cards.delete(name);
+    }
+    get(name) {
+        return this.cards.get(name);
+    }
+    find(query) {
+        const lower = query.toLowerCase();
+        return Array.from(this.cards.values()).filter(a => a.name.toLowerCase().includes(lower) ||
+            a.description.toLowerCase().includes(lower) ||
+            a.capabilities.some(c => c.toLowerCase().includes(lower)));
+    }
+    async send(agentName, message) {
+        const agent = this.cards.get(agentName);
+        if (!agent)
+            throw new Error(`Agent '${agentName}' not found`);
+        if (agent.handler) {
+            return agent.handler(message);
+        }
+        else if (agent.endpoint) {
+            const res = await fetch(agent.endpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message }),
+            });
+            const data = await res.json();
+            return data.response || data.content || '';
+        }
+        throw new Error(`Agent '${agentName}' has no handler or endpoint`);
+    }
+    list() {
+        return Array.from(this.cards.values());
+    }
+}
+exports.AgentCardRegistry = AgentCardRegistry;
 // ── Agent Registry ──────────────────────────────────────────
 class AgentRegistry extends events_1.EventEmitter {
     registrations = new Map();

package/dist/core/agent.d.ts

@@ -5,6 +5,7 @@ import { SkillLearner } from '../skills/auto-learn';
 import type { MCPTool } from '../tools/mcp';
 import { MCPToolRegistry } from '../tools/mcp';
 import { type SubAgentConfig, type SubAgentResult } from './subagent';
+import { Tracer } from '../telemetry';
 export declare class BaseAgent extends EventEmitter implements IAgent {
     readonly name: string;
     private _state;
@@ -19,6 +20,9 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
     private skillLearner?;
     private autoLearnConfig;
     private _subAgentManager?;
+    private longTermMemory?;
+    private longTermMemoryConfig;
+    private tracer?;
     constructor(options: {
         name: string;
         systemPrompt?: string;
@@ -33,13 +37,25 @@ export declare class BaseAgent extends EventEmitter implements IAgent {
             improveOnUse?: boolean;
         };
         maxToolRounds?: number;
+        tracer?: Tracer;
     });
+    setLongTermMemory(brain: any, config?: {
+        autoLearn?: boolean;
+        autoRecall?: boolean;
+    }): void;
+    getLongTermMemory(): any;
+    getLongTermMemoryConfig(): {
+        autoLearn: boolean;
+        autoRecall: boolean;
+    };
     get state(): AgentState;
     get provider(): LLMProvider;
     getSystemPrompt(): string;
     getMemory(): MemoryStore;
     getSkillLearner(): SkillLearner | undefined;
     getToolRegistry(): MCPToolRegistry;
+    getTracer(): Tracer | undefined;
+    setTracer(tracer: Tracer): void;
     registerTool(tool: MCPTool): void;
     private transition;
     init(): Promise<void>;

package/dist/core/agent.js

@@ -21,6 +21,9 @@ class BaseAgent extends events_1.EventEmitter {
     skillLearner;
     autoLearnConfig;
     _subAgentManager;
+    longTermMemory;
+    longTermMemoryConfig = { autoLearn: true, autoRecall: true };
+    tracer;
     constructor(options) {
         super();
         this.name = options.name;
@@ -37,6 +40,22 @@ class BaseAgent extends events_1.EventEmitter {
         if (options.skillsDir) {
             this.skillLearner = new auto_learn_1.SkillLearner(options.skillsDir);
         }
+        this.tracer = options.tracer;
+    }
+    setLongTermMemory(brain, config) {
+        this.longTermMemory = brain;
+        if (config) {
+            this.longTermMemoryConfig = {
+                autoLearn: config.autoLearn !== false,
+                autoRecall: config.autoRecall !== false,
+            };
+        }
+    }
+    getLongTermMemory() {
+        return this.longTermMemory;
+    }
+    getLongTermMemoryConfig() {
+        return this.longTermMemoryConfig;
     }
     get state() {
         return this._state;
@@ -56,6 +75,12 @@ class BaseAgent extends events_1.EventEmitter {
     getToolRegistry() {
         return this.toolRegistry;
     }
+    getTracer() {
+        return this.tracer;
+    }
+    setTracer(tracer) {
+        this.tracer = tracer;
+    }
     registerTool(tool) {
         this.toolRegistry.register(tool);
     }
@@ -109,8 +134,45 @@ class BaseAgent extends events_1.EventEmitter {
     }
     async handleMessage(message) {
         this.emit('message:in', message);
+        // Start root span if tracer is configured
+        let rootSpan;
+        if (this.tracer) {
+            rootSpan = this.tracer.startSpan('handleMessage', {
+                kind: 'server',
+                attributes: {
+                    'message.channel': message.metadata?.channel || 'unknown',
+                    'message.sender': message.metadata?.sender || 'unknown',
+                    'message.length': message.content.length,
+                },
+            });
+            this.tracer.increment('agent.messages.total', 1, { agent: this.name });
+        }
         const sessionId = message.metadata?.sessionId ?? 'default';
         await this.memory.addMessage(sessionId, message);
+        // === Recall from long-term memory ===
+        let memoryContext = '';
+        if (this.longTermMemory && this.longTermMemoryConfig.autoRecall) {
+            let memorySpan;
+            if (this.tracer && rootSpan) {
+                memorySpan = this.tracer.startSpan('memory.recall', { parent: rootSpan, kind: 'client' });
+            }
+            try {
+                const recalled = await this.longTermMemory.recall(message.content);
+                if (recalled && (Array.isArray(recalled) ? recalled.length > 0 : true)) {
+                    memoryContext = '\n\n[Relevant memories]\n' +
+                        (Array.isArray(recalled)
+                            ? recalled.map((r) => typeof r === 'string' ? r : r.content || r.compiled_truth || '').join('\n')
+                            : String(recalled));
+                }
+                if (this.tracer && memorySpan)
+                    this.tracer.endSpan(memorySpan, 'ok');
+            }
+            catch {
+                if (this.tracer && memorySpan)
+                    this.tracer.endSpan(memorySpan, 'error');
+                // Silent fail — don't break chat if memory fails
+            }
+        }
         const context = {
             agentName: this.name,
             sessionId,
@@ -136,27 +198,58 @@ class BaseAgent extends events_1.EventEmitter {
         }
         // Check if a learned skill matches — prepend instructions to system prompt
         let effectiveSystemPrompt = this.systemPrompt;
+        // Inject long-term memory context
+        if (memoryContext) {
+            effectiveSystemPrompt = effectiveSystemPrompt + memoryContext;
+        }
         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);
+            if (this.tracer && rootSpan) {
+                this.tracer.addEvent(rootSpan, 'skill.matched', { 'skill.name': matchedSkill.name });
+            }
         }
         // 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++) {
+            let llmSpan;
+            if (this.tracer && rootSpan) {
+                llmSpan = this.tracer.startSpan('llm.chat', {
+                    parent: rootSpan,
+                    kind: 'client',
+                    attributes: { 'llm.round': round },
+                });
+            }
             const llmResponse = await this._provider.chat(llmMessages, effectiveSystemPrompt, { tools: tools.length > 0 ? tools : undefined });
+            if (this.tracer && llmSpan) {
+                llmSpan.attributes['llm.response.length'] = llmResponse.length;
+                this.tracer.endSpan(llmSpan, 'ok');
+            }
             const toolCall = this.parseToolCall(llmResponse);
             if (!toolCall || tools.length === 0 || round === this.maxToolRounds) {
                 finalResponse = llmResponse;
                 break;
             }
             // Execute tool
+            let toolSpan;
+            if (this.tracer && rootSpan) {
+                toolSpan = this.tracer.startSpan('tool.execute', {
+                    parent: rootSpan,
+                    kind: 'internal',
+                    attributes: { 'tool.name': toolCall.name },
+                });
+            }
             const toolResult = await this.toolRegistry.execute(toolCall.name, toolCall.arguments, context);
             this.emit('tool:execute', toolCall.name, toolResult);
+            if (this.tracer && toolSpan) {
+                toolSpan.attributes['tool.result.length'] = toolResult.content?.length || 0;
+                this.tracer.endSpan(toolSpan, 'ok');
+            }
             // Add tool call and result to messages for next round
             llmMessages.push({
                 id: `tool_call_${Date.now()}`,
@@ -174,6 +267,21 @@ class BaseAgent extends events_1.EventEmitter {
         const response = this.createResponse(finalResponse, message);
         await this.memory.addMessage(sessionId, response);
         this.emit('message:out', response);
+        // End root telemetry span
+        if (this.tracer && rootSpan) {
+            rootSpan.attributes['response.length'] = finalResponse.length;
+            this.tracer.endSpan(rootSpan, 'ok');
+            this.tracer.histogram('agent.message.duration', rootSpan.endTime - rootSpan.startTime, { agent: this.name });
+        }
+        // === Learn from interaction ===
+        if (this.longTermMemory && this.longTermMemoryConfig.autoLearn) {
+            try {
+                await this.longTermMemory.learn(`User: ${message.content}\nAssistant: ${finalResponse}`, { tags: ['conversation', message.metadata?.channel || 'unknown'] });
+            }
+            catch {
+                // Silent fail
+            }
+        }
         // After response, check if we should learn a skill
         if (this.skillLearner &&
             this.autoLearnConfig.enabled &&

package/dist/core/runtime.d.ts

@@ -1,3 +1,4 @@
+import { PluginManager } from '../plugins';
 import { BaseAgent } from './agent';
 import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
@@ -12,6 +13,10 @@ export declare class AgentRuntime {
     private isShuttingDown;
     private analytics;
     private scheduler;
+    private pluginManager;
+    private brain;
+    private agentBrain;
+    private evolveScheduler;
     loadConfig(filePath: string): Promise<OADDocument>;
     setHistoryLimit(limit: number): void;
     initialize(config?: OADDocument): Promise<BaseAgent>;
@@ -23,5 +28,6 @@ export declare class AgentRuntime {
     getAgent(): BaseAgent | null;
     getAnalytics(): Analytics;
     getConfig(): OADDocument | null;
+    getPluginManager(): PluginManager;
 }
 //# sourceMappingURL=runtime.d.ts.map

package/dist/core/runtime.js

@@ -1,13 +1,53 @@
 "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.AgentRuntime = void 0;
 exports.truncateOutput = truncateOutput;
+const plugins_1 = require("../plugins");
+const logger_1 = require("../plugins/logger");
+const rate_limiter_1 = require("../plugins/rate-limiter");
+const content_filter_1 = require("../plugins/content-filter");
 const agent_1 = require("./agent");
 const config_1 = require("./config");
-const logger_1 = require("./logger");
+const logger_2 = require("./logger");
 const web_1 = require("../channels/web");
 const telegram_1 = require("../channels/telegram");
 const websocket_1 = require("../channels/websocket");
+const wechat_1 = require("../channels/wechat");
+const feishu_1 = require("../channels/feishu");
+const email_1 = require("../channels/email");
 const deepbrain_1 = require("../memory/deepbrain");
 const analytics_1 = require("../analytics");
 const scheduler_1 = require("./scheduler");
@@ -22,12 +62,16 @@ function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT) {
 class AgentRuntime {
     agent = null;
     config = null;
-    logger = new logger_1.Logger('runtime');
+    logger = new logger_2.Logger('runtime');
     historyLimit = DEFAULT_HISTORY_LIMIT;
     shutdownHandlers = [];
     isShuttingDown = false;
     analytics = new analytics_1.Analytics();
     scheduler = null;
+    pluginManager = new plugins_1.PluginManager();
+    brain = null;
+    agentBrain = null;
+    evolveScheduler = null;
     async loadConfig(filePath) {
         this.config = (0, config_1.loadOAD)(filePath);
         this.logger.info('Config loaded', { name: this.config.metadata.name });
@@ -105,8 +149,88 @@ class AgentRuntime {
                 this.agent.bindChannel(new websocket_1.WebSocketChannel(ch.port ?? 3002));
                 this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
             }
+            else if (ch.type === 'wechat') {
+                this.agent.bindChannel(new wechat_1.WeChatChannel({
+                    appId: ch.config?.appId ?? process.env.WECHAT_APP_ID ?? '',
+                    appSecret: ch.config?.appSecret ?? process.env.WECHAT_APP_SECRET ?? '',
+                    token: ch.config?.token ?? process.env.WECHAT_TOKEN ?? '',
+                    encodingAESKey: ch.config?.encodingAESKey,
+                    port: ch.port,
+                }));
+                this.logger.info('Bound wechat channel', { port: ch.port ?? 8080 });
+            }
+            else if (ch.type === 'feishu') {
+                this.agent.bindChannel(new feishu_1.FeishuChannel({
+                    appId: ch.config?.appId ?? process.env.FEISHU_APP_ID,
+                    appSecret: ch.config?.appSecret ?? process.env.FEISHU_APP_SECRET,
+                    verificationToken: ch.config?.verificationToken ?? process.env.FEISHU_VERIFICATION_TOKEN,
+                    encryptKey: ch.config?.encryptKey,
+                    port: ch.port,
+                }));
+                this.logger.info('Bound feishu channel', { port: ch.port ?? 8081 });
+            }
+            else if (ch.type === 'email') {
+                this.agent.bindChannel(new email_1.EmailChannel({
+                    mode: ch.config?.mode ?? 'webhook',
+                    smtp: ch.config?.smtp,
+                    imap: ch.config?.imap,
+                    webhookPort: ch.port,
+                    filters: ch.config?.filters,
+                }));
+                this.logger.info('Bound email channel', { mode: ch.config?.mode ?? 'webhook', port: ch.port ?? 8082 });
+            }
         }
         await this.agent.init();
+        // === Auto-wire DeepBrain long-term memory (Brain/AgentBrain) ===
+        const longTermCfg = memCfg && typeof memCfg.longTerm === 'object' ? memCfg.longTerm : null;
+        if (longTermCfg?.provider === 'deepbrain') {
+            try {
+                const deepbrainModule = await Promise.resolve().then(() => __importStar(require(/* webpackIgnore: true */ 'deepbrain')));
+                const BrainClass = deepbrainModule.Brain ?? deepbrainModule.default?.Brain;
+                const AgentBrainClass = deepbrainModule.AgentBrain ?? deepbrainModule.default?.AgentBrain;
+                if (BrainClass && AgentBrainClass) {
+                    const dbConfig = longTermCfg.config ?? {};
+                    const dbPath = dbConfig.database || './data/brain.db';
+                    const embeddingProvider = dbConfig.embeddingProvider || 'ollama';
+                    this.brain = new BrainClass({
+                        database: dbPath,
+                        embedding_provider: embeddingProvider,
+                    });
+                    await this.brain.connect();
+                    this.agentBrain = new AgentBrainClass(this.brain, cfg.metadata.name);
+                    this.agent.setLongTermMemory(this.agentBrain, {
+                        autoLearn: dbConfig.autoLearn !== false,
+                        autoRecall: dbConfig.autoRecall !== false,
+                    });
+                    this.logger.info('DeepBrain Brain/AgentBrain connected', { database: dbPath });
+                    // Brain seed loading
+                    const { existsSync, readFileSync, renameSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                    const seedPath = './data/brain-seed.md';
+                    if (existsSync(seedPath)) {
+                        const seed = readFileSync(seedPath, 'utf-8');
+                        await this.brain.put('brain-seed', seed, { type: 'seed', tags: ['seed', 'initial'] });
+                        renameSync(seedPath, './data/brain-seed.loaded.md');
+                        this.logger.info('Brain seed loaded');
+                    }
+                    // Auto-evolve scheduling
+                    const evolveInterval = dbConfig.evolveInterval;
+                    if (evolveInterval && evolveInterval > 0) {
+                        const AutoEvolveSchedulerClass = deepbrainModule.AutoEvolveScheduler ?? deepbrainModule.default?.AutoEvolveScheduler;
+                        if (AutoEvolveSchedulerClass) {
+                            this.evolveScheduler = new AutoEvolveSchedulerClass();
+                            this.evolveScheduler.start(this.agentBrain, evolveInterval);
+                            this.logger.info('DeepBrain auto-evolve scheduled', { interval: evolveInterval });
+                        }
+                    }
+                }
+                else {
+                    this.logger.warn('DeepBrain module found but Brain/AgentBrain classes not available');
+                }
+            }
+            catch (e) {
+                this.logger.warn('DeepBrain not available (install with: npm install deepbrain)', { error: e.message });
+            }
+        }
         // Wire analytics to agent events
         this.agent.on('message:out', () => {
             // responseTime is approximated; real timing is done via skill/llm events
@@ -118,6 +242,23 @@ class AgentRuntime {
             this.analytics.recordError();
         });
         this.logger.info('Agent initialized', { name: cfg.metadata.name });
+        // Load enhanced plugins from OAD config
+        const pluginsCfg = cfg.spec.plugins;
+        if (pluginsCfg && Array.isArray(pluginsCfg)) {
+            const builtinPlugins = {
+                'logger': () => logger_1.loggerPlugin,
+                'rate-limiter': (c) => (0, rate_limiter_1.createRateLimiterPlugin)(c?.maxPerMinute ?? 60),
+                'content-filter': (c) => (0, content_filter_1.createContentFilterPlugin)(c?.blocklist ?? []),
+            };
+            for (const entry of pluginsCfg) {
+                const factory = builtinPlugins[entry.name];
+                if (factory) {
+                    this.pluginManager.registerEnhanced(factory(entry.config));
+                    this.logger.info('Enhanced plugin loaded from config', { name: entry.name });
+                }
+            }
+        }
+        await this.pluginManager.initAll(this);
         // Initialize scheduler if jobs are configured
         const schedulerCfg = cfg.spec.scheduler;
         if (schedulerCfg?.jobs && Array.isArray(schedulerCfg.jobs) && schedulerCfg.jobs.length > 0) {
@@ -169,10 +310,25 @@ class AgentRuntime {
         if (!this.agent)
             return;
         this.logger.info('Stopping agent...');
+        if (this.evolveScheduler) {
+            try {
+                this.evolveScheduler.stop();
+            }
+            catch { /* ignore */ }
+            this.logger.info('DeepBrain auto-evolve stopped');
+        }
+        if (this.brain) {
+            try {
+                await this.brain.disconnect();
+                this.logger.info('DeepBrain disconnected');
+            }
+            catch { /* ignore */ }
+        }
         if (this.scheduler) {
             this.scheduler.stop();
             this.logger.info('Scheduler stopped');
         }
+        await this.pluginManager.shutdownAll();
         await this.agent.stop();
         for (const handler of this.shutdownHandlers) {
             await handler();
@@ -213,6 +369,9 @@ class AgentRuntime {
     getConfig() {
         return this.config;
     }
+    getPluginManager() {
+        return this.pluginManager;
+    }
 }
 exports.AgentRuntime = AgentRuntime;
 //# sourceMappingURL=runtime.js.map

package/dist/core/sandbox.d.ts

@@ -4,6 +4,22 @@ export interface SandboxConfig {
     agentDir: string;
     networkAllowlist?: string[];
     shellAllowed?: boolean;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    maxFileSize?: number;
+    maxFiles?: number;
+    networkAccess?: boolean;
+    readOnlyPaths?: string[];
+    timeout?: number;
+}
+export interface ValidationResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface SandboxStatus {
+    files: number;
+    totalSize: number;
+    violations: number;
 }
 export interface SandboxRestrictions {
     fileSystem: {
@@ -18,11 +34,21 @@ export interface SandboxRestrictions {
 export declare class Sandbox {
     private config;
     private restrictions;
+    private violations;
+    private maxFileSize;
+    private maxFiles;
     constructor(config: SandboxConfig);
     get trustLevel(): TrustLevelType;
     getRestrictions(): SandboxRestrictions;
     checkFileAccess(filePath: string, mode: 'read' | 'write'): boolean;
     checkNetworkAccess(url: string): boolean;
     checkShellAccess(): boolean;
+    validateFileOp(action: 'read' | 'write' | 'delete', filePath: string): ValidationResult;
+    validateCommand(command: string): ValidationResult;
+    validateNetwork(url: string): ValidationResult;
+    getStatus(): SandboxStatus;
+    getViolations(): number;
+    getMaxFileSize(): number;
+    getMaxFiles(): number;
 }
 //# sourceMappingURL=sandbox.d.ts.map