@starlink-awaken/agentmesh 1.0.0

package/src/core/event-bus.ts

@@ -0,0 +1,76 @@
+import { EventEmitter } from 'events';
+import type { AgentMessage, EventType } from '../types/index.js';
+
+interface EventBusOptions {
+  logger?: Console;
+}
+
+export class EventBus extends EventEmitter {
+  private logger: Console;
+
+  constructor(options: EventBusOptions = {}) {
+    super();
+    this.logger = options.logger || console;
+    this.setMaxListeners(100);
+  }
+
+  /**
+   * 发布事件
+   */
+  publish(eventType: EventType, data: AgentMessage): void {
+    const event = {
+      type: eventType,
+      data,
+      timestamp: Date.now()
+    };
+    this.emit(eventType, event);
+    this.logger.info(`[EventBus] Published: ${eventType}`, { id: data.id });
+  }
+
+  /**
+   * 订阅事件
+   */
+  subscribe(eventType: EventType, handler: (event: { type: EventType; data: AgentMessage; timestamp: number }) => void): () => void {
+    this.on(eventType, handler);
+    this.logger.info(`[EventBus] Subscribed to: ${eventType}`);
+
+    // 返回取消订阅函数
+    return () => {
+      this.off(eventType, handler);
+      this.logger.info(`[EventBus] Unsubscribed from: ${eventType}`);
+    };
+  }
+
+  /**
+   * 发布任务事件
+   */
+  publishTaskEvent(eventType: Exclude<EventType, 'agent.registered' | 'agent.unregistered'>, message: AgentMessage): void {
+    this.publish(eventType, message);
+  }
+
+  /**
+   * 发布 Agent 事件
+   */
+  publishAgentEvent(eventType: 'agent.registered' | 'agent.unregistered', message: AgentMessage): void {
+    this.publish(eventType, message);
+  }
+
+  /**
+   * 获取所有事件类型
+   */
+  getEventTypes(): EventType[] {
+    return [
+      'agent.registered',
+      'agent.unregistered',
+      'task.submitted',
+      'task.assigned',
+      'task.started',
+      'task.progress',
+      'task.completed',
+      'task.failed',
+      'context.updated'
+    ];
+  }
+}
+
+export const eventBus = new EventBus();

package/src/core/metrics.ts

