opc-agent 1.2.1 → 1.3.1

package/src/core/room.ts

@@ -1,109 +1,109 @@
-import { EventEmitter } from 'events';
-import type { Message, IAgent } from './types';
-
-export interface RoomMessage {
-  from: string;
-  to?: string; // undefined = broadcast
-  topic?: string;
-  message: Message;
-}
-
-export class Room extends EventEmitter {
-  readonly name: string;
-  private agents: Map<string, IAgent> = new Map();
-  private subscriptions: Map<string, Set<string>> = new Map(); // topic -> agentNames
-
-  constructor(name: string) {
-    super();
-    this.name = name;
-  }
-
-  addAgent(agent: IAgent): void {
-    this.agents.set(agent.name, agent);
-    this.emit('agent:join', agent.name);
-  }
-
-  removeAgent(name: string): void {
-    this.agents.delete(name);
-    // Remove from all subscriptions
-    for (const [, subscribers] of this.subscriptions) {
-      subscribers.delete(name);
-    }
-    this.emit('agent:leave', name);
-  }
-
-  getAgents(): string[] {
-    return Array.from(this.agents.keys());
-  }
-
-  subscribe(agentName: string, topic: string): void {
-    if (!this.subscriptions.has(topic)) {
-      this.subscriptions.set(topic, new Set());
-    }
-    this.subscriptions.get(topic)!.add(agentName);
-  }
-
-  unsubscribe(agentName: string, topic: string): void {
-    this.subscriptions.get(topic)?.delete(agentName);
-  }
-
-  getSubscribers(topic: string): string[] {
-    return Array.from(this.subscriptions.get(topic) ?? []);
-  }
-
-  async send(roomMessage: RoomMessage): Promise<Message[]> {
-    const responses: Message[] = [];
-    this.emit('message', roomMessage);
-
-    if (roomMessage.to) {
-      // Direct message
-      const agent = this.agents.get(roomMessage.to);
-      if (agent) {
-        const response = await agent.handleMessage(roomMessage.message);
-        responses.push(response);
-      }
-    } else if (roomMessage.topic) {
-      // Topic-based pub/sub
-      const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
-      for (const name of subscribers) {
-        if (name === roomMessage.from) continue;
-        const agent = this.agents.get(name);
-        if (agent) {
-          const response = await agent.handleMessage(roomMessage.message);
-          responses.push(response);
-        }
-      }
-    } else {
-      // Broadcast to all except sender
-      for (const [name, agent] of this.agents) {
-        if (name === roomMessage.from) continue;
-        const response = await agent.handleMessage(roomMessage.message);
-        responses.push(response);
-      }
-    }
-
-    return responses;
-  }
-
-  async broadcast(from: string, content: string): Promise<Message[]> {
-    const message: Message = {
-      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'user',
-      content,
-      timestamp: Date.now(),
-      metadata: { room: this.name, from },
-    };
-    return this.send({ from, message });
-  }
-
-  async publishToTopic(from: string, topic: string, content: string): Promise<Message[]> {
-    const message: Message = {
-      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-      role: 'user',
-      content,
-      timestamp: Date.now(),
-      metadata: { room: this.name, from, topic },
-    };
-    return this.send({ from, topic, message });
-  }
-}
+import { EventEmitter } from 'events';
+import type { Message, IAgent } from './types';
+
+export interface RoomMessage {
+  from: string;
+  to?: string; // undefined = broadcast
+  topic?: string;
+  message: Message;
+}
+
+export class Room extends EventEmitter {
+  readonly name: string;
+  private agents: Map<string, IAgent> = new Map();
+  private subscriptions: Map<string, Set<string>> = new Map(); // topic -> agentNames
+
+  constructor(name: string) {
+    super();
+    this.name = name;
+  }
+
+  addAgent(agent: IAgent): void {
+    this.agents.set(agent.name, agent);
+    this.emit('agent:join', agent.name);
+  }
+
+  removeAgent(name: string): void {
+    this.agents.delete(name);
+    // Remove from all subscriptions
+    for (const [, subscribers] of this.subscriptions) {
+      subscribers.delete(name);
+    }
+    this.emit('agent:leave', name);
+  }
+
+  getAgents(): string[] {
+    return Array.from(this.agents.keys());
+  }
+
+  subscribe(agentName: string, topic: string): void {
+    if (!this.subscriptions.has(topic)) {
+      this.subscriptions.set(topic, new Set());
+    }
+    this.subscriptions.get(topic)!.add(agentName);
+  }
+
+  unsubscribe(agentName: string, topic: string): void {
+    this.subscriptions.get(topic)?.delete(agentName);
+  }
+
+  getSubscribers(topic: string): string[] {
+    return Array.from(this.subscriptions.get(topic) ?? []);
+  }
+
+  async send(roomMessage: RoomMessage): Promise<Message[]> {
+    const responses: Message[] = [];
+    this.emit('message', roomMessage);
+
+    if (roomMessage.to) {
+      // Direct message
+      const agent = this.agents.get(roomMessage.to);
+      if (agent) {
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    } else if (roomMessage.topic) {
+      // Topic-based pub/sub
+      const subscribers = this.subscriptions.get(roomMessage.topic) ?? new Set();
+      for (const name of subscribers) {
+        if (name === roomMessage.from) continue;
+        const agent = this.agents.get(name);
+        if (agent) {
+          const response = await agent.handleMessage(roomMessage.message);
+          responses.push(response);
+        }
+      }
+    } else {
+      // Broadcast to all except sender
+      for (const [name, agent] of this.agents) {
+        if (name === roomMessage.from) continue;
+        const response = await agent.handleMessage(roomMessage.message);
+        responses.push(response);
+      }
+    }
+
+    return responses;
+  }
+
+  async broadcast(from: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from },
+    };
+    return this.send({ from, message });
+  }
+
+  async publishToTopic(from: string, topic: string, content: string): Promise<Message[]> {
+    const message: Message = {
+      id: `room_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      role: 'user',
+      content,
+      timestamp: Date.now(),
+      metadata: { room: this.name, from, topic },
+    };
+    return this.send({ from, topic, message });
+  }
+}

package/src/core/runtime.ts

@@ -1,152 +1,152 @@
-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 { DeepBrainMemoryStore } from '../memory/deepbrain';
-import type { OADDocument } from '../schema/oad';
-import type { ISkill, MemoryStore, Message } from './types';
-import type { Response } from 'express';
-
-const MAX_TOOL_OUTPUT = 5000;
-const DEFAULT_HISTORY_LIMIT = 50;
-
-export function truncateOutput(output: string, maxChars: number = MAX_TOOL_OUTPUT): string {
-  if (output.length <= maxChars) return output;
-  const half = Math.floor(maxChars / 2) - 50;
-  return `${output.slice(0, half)}\n\n... [truncated ${output.length - maxChars} chars] ...\n\n${output.slice(-half)}`;
-}
-
-export class AgentRuntime {
-  private agent: BaseAgent | null = null;
-  private config: OADDocument | null = null;
-  private logger = new Logger('runtime');
-  private historyLimit: number = DEFAULT_HISTORY_LIMIT;
-  private shutdownHandlers: (() => Promise<void>)[] = [];
-  private isShuttingDown = false;
-
-  async loadConfig(filePath: string): Promise<OADDocument> {
-    this.config = loadOAD(filePath);
-    this.logger.info('Config loaded', { name: this.config.metadata.name });
-    return this.config;
-  }
-
-  setHistoryLimit(limit: number): void {
-    this.historyLimit = limit;
-  }
-
-  async initialize(config?: OADDocument): Promise<BaseAgent> {
-    const cfg = config ?? this.config;
-    if (!cfg) throw new Error('No config loaded. Call loadConfig() first.');
-
-    let memory: MemoryStore | undefined;
-    const memCfg = cfg.spec.memory;
-    if (memCfg && typeof memCfg.longTerm === 'object' && memCfg.longTerm.provider === 'deepbrain') {
-      memory = new DeepBrainMemoryStore({
-        collection: memCfg.longTerm.collection,
-        config: memCfg.longTerm.config,
-      });
-      this.logger.info('Using DeepBrain memory provider');
-    }
-
-    this.agent = new BaseAgent({
-      name: cfg.metadata.name,
-      systemPrompt: cfg.spec.systemPrompt,
-      provider: cfg.spec.provider?.default,
-      model: cfg.spec.model,
-      memory,
-      historyLimit: this.historyLimit,
-    });
-
-    for (const ch of cfg.spec.channels) {
-      if (ch.type === 'web') {
-        const port = ch.port ?? 3000;
-        const webChannel = new WebChannel(port);
-        webChannel.setAgentName(cfg.metadata.name);
-        // Wire streaming
-        webChannel.onStreamMessage(async (msg: Message, res: Response) => {
-          res.writeHead(200, {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive',
-            'Access-Control-Allow-Origin': '*',
-          });
-          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');
-          } catch (err) {
-            const errMsg = err instanceof Error ? err.message : String(err);
-            res.write(`data: ${JSON.stringify({ error: errMsg })}\n\n`);
-          }
-          res.end();
-        });
-        this.agent.bindChannel(webChannel);
-        this.logger.info('Bound web channel', { port });
-      } else if (ch.type === 'telegram') {
-        this.agent.bindChannel(new TelegramChannel({
-          token: ch.config?.token as string,
-          port: ch.port,
-        }));
-        this.logger.info('Bound telegram channel');
-      } else if (ch.type === 'websocket') {
-        this.agent.bindChannel(new WebSocketChannel(ch.port ?? 3002));
-        this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
-      }
-    }
-
-    await this.agent.init();
-    this.logger.info('Agent initialized', { name: cfg.metadata.name });
-    return this.agent;
-  }
-
-  async start(): Promise<void> {
-    if (!this.agent) throw new Error('Agent not initialized.');
-    this.setupGracefulShutdown();
-    await this.agent.start();
-    this.logger.info('Agent started');
-  }
-
-  async stop(): Promise<void> {
-    if (!this.agent) return;
-    this.logger.info('Stopping agent...');
-    await this.agent.stop();
-    for (const handler of this.shutdownHandlers) {
-      await handler();
-    }
-    this.logger.info('Agent stopped');
-  }
-
-  onShutdown(handler: () => Promise<void>): void {
-    this.shutdownHandlers.push(handler);
-  }
-
-  private setupGracefulShutdown(): void {
-    const shutdown = async (signal: string) => {
-      if (this.isShuttingDown) return;
-      this.isShuttingDown = true;
-      this.logger.info(`Received ${signal}, shutting down gracefully...`);
-      await this.stop();
-      process.exit(0);
-    };
-
-    process.on('SIGINT', () => shutdown('SIGINT'));
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-    process.on('uncaughtException', (err) => {
-      this.logger.error('Uncaught exception', { message: err.message });
-      shutdown('uncaughtException');
-    });
-  }
-
-  registerSkill(skill: ISkill): void {
-    if (!this.agent) throw new Error('Agent not initialized.');
-    this.agent.registerSkill(skill);
-    this.logger.debug('Skill registered', { name: skill.name });
-  }
-
-  getAgent(): BaseAgent | null {
-    return this.agent;
-  }
-}
+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 { DeepBrainMemoryStore } from '../memory/deepbrain';
+import type { OADDocument } from '../schema/oad';
+import type { ISkill, MemoryStore, Message } from './types';
+import type { Response } from 'express';
+
+const MAX_TOOL_OUTPUT = 5000;
+const DEFAULT_HISTORY_LIMIT = 50;
+
+export function truncateOutput(output: string, maxChars: number = MAX_TOOL_OUTPUT): string {
+  if (output.length <= maxChars) return output;
+  const half = Math.floor(maxChars / 2) - 50;
+  return `${output.slice(0, half)}\n\n... [truncated ${output.length - maxChars} chars] ...\n\n${output.slice(-half)}`;
+}
+
+export class AgentRuntime {
+  private agent: BaseAgent | null = null;
+  private config: OADDocument | null = null;
+  private logger = new Logger('runtime');
+  private historyLimit: number = DEFAULT_HISTORY_LIMIT;
+  private shutdownHandlers: (() => Promise<void>)[] = [];
+  private isShuttingDown = false;
+
+  async loadConfig(filePath: string): Promise<OADDocument> {
+    this.config = loadOAD(filePath);
+    this.logger.info('Config loaded', { name: this.config.metadata.name });
+    return this.config;
+  }
+
+  setHistoryLimit(limit: number): void {
+    this.historyLimit = limit;
+  }
+
+  async initialize(config?: OADDocument): Promise<BaseAgent> {
+    const cfg = config ?? this.config;
+    if (!cfg) throw new Error('No config loaded. Call loadConfig() first.');
+
+    let memory: MemoryStore | undefined;
+    const memCfg = cfg.spec.memory;
+    if (memCfg && typeof memCfg.longTerm === 'object' && memCfg.longTerm.provider === 'deepbrain') {
+      memory = new DeepBrainMemoryStore({
+        collection: memCfg.longTerm.collection,
+        config: memCfg.longTerm.config,
+      });
+      this.logger.info('Using DeepBrain memory provider');
+    }
+
+    this.agent = new BaseAgent({
+      name: cfg.metadata.name,
+      systemPrompt: cfg.spec.systemPrompt,
+      provider: cfg.spec.provider?.default,
+      model: cfg.spec.model,
+      memory,
+      historyLimit: this.historyLimit,
+    });
+
+    for (const ch of cfg.spec.channels) {
+      if (ch.type === 'web') {
+        const port = ch.port ?? 3000;
+        const webChannel = new WebChannel(port);
+        webChannel.setAgentName(cfg.metadata.name);
+        // Wire streaming
+        webChannel.onStreamMessage(async (msg: Message, res: Response) => {
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+          });
+          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');
+          } catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            res.write(`data: ${JSON.stringify({ error: errMsg })}\n\n`);
+          }
+          res.end();
+        });
+        this.agent.bindChannel(webChannel);
+        this.logger.info('Bound web channel', { port });
+      } else if (ch.type === 'telegram') {
+        this.agent.bindChannel(new TelegramChannel({
+          token: ch.config?.token as string,
+          port: ch.port,
+        }));
+        this.logger.info('Bound telegram channel');
+      } else if (ch.type === 'websocket') {
+        this.agent.bindChannel(new WebSocketChannel(ch.port ?? 3002));
+        this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
+      }
+    }
+
+    await this.agent.init();
+    this.logger.info('Agent initialized', { name: cfg.metadata.name });
+    return this.agent;
+  }
+
+  async start(): Promise<void> {
+    if (!this.agent) throw new Error('Agent not initialized.');
+    this.setupGracefulShutdown();
+    await this.agent.start();
+    this.logger.info('Agent started');
+  }
+
+  async stop(): Promise<void> {
+    if (!this.agent) return;
+    this.logger.info('Stopping agent...');
+    await this.agent.stop();
+    for (const handler of this.shutdownHandlers) {
+      await handler();
+    }
+    this.logger.info('Agent stopped');
+  }
+
+  onShutdown(handler: () => Promise<void>): void {
+    this.shutdownHandlers.push(handler);
+  }
+
+  private setupGracefulShutdown(): void {
+    const shutdown = async (signal: string) => {
+      if (this.isShuttingDown) return;
+      this.isShuttingDown = true;
+      this.logger.info(`Received ${signal}, shutting down gracefully...`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('uncaughtException', (err) => {
+      this.logger.error('Uncaught exception', { message: err.message });
+      shutdown('uncaughtException');
+    });
+  }
+
+  registerSkill(skill: ISkill): void {
+    if (!this.agent) throw new Error('Agent not initialized.');
+    this.agent.registerSkill(skill);
+    this.logger.debug('Skill registered', { name: skill.name });
+  }
+
+  getAgent(): BaseAgent | null {
+    return this.agent;
+  }
+}