opc-agent 2.0.0 → 2.0.1

package/src/core/a2a.ts

@@ -3,6 +3,66 @@ import { Room } from './room';
 import type { Message, IAgent } from './types';
 import { Logger } from './logger';
 
+// ── Agent Card (v1.6.0 — simplified A2A) ────────────────────
+
+export interface AgentCard {
+  name: string;
+  description: string;
+  capabilities: string[];
+  endpoint?: string;
+  handler?: (message: string) => Promise<string>;
+}
+
+export class AgentCardRegistry {
+  private cards: Map<string, AgentCard> = new Map();
+  private logger = new Logger('a2a:cards');
+
+  register(card: AgentCard): void {
+    this.cards.set(card.name, card);
+    this.logger.info('AgentCard registered', { name: card.name });
+  }
+
+  unregister(name: string): void {
+    this.cards.delete(name);
+  }
+
+  get(name: string): AgentCard | undefined {
+    return this.cards.get(name);
+  }
+
+  find(query: string): AgentCard[] {
+    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: string, message: string): Promise<string> {
+    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() as any;
+      return data.response || data.content || '';
+    }
+
+    throw new Error(`Agent '${agentName}' has no handler or endpoint`);
+  }
+
+  list(): AgentCard[] {
+    return Array.from(this.cards.values());
+  }
+}
+
 // ── A2A Types ───────────────────────────────────────────────
 
 export interface AgentCapability {

package/src/core/agent.ts

@@ -6,6 +6,8 @@ import { SkillLearner } from '../skills/auto-learn';
 import type { MCPTool } from '../tools/mcp';
 import { MCPToolRegistry } from '../tools/mcp';
 import { SubAgentManager, type SubAgentConfig, type SubAgentResult } from './subagent';
+import { Tracer } from '../telemetry';
+import type { Span as TelemetrySpan } from '../telemetry';
 
 export class BaseAgent extends EventEmitter implements IAgent {
   readonly name: string;
@@ -21,6 +23,9 @@ export class BaseAgent extends EventEmitter implements IAgent {
   private skillLearner?: SkillLearner;
   private autoLearnConfig: { enabled: boolean; minConversationLength: number; improveOnUse: boolean };
   private _subAgentManager?: SubAgentManager;
+  private longTermMemory?: any;
+  private longTermMemoryConfig: { autoLearn: boolean; autoRecall: boolean } = { autoLearn: true, autoRecall: true };
+  private tracer?: Tracer;
 
   constructor(options: {
     name: string;
@@ -36,6 +41,7 @@ export class BaseAgent extends EventEmitter implements IAgent {
       improveOnUse?: boolean;
     };
     maxToolRounds?: number;
+    tracer?: Tracer;
   }) {
     super();
     this.name = options.name;
@@ -52,6 +58,25 @@ export class BaseAgent extends EventEmitter implements IAgent {
     if (options.skillsDir) {
       this.skillLearner = new SkillLearner(options.skillsDir);
     }
+    this.tracer = options.tracer;
+  }
+
+  setLongTermMemory(brain: any, config?: { autoLearn?: boolean; autoRecall?: boolean }): void {
+    this.longTermMemory = brain;
+    if (config) {
+      this.longTermMemoryConfig = {
+        autoLearn: config.autoLearn !== false,
+        autoRecall: config.autoRecall !== false,
+      };
+    }
+  }
+
+  getLongTermMemory(): any {
+    return this.longTermMemory;
+  }
+
+  getLongTermMemoryConfig(): { autoLearn: boolean; autoRecall: boolean } {
+    return this.longTermMemoryConfig;
   }
 
   get state(): AgentState {
@@ -78,6 +103,14 @@ export class BaseAgent extends EventEmitter implements IAgent {
     return this.toolRegistry;
   }
 
+  getTracer(): Tracer | undefined {
+    return this.tracer;
+  }
+
+  setTracer(tracer: Tracer): void {
+    this.tracer = tracer;
+  }
+
   registerTool(tool: MCPTool): void {
     this.toolRegistry.register(tool);
   }
@@ -143,9 +176,45 @@ export class BaseAgent extends EventEmitter implements IAgent {
   async handleMessage(message: Message): Promise<Message> {
     this.emit('message:in', message);
 
+    // Start root span if tracer is configured
+    let rootSpan: TelemetrySpan | undefined;
+    if (this.tracer) {
+      rootSpan = this.tracer.startSpan('handleMessage', {
+        kind: 'server',
+        attributes: {
+          'message.channel': (message.metadata?.channel as string) || 'unknown',
+          'message.sender': (message.metadata?.sender as string) || 'unknown',
+          'message.length': message.content.length,
+        },
+      });
+      this.tracer.increment('agent.messages.total', 1, { agent: this.name });
+    }
+
     const sessionId = (message.metadata?.sessionId as string) ?? 'default';
     await this.memory.addMessage(sessionId, message);
 
+    // === Recall from long-term memory ===
+    let memoryContext = '';
+    if (this.longTermMemory && this.longTermMemoryConfig.autoRecall) {
+      let memorySpan: TelemetrySpan | undefined;
+      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: any) => 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: AgentContext = {
       agentName: this.name,
       sessionId,
@@ -172,12 +241,21 @@ export class BaseAgent extends EventEmitter implements IAgent {
 
     // 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
@@ -186,12 +264,26 @@ export class BaseAgent extends EventEmitter implements IAgent {
     let finalResponse = '';
 
     for (let round = 0; round <= this.maxToolRounds; round++) {
+      let llmSpan: TelemetrySpan | undefined;
+      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;
@@ -199,9 +291,23 @@ export class BaseAgent extends EventEmitter implements IAgent {
       }
 
       // Execute tool
+      let toolSpan: TelemetrySpan | undefined;
+      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()}`,
@@ -221,6 +327,25 @@ export class BaseAgent extends EventEmitter implements IAgent {
     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 as string) || 'unknown'] },
+        );
+      } catch {
+        // Silent fail
+      }
+    }
+
     // After response, check if we should learn a skill
     if (
       this.skillLearner &&

package/src/core/runtime.ts

@@ -1,9 +1,17 @@
+import { PluginManager } from '../plugins';
+import type { Plugin } from '../plugins';
+import { loggerPlugin } from '../plugins/logger';
+import { createRateLimiterPlugin } from '../plugins/rate-limiter';
+import { createContentFilterPlugin } from '../plugins/content-filter';
 import { BaseAgent } from './agent';
 import { loadOAD } from './config';
 import { Logger } from './logger';
 import { WebChannel } from '../channels/web';
 import { TelegramChannel } from '../channels/telegram';
 import { WebSocketChannel } from '../channels/websocket';
+import { WeChatChannel } from '../channels/wechat';
+import { FeishuChannel } from '../channels/feishu';
+import { EmailChannel } from '../channels/email';
 import { DeepBrainMemoryStore } from '../memory/deepbrain';
 import { Analytics } from '../analytics';
 import type { OADDocument } from '../schema/oad';
@@ -30,6 +38,10 @@ export class AgentRuntime {
   private isShuttingDown = false;
   private analytics: Analytics = new Analytics();
   private scheduler: Scheduler | null = null;
+  private pluginManager: PluginManager = new PluginManager();
+  private brain: any = null;
+  private agentBrain: any = null;
+  private evolveScheduler: any = null;
 
   async loadConfig(filePath: string): Promise<OADDocument> {
     this.config = loadOAD(filePath);
@@ -108,11 +120,93 @@ export class AgentRuntime {
       } else if (ch.type === 'websocket') {
         this.agent.bindChannel(new WebSocketChannel(ch.port ?? 3002));
         this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
+      } else if (ch.type === 'wechat') {
+        this.agent.bindChannel(new WeChatChannel({
+          appId: (ch.config?.appId as string) ?? process.env.WECHAT_APP_ID ?? '',
+          appSecret: (ch.config?.appSecret as string) ?? process.env.WECHAT_APP_SECRET ?? '',
+          token: (ch.config?.token as string) ?? process.env.WECHAT_TOKEN ?? '',
+          encodingAESKey: ch.config?.encodingAESKey as string,
+          port: ch.port,
+        }));
+        this.logger.info('Bound wechat channel', { port: ch.port ?? 8080 });
+      } else if (ch.type === 'feishu') {
+        this.agent.bindChannel(new FeishuChannel({
+          appId: (ch.config?.appId as string) ?? process.env.FEISHU_APP_ID,
+          appSecret: (ch.config?.appSecret as string) ?? process.env.FEISHU_APP_SECRET,
+          verificationToken: (ch.config?.verificationToken as string) ?? process.env.FEISHU_VERIFICATION_TOKEN,
+          encryptKey: ch.config?.encryptKey as string,
+          port: ch.port,
+        }));
+        this.logger.info('Bound feishu channel', { port: ch.port ?? 8081 });
+      } else if (ch.type === 'email') {
+        this.agent.bindChannel(new EmailChannel({
+          mode: (ch.config?.mode as 'webhook' | 'imap') ?? 'webhook',
+          smtp: ch.config?.smtp as any,
+          imap: ch.config?.imap as any,
+          webhookPort: ch.port,
+          filters: ch.config?.filters as any,
+        }));
+        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 import(/* 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 as any).database || './data/brain.db';
+          const embeddingProvider = (dbConfig as any).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 as any).autoLearn !== false,
+            autoRecall: (dbConfig as any).autoRecall !== false,
+          });
+
+          this.logger.info('DeepBrain Brain/AgentBrain connected', { database: dbPath });
+
+          // Brain seed loading
+          const { existsSync, readFileSync, renameSync } = await import('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 as any).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: any) {
+        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
@@ -126,6 +220,24 @@ export class AgentRuntime {
 
     this.logger.info('Agent initialized', { name: cfg.metadata.name });
 
+    // Load enhanced plugins from OAD config
+    const pluginsCfg = (cfg.spec as any).plugins;
+    if (pluginsCfg && Array.isArray(pluginsCfg)) {
+      const builtinPlugins: Record<string, (config?: any) => Plugin> = {
+        'logger': () => loggerPlugin,
+        'rate-limiter': (c: any) => createRateLimiterPlugin(c?.maxPerMinute ?? 60),
+        'content-filter': (c: any) => 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 as any).scheduler;
     if (schedulerCfg?.jobs && Array.isArray(schedulerCfg.jobs) && schedulerCfg.jobs.length > 0) {
@@ -178,10 +290,21 @@ export class AgentRuntime {
   async stop(): Promise<void> {
     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();
@@ -227,4 +350,8 @@ export class AgentRuntime {
   getConfig(): OADDocument | null {
     return this.config;
   }
+
+  getPluginManager(): PluginManager {
+    return this.pluginManager;
+  }
 }

package/src/core/sandbox.ts

@@ -1,11 +1,30 @@
 import type { TrustLevelType } from '../schema/oad';
 import * as path from 'path';
+import * as fs from 'fs';
 
 export interface SandboxConfig {
   trustLevel: TrustLevelType;
   agentDir: string;
   networkAllowlist?: string[];
   shellAllowed?: boolean;
+  allowedCommands?: string[];
+  blockedCommands?: string[];
+  maxFileSize?: number;       // bytes, default 10MB
+  maxFiles?: number;          // max files in workspace, default 1000
+  networkAccess?: boolean;    // allow network, default true
+  readOnlyPaths?: string[];   // paths that can't be written
+  timeout?: number;           // global timeout ms
+}
+
+export interface ValidationResult {
+  allowed: boolean;
+  reason?: string;
+}
+
+export interface SandboxStatus {
+  files: number;
+  totalSize: number;
+  violations: number;
 }
 
 export interface SandboxRestrictions {
@@ -40,6 +59,9 @@ const TRUST_RESTRICTIONS: Record<string, SandboxRestrictions> = {
 export class Sandbox {
   private config: SandboxConfig;
   private restrictions: SandboxRestrictions;
+  private violations: number = 0;
+  private maxFileSize: number;
+  private maxFiles: number;
 
   constructor(config: SandboxConfig) {
     this.config = config;
@@ -52,6 +74,11 @@ export class Sandbox {
     if (config.shellAllowed !== undefined) {
       this.restrictions.shell = config.shellAllowed;
     }
+    if (config.networkAccess === false) {
+      this.restrictions.network.allowed = [];
+    }
+    this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024; // 10MB
+    this.maxFiles = config.maxFiles ?? 1000;
   }
 
   get trustLevel(): TrustLevelType {
@@ -98,4 +125,120 @@ export class Sandbox {
   checkShellAccess(): boolean {
     return this.restrictions.shell;
   }
+
+  validateFileOp(action: 'read' | 'write' | 'delete', filePath: string): ValidationResult {
+    const resolved = path.resolve(filePath);
+
+    if (action === 'write' || action === 'delete') {
+      // Check read-only paths
+      if (this.config.readOnlyPaths) {
+        for (const ro of this.config.readOnlyPaths) {
+          const roResolved = path.resolve(ro);
+          if (resolved.startsWith(roResolved) || resolved === roResolved) {
+            this.violations++;
+            return { allowed: false, reason: `Path is read-only: ${ro}` };
+          }
+        }
+      }
+
+      // Check file size for writes
+      if (action === 'write') {
+        try {
+          if (fs.existsSync(resolved)) {
+            const stat = fs.statSync(resolved);
+            if (stat.size > this.maxFileSize) {
+              this.violations++;
+              return { allowed: false, reason: `File exceeds max size: ${this.maxFileSize} bytes` };
+            }
+          }
+        } catch {
+          // File doesn't exist yet — that's fine
+        }
+      }
+    }
+
+    const mode = action === 'read' ? 'read' : 'write';
+    if (!this.checkFileAccess(filePath, mode)) {
+      this.violations++;
+      return { allowed: false, reason: `File access denied for ${action}: ${filePath}` };
+    }
+
+    return { allowed: true };
+  }
+
+  validateCommand(command: string): ValidationResult {
+    if (!this.restrictions.shell) {
+      this.violations++;
+      return { allowed: false, reason: 'Shell access is disabled' };
+    }
+
+    // Check blocklist
+    if (this.config.blockedCommands) {
+      for (const blocked of this.config.blockedCommands) {
+        if (command.includes(blocked)) {
+          this.violations++;
+          return { allowed: false, reason: `Command is blocked: ${blocked}` };
+        }
+      }
+    }
+
+    // Check allowlist (if set, only allowed commands pass)
+    if (this.config.allowedCommands && this.config.allowedCommands.length > 0) {
+      const allowed = this.config.allowedCommands.some(a => command.startsWith(a) || command.includes(a));
+      if (!allowed) {
+        this.violations++;
+        return { allowed: false, reason: 'Command not in allowlist' };
+      }
+    }
+
+    return { allowed: true };
+  }
+
+  validateNetwork(url: string): ValidationResult {
+    if (this.config.networkAccess === false) {
+      this.violations++;
+      return { allowed: false, reason: 'Network access is disabled' };
+    }
+    if (!this.checkNetworkAccess(url)) {
+      this.violations++;
+      return { allowed: false, reason: `Network access denied for: ${url}` };
+    }
+    return { allowed: true };
+  }
+
+  getStatus(): SandboxStatus {
+    let files = 0;
+    let totalSize = 0;
+    try {
+      const agentDir = path.resolve(this.config.agentDir);
+      if (fs.existsSync(agentDir)) {
+        const countFiles = (dir: string) => {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+          for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory() && entry.name !== 'node_modules') {
+              countFiles(full);
+            } else if (entry.isFile()) {
+              files++;
+              try { totalSize += fs.statSync(full).size; } catch {}
+            }
+          }
+        };
+        countFiles(agentDir);
+      }
+    } catch {}
+    return { files, totalSize, violations: this.violations };
+  }
+
+  getViolations(): number {
+    return this.violations;
+  }
+
+  getMaxFileSize(): number {
+    return this.maxFileSize;
+  }
+
+  getMaxFiles(): number {
+    return this.maxFiles;
+  }
 }