@@ -0,0 +1,216 @@
+import { writeFileSync, existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+
+interface Metric {
+  name: string;
+  value: number;
+  timestamp: number;
+  tags?: Record<string, string>;
+}
+
+interface LogEntry {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  message: string;
+  timestamp: number;
+  data?: any;
+}
+
+export class Metrics {
+  private metrics: Map<string, Metric[]> = new Map();
+  private logs: LogEntry[] = [];
+  private logDir: string;
+  private maxMetricsHistory = 1000;
+  private maxLogsHistory = 1000;
+
+  constructor(logDir: string = './logs') {
+    this.logDir = logDir;
+    this.ensureLogDir();
+  }
+
+  private ensureLogDir(): void {
+    if (!existsSync(this.logDir)) {
+      mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+
+  /**
+   * 记录指标
+   */
+  record(name: string, value: number, tags?: Record<string, string>): void {
+    const metric: Metric = {
+      name,
+      value,
+      timestamp: Date.now(),
+      tags
+    };
+
+    if (!this.metrics.has(name)) {
+      this.metrics.set(name, []);
+    }
+
+    const history = this.metrics.get(name)!;
+    history.push(metric);
+
+    // 保持历史记录数量
+    if (history.length > this.maxMetricsHistory) {
+      history.shift();
+    }
+  }
+
+  /**
+   * 递增计数器
+   */
+  increment(name: string, tags?: Record<string, string>): void {
+    const current = this.get(name);
+    this.record(name, current + 1, tags);
+  }
+
+  /**
+   * 记录执行时间
+   */
+  timing(name: string, duration: number, tags?: Record<string, string>): void {
+    this.record(`${name}.duration`, duration, tags);
+  }
+
+  /**
+   * 获取指标值
+   */
+  get(name: string): number {
+    const history = this.metrics.get(name);
+    if (!history || history.length === 0) return 0;
+    const last = history[history.length - 1];
+    return last?.value ?? 0;
+  }
+
+  /**
+   * 获取指标历史
+   */
+  getHistory(name: string, limit?: number): Metric[] {
+    const history = this.metrics.get(name);
+    if (!history) return [];
+    return limit ? history.slice(-limit) : history;
+  }
+
+  /**
+   * 获取所有指标摘要
+   */
+  getSummary(): Record<string, { count: number; last: number; avg: number }> {
+    const summary: Record<string, { count: number; last: number; avg: number }> = {};
+
+    for (const [name, history] of this.metrics) {
+      if (history.length === 0) continue;
+
+      const values = history.map(m => m.value);
+      const sum = values.reduce((a, b) => a + b, 0);
+
+      summary[name] = {
+        count: history.length,
+        last: values[values.length - 1] ?? 0,
+        avg: sum / values.length
+      };
+    }
+
+    return summary;
+  }
+
+  /**
+   * 记录日志
+   */
+  log(level: LogEntry['level'], message: string, data?: any): void {
+    const entry: LogEntry = {
+      level,
+      message,
+      timestamp: Date.now(),
+      data
+    };
+
+    this.logs.push(entry);
+
+    // 保持日志数量
+    if (this.logs.length > this.maxLogsHistory) {
+      this.logs.shift();
+    }
+
+    // 写入文件
+    this.writeLogToFile(entry);
+  }
+
+  private writeLogToFile(entry: LogEntry): void {
+    try {
+      const date = new Date(entry.timestamp).toISOString().split('T')[0];
+      const logFile = join(this.logDir, `gateway-${date}.log`);
+      const line = `[${new Date(entry.timestamp).toISOString()}] [${entry.level.toUpperCase()}] ${entry.message}${entry.data ? ' ' + JSON.stringify(entry.data) : ''}\n`;
+      appendFileSync(logFile, line);
+    } catch (error) {
+      console.error('Failed to write log to file:', error);
+    }
+  }
+
+  /**
+   * 获取日志
+   */
+  getLogs(level?: LogEntry['level'], limit?: number): LogEntry[] {
+    let filtered = this.logs;
+
+    if (level) {
+      filtered = filtered.filter(l => l.level === level);
+    }
+
+    return limit ? filtered.slice(-limit) : filtered;
+  }
+
+  /**
+   * 获取统计信息
+   */
+  getStats(): {
+    uptime: number;
+    totalTasks: number;
+    completedTasks: number;
+    failedTasks: number;
+    activeAgents: number;
+    metricsCount: number;
+    logsCount: number;
+  } {
+    const taskHistory = this.metrics.get('tasks.submitted') || [];
+    const completedHistory = this.metrics.get('tasks.completed') || [];
+    const failedHistory = this.metrics.get('tasks.failed') || [];
+
+    return {
+      uptime: this.startTime ? Date.now() - this.startTime : 0,
+      totalTasks: taskHistory.length,
+      completedTasks: completedHistory.length,
+      failedTasks: failedHistory.length,
+      activeAgents: this.metrics.get('agents.active')?.[0]?.value || 0,
+      metricsCount: this.metrics.size,
+      logsCount: this.logs.length
+    };
+  }
+
+  private startTime = Date.now();
+
+  /**
+   * 启动计时
+   */
+  start(): void {
+    this.startTime = Date.now();
+  }
+
+  /**
+   * 重置指标
+   */
+  reset(): void {
+    this.metrics.clear();
+    this.logs = [];
+    this.startTime = Date.now();
+  }
+}
+
+export const metrics = new Metrics();
+
+// 便捷方法
+export const logger = {
+  debug: (message: string, data?: any) => metrics.log('debug', message, data),
+  info: (message: string, data?: any) => metrics.log('info', message, data),
+  warn: (message: string, data?: any) => metrics.log('warn', message, data),
+  error: (message: string, data?: any) => metrics.log('error', message, data)
+};

package/src/core/router.ts

@@ -0,0 +1,105 @@
+import type { Agent, RoutingRule, AgentMessage } from '../types/index.js';
+
+export class Router {
+  private rules: RoutingRule[] = [];
+  private agents: Map<string, Agent> = new Map();
+  private defaultAgent?: string;
+
+  /**
+   * 配置路由规则
+   */
+  configure(rules: RoutingRule[], defaultAgent?: string): void {
+    // 按优先级排序
+    this.rules = [...rules].sort((a, b) => b.priority - a.priority);
+    this.defaultAgent = defaultAgent;
+  }
+
+  /**
+   * 注册 Agent
+   */
+  registerAgent(agent: Agent): void {
+    this.agents.set(agent.id, agent);
+  }
+
+  /**
+   * 注销 Agent
+   */
+  unregisterAgent(agentId: string): void {
+    this.agents.delete(agentId);
+  }
+
+  /**
+   * 获取所有在线 Agent
+   */
+  getOnlineAgents(): Agent[] {
+    return Array.from(this.agents.values()).filter(a => a.status === 'online');
+  }
+
+  /**
+   * 路由任务到合适的 Agent
+   */
+  route(message: AgentMessage): { agentIds: string[]; strategy: 'direct' | 'broadcast' } {
+    const task = message.payload?.task || '';
+
+    // 匹配路由规则
+    for (const rule of this.rules) {
+      if (this.matchesRule(task, rule.keywords)) {
+        // 检查 Agent 是否在线
+        if (rule.strategy === 'broadcast' && rule.agents) {
+          const availableAgents = rule.agents.filter(id => this.isAgentOnline(id));
+          if (availableAgents.length > 0) {
+            return { agentIds: availableAgents, strategy: 'broadcast' };
+          }
+        } else if (rule.agent && this.isAgentOnline(rule.agent)) {
+          return { agentIds: [rule.agent], strategy: 'direct' };
+        }
+      }
+    }
+
+    // 使用默认 Agent
+    if (this.defaultAgent && this.isAgentOnline(this.defaultAgent)) {
+      return { agentIds: [this.defaultAgent], strategy: 'direct' };
+    }
+
+    // 返回所有在线 Agent 作为兜底
+    const onlineAgents = this.getOnlineAgents();
+    if (onlineAgents.length > 0) {
+      return { agentIds: onlineAgents.map(a => a.id), strategy: 'broadcast' };
+    }
+
+    // 没有可用的 Agent
+    return { agentIds: [], strategy: 'direct' };
+  }
+
+  /**
+   * 检查任务是否匹配路由关键词
+   */
+  private matchesRule(task: string, keywords: string[]): boolean {
+    const lowerTask = task.toLowerCase();
+    return keywords.some(keyword => lowerTask.includes(keyword.toLowerCase()));
+  }
+
+  /**
+   * 检查 Agent 是否在线
+   */
+  private isAgentOnline(agentId: string): boolean {
+    const agent = this.agents.get(agentId);
+    return agent?.status === 'online';
+  }
+
+  /**
+   * 获取 Agent 信息
+   */
+  getAgent(agentId: string): Agent | undefined {
+    return this.agents.get(agentId);
+  }
+
+  /**
+   * 获取所有 Agent
+   */
+  getAllAgents(): Agent[] {
+    return Array.from(this.agents.values());
+  }
+}
+
+export const router = new Router();

package/src/core/task-manager.ts

@@ -0,0 +1,248 @@
+import { v4 as uuidv4 } from 'uuid';
+import type { Task, AgentMessage, Agent, Error } from '../types/index.js';
+import { eventBus } from './event-bus.js';
+import { router } from './router.js';
+import { contextManager } from './context-manager.js';
+import { agentRegistry } from './agent-registry.js';
+
+export class TaskManager {
+  private tasks: Map<string, Task> = new Map();
+
+  /**
+   * 创建新任务
+   */
+  async createTask(request: AgentMessage): Promise<Task> {
+    const taskId = uuidv4();
+    const task: Task = {
+      id: taskId,
+      status: 'pending',
+      request,
+      assignedAgents: [],
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    };
+
+    this.tasks.set(taskId, task);
+
+    // 发布任务提交事件
+    eventBus.publishTaskEvent('task.submitted', {
+      ...request,
+      id: taskId
+    });
+
+    return task;
+  }
+
+  /**
+   * 分配任务到 Agent
+   */
+  assignTask(taskId: string, agentIds: string[]): Task | null {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return null;
+    }
+
+    task.assignedAgents = agentIds;
+    task.status = 'assigned';
+    task.updatedAt = Date.now();
+
+    // 发布任务分配事件
+    eventBus.publishTaskEvent('task.assigned', {
+      ...task.request,
+      id: taskId
+    });
+
+    return task;
+  }
+
+  /**
+   * 开始执行任务
+   */
+  startTask(taskId: string): Task | null {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return null;
+    }
+
+    task.status = 'running';
+    task.updatedAt = Date.now();
+
+    eventBus.publishTaskEvent('task.started', {
+      ...task.request,
+      id: taskId
+    });
+
+    return task;
+  }
+
+  /**
+   * 完成任务
+   */
+  completeTask(taskId: string, result: unknown): Task | null {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return null;
+    }
+
+    task.status = 'completed';
+    task.result = result;
+    task.updatedAt = Date.now();
+
+    eventBus.publishTaskEvent('task.completed', {
+      ...task.request,
+      id: taskId,
+      result
+    });
+
+    return task;
+  }
+
+  /**
+   * 任务失败
+   */
+  failTask(taskId: string, error: Error): Task | null {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      return null;
+    }
+
+    task.status = 'failed';
+    task.error = error;
+    task.updatedAt = Date.now();
+
+    eventBus.publishTaskEvent('task.failed', {
+      ...task.request,
+      id: taskId,
+      error
+    });
+
+    return task;
+  }
+
+  /**
+   * 获取任务
+   */
+  getTask(taskId: string): Task | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  /**
+   * 获取所有任务
+   */
+  getAllTasks(): Task[] {
+    return Array.from(this.tasks.values());
+  }
+
+  /**
+   * 处理任务
+   */
+  async processTask(message: AgentMessage): Promise<Task> {
+    // 1. 创建任务
+    const task = await this.createTask(message);
+
+    // 2. 如果有共享空间，添加消息到上下文
+    if (message.payload?.context?.shared_space_id) {
+      await contextManager.addMessage(
+        message.payload.context.shared_space_id,
+        message
+      );
+    }
+
+    // 3. 路由任务到 Agent
+    const { agentIds, strategy } = router.route(message);
+
+    if (agentIds.length === 0) {
+      this.failTask(task.id, {
+        code: 'NO_AGENT_AVAILABLE',
+        message: 'No available agents to handle this task'
+      });
+      throw new Error('No available agents');
+    }
+
+    // 4. 分配任务
+    this.assignTask(task.id, agentIds);
+    this.startTask(task.id);
+
+    // 5. 执行任务
+    await this.executeTask(task, agentIds, strategy);
+
+    return task;
+  }
+
+  /**
+   * 执行任务
+   */
+  private async executeTask(
+    task: Task,
+    agentIds: string[],
+    strategy: 'direct' | 'broadcast'
+  ): Promise<void> {
+    const results: Record<string, unknown> = {};
+
+    if (strategy === 'direct' && agentIds[0]) {
+      // 单 Agent 执行
+      const agentId = agentIds[0]!;
+      const adapter = agentRegistry.get(agentId);
+
+      if (!adapter) {
+        this.failTask(task.id, {
+          code: 'AGENT_NOT_FOUND',
+          message: `Agent ${agentId} not found`
+        });
+        return;
+      }
+
+      try {
+        console.log(`[TaskManager] Executing task ${task.id} with agent ${agentId}`);
+        const response = await adapter.invoke(task.request);
+        results[agentId] = response.result;
+
+        // 如果有共享空间，添加响应到上下文
+        if (task.request.payload?.context?.shared_space_id) {
+          await contextManager.addMessage(
+            task.request.payload.context.shared_space_id,
+            response
+          );
+        }
+
+        this.completeTask(task.id, response.result);
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.failTask(task.id, {
+          code: 'EXECUTION_ERROR',
+          message: errorMessage
+        });
+      }
+    } else {
+      // 广播模式：多个 Agent 同时执行
+      const promises = agentIds.map(async (agentId) => {
+        const adapter = agentRegistry.get(agentId);
+        if (!adapter) {
+          results[agentId] = { error: `Agent ${agentId} not found` };
+          return;
+        }
+
+        try {
+          const response = await adapter.invoke(task.request);
+          results[agentId] = response.result;
+
+          // 添加响应到上下文
+          if (task.request.payload?.context?.shared_space_id) {
+            await contextManager.addMessage(
+              task.request.payload.context.shared_space_id,
+              response
+            );
+          }
+        } catch (error: unknown) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          results[agentId] = { error: errorMessage };
+        }
+      });
+
+      await Promise.all(promises);
+      this.completeTask(task.id, results);
+    }
+  }
+}
+
+export const taskManager = new TaskManager();