@starlink-awaken/agentmesh 1.0.0

package/src/core/vector-store.ts

@@ -0,0 +1,203 @@
+import { ChromaClient } from 'chromadb';
+import type { Collection } from 'chromadb';
+import type { AgentMessage } from '../types/index.js';
+
+interface VectorEntry {
+  id: string;
+  message: AgentMessage;
+  embedding?: number[];
+}
+
+export class VectorStore {
+  private client: ChromaClient | null = null;
+  private collection: Collection | null = null;
+  private isInitialized = false;
+  private baseDir: string;
+
+  constructor(baseDir: string = './data/vector-db') {
+    this.baseDir = baseDir;
+  }
+
+  /**
+   * 初始化向量数据库
+   */
+  async initialize(): Promise<void> {
+    if (this.isInitialized) return;
+
+    try {
+      this.client = new ChromaClient({
+        path: 'http://localhost:8000'
+      });
+
+      // 尝试获取或创建 collection
+      try {
+        this.collection = await this.client.getOrCreateCollection({
+          name: 'agent-context'
+        });
+      } catch {
+        // Collection 可能不存在，创建新的
+        this.collection = await this.client.createCollection({
+          name: 'agent-context'
+        });
+      }
+
+      this.isInitialized = true;
+      console.log('[VectorStore] Initialized successfully');
+    } catch (error) {
+      console.warn('[VectorStore] Failed to initialize (ChromaDB not running?):', error);
+      this.isInitialized = false;
+    }
+  }
+
+  /**
+   * 添加消息到向量存储
+   */
+  async addMessage(spaceId: string, message: AgentMessage): Promise<void> {
+    if (!this.isInitialized || !this.collection) {
+      console.warn('[VectorStore] Not initialized, skipping add');
+      return;
+    }
+
+    const entry: VectorEntry = {
+      id: `${spaceId}_${message.id}`,
+      message
+    };
+
+    try {
+      // 简单文本向量化（使用消息内容）
+      const text = this.messageToText(message);
+
+      await this.collection.add({
+        ids: [entry.id],
+        documents: [text],
+        metadatas: [{
+          space_id: spaceId,
+          message_id: message.id,
+          timestamp: message.timestamp,
+          source: message.source,
+          type: message.type
+        }]
+      });
+
+      console.log('[VectorStore] Added message:', entry.id);
+    } catch (error) {
+      console.error('[VectorStore] Failed to add message:', error);
+    }
+  }
+
+  /**
+   * 搜索相似上下文
+   */
+  async searchSimilar(spaceId: string, query: string, limit: number = 5): Promise<AgentMessage[]> {
+    if (!this.isInitialized || !this.collection) {
+      console.warn('[VectorStore] Not initialized, returning empty');
+      return [];
+    }
+
+    try {
+      const results = await this.collection.query({
+        queryTexts: [query],
+        nResults: limit,
+        where: { space_id: spaceId }
+      });
+
+      const messages: AgentMessage[] = [];
+      if (results.documents && results.documents[0]) {
+        for (let i = 0; i < results.documents[0].length; i++) {
+          const metadata = results.metadatas?.[0]?.[i];
+          if (metadata?.message_id) {
+            // 这里返回元数据，实际使用时可以从文件/内存中获取完整消息
+            messages.push({
+              id: metadata.message_id as string,
+              type: 'event',
+              source: metadata.source as string,
+              target: 'search',
+              correlation_id: '',
+              timestamp: metadata.timestamp as number,
+              payload: {
+                task: results.documents[0][i] || ''
+              }
+            });
+          }
+        }
+      }
+
+      return messages;
+    } catch (error) {
+      console.error('[VectorStore] Search failed:', error);
+      return [];
+    }
+  }
+
+  /**
+   * 获取空间的向量数量
+   */
+  async getCount(spaceId: string): Promise<number> {
+    if (!this.isInitialized || !this.collection) {
+      return 0;
+    }
+
+    try {
+      const results = await this.collection.get({
+        where: { space_id: spaceId }
+      });
+      return results.ids?.length || 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * 删除空间的向量
+   */
+  async deleteSpace(spaceId: string): Promise<void> {
+    if (!this.isInitialized || !this.collection) {
+      return;
+    }
+
+    try {
+      // 获取该 space 的所有 ID
+      const results = await this.collection.get({
+        where: { space_id: spaceId }
+      });
+
+      if (results.ids && results.ids.length > 0) {
+        await this.collection.delete({
+          ids: results.ids
+        });
+      }
+    } catch (error) {
+      console.error('[VectorStore] Delete space failed:', error);
+    }
+  }
+
+  /**
+   * 将消息转换为可向量化的文本
+   */
+  private messageToText(message: AgentMessage): string {
+    const parts: string[] = [];
+
+    if (message.payload?.task) {
+      parts.push(`Task: ${message.payload.task}`);
+    }
+
+    if (message.result) {
+      parts.push(`Result: ${JSON.stringify(message.result)}`);
+    }
+
+    if (message.error) {
+      parts.push(`Error: ${message.error.message}`);
+    }
+
+    return parts.join('\n') || JSON.stringify(message);
+  }
+
+  /**
+   * 检查是否可用
+   */
+  isAvailable(): boolean {
+    return this.isInitialized;
+  }
+}
+
+export const vectorStore = new VectorStore();

package/src/index.ts

@@ -0,0 +1,84 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { apiRoutes } from './routes/api.js';
+import { websocketRoutes } from './routes/websocket.js';
+import { eventBus } from './core/event-bus.js';
+import { router } from './core/router.js';
+import { agentRegistry } from './core/agent-registry.js';
+import { vectorStore } from './core/vector-store.js';
+import { loadConfig, getRoutingRules, getDefaultAgent } from './core/config.js';
+
+async function main() {
+  const config = loadConfig();
+
+  // 初始化 Fastify
+  const fastify = Fastify({
+    logger: {
+      level: config.logLevel
+    }
+  });
+
+  // 注册 CORS
+  await fastify.register(cors, {
+    origin: true
+  });
+
+  // 注册路由
+  await fastify.register(apiRoutes);
+  await fastify.register(websocketRoutes);
+
+  // 初始化组件
+  const rules = getRoutingRules();
+  const defaultAgent = getDefaultAgent();
+  router.configure(rules, defaultAgent);
+
+  // 初始化 Agent Registry
+  agentRegistry.initialize();
+
+  // 注册所有 Agent 到 Router
+  agentRegistry.getAgents().forEach(agent => {
+    router.registerAgent(agent);
+  });
+
+  // 初始化向量存储（异步）
+  vectorStore.initialize().catch(err => {
+    console.warn('[VectorStore] Init failed:', err);
+  });
+
+  // 启动服务器
+  try {
+    await fastify.listen({
+      port: config.port,
+      host: config.host
+    });
+
+    console.log(`
+╔═══════════════════════════════════════════════════╗
+║           Agent Gateway Server                   ║
+╠═══════════════════════════════════════════════════╣
+║  HTTP Server: http://${config.host}:${config.port}              ║
+║  WebSocket:  ws://${config.host}:${config.port}/ws             ║
+║  SSE:        http://${config.host}:${config.port}/events       ║
+║  Health:     http://${config.host}:${config.port}/health       ║
+║  Tasks:      http://${config.host}:${config.port}/tasks        ║
+║  Spaces:     http://${config.host}:${config.port}/spaces       ║
+║  Agents:     http://${config.host}:${config.port}/agents       ║
+╚═══════════════════════════════════════════════════╝
+    `);
+
+    // 订阅事件日志
+    eventBus.getEventTypes().forEach(eventType => {
+      eventBus.subscribe(eventType, (event) => {
+        console.log(`[Event] ${event.type}:`, {
+          id: event.data.id,
+          correlation_id: event.data.correlation_id
+        });
+      });
+    });
+  } catch (error) {
+    fastify.log.error(error);
+    process.exit(1);
+  }
+}
+
+main();

package/src/routes/api.ts

@@ -0,0 +1,158 @@
+import type { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { v4 as uuidv4 } from 'uuid';
+import type { AgentMessage, Agent } from '../types/index.js';
+import { taskManager } from '../core/task-manager.js';
+import { router } from '../core/router.js';
+import { contextManager } from '../core/context-manager.js';
+
+export async function apiRoutes(fastify: FastifyInstance) {
+  // 健康检查
+  fastify.get('/health', async (_request: FastifyRequest, _reply: FastifyReply) => {
+    return {
+      status: 'ok',
+      timestamp: Date.now(),
+      agents: router.getAllAgents().map(a => ({
+        id: a.id,
+        name: a.name,
+        status: a.status
+      }))
+    };
+  });
+
+  // 提交任务
+  fastify.post<{ Body: Partial<AgentMessage> }>(
+    '/tasks',
+    async (request: FastifyRequest<{ Body: Partial<AgentMessage> }>, reply: FastifyReply) => {
+      const body = request.body || {};
+
+      const message: AgentMessage = {
+        id: uuidv4(),
+        type: 'request',
+        source: body.source || 'api',
+        target: 'gateway',
+        correlation_id: body.correlation_id || uuidv4(),
+        timestamp: Date.now(),
+        payload: body.payload
+      };
+
+      try {
+        const task = await taskManager.processTask(message);
+        reply.code(202).send({
+          task_id: task.id,
+          status: task.status,
+          message: 'Task submitted successfully'
+        });
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        reply.code(500).send({
+          error: {
+            code: 'TASK_FAILED',
+            message: errorMessage
+          }
+        });
+      }
+    }
+  );
+
+  // 获取任务状态
+  fastify.get<{ Params: { taskId: string } }>(
+    '/tasks/:taskId',
+    async (request: FastifyRequest<{ Params: { taskId: string } }>, reply: FastifyReply) => {
+      const { taskId } = request.params;
+      const task = taskManager.getTask(taskId);
+
+      if (!task) {
+        reply.code(404).send({
+          error: {
+            code: 'TASK_NOT_FOUND',
+            message: `Task ${taskId} not found`
+          }
+        });
+        return;
+      }
+
+      reply.send({
+        id: task.id,
+        status: task.status,
+        assigned_agents: task.assignedAgents,
+        result: task.result,
+        error: task.error,
+        created_at: task.createdAt,
+        updated_at: task.updatedAt
+      });
+    }
+  );
+
+  // 获取所有任务
+  fastify.get('/tasks', async (_request: FastifyRequest, reply: FastifyReply) => {
+    const tasks = taskManager.getAllTasks();
+    reply.send(tasks.map(t => ({
+      id: t.id,
+      status: t.status,
+      assigned_agents: t.assignedAgents,
+      created_at: t.createdAt
+    })));
+  });
+
+  // 创建共享空间
+  fastify.post<{ Body: { metadata?: Record<string, unknown> } }>(
+    '/spaces',
+    async (request: FastifyRequest<{ Body: { metadata?: Record<string, unknown> } }>, reply: FastifyReply) => {
+      const { metadata } = request.body || {};
+      const spaceId = await contextManager.createSharedSpace(metadata);
+      reply.code(201).send({ space_id: spaceId });
+    }
+  );
+
+  // 获取共享空间
+  fastify.get<{ Params: { spaceId: string } }>(
+    '/spaces/:spaceId',
+    async (request: FastifyRequest<{ Params: { spaceId: string } }>, reply: FastifyReply) => {
+      const { spaceId } = request.params;
+      const context = await contextManager.getSharedSpace(spaceId);
+
+      if (!context) {
+        reply.code(404).send({
+          error: {
+            code: 'SPACE_NOT_FOUND',
+            message: `Shared space ${spaceId} not found`
+          }
+        });
+        return;
+      }
+
+      reply.send({
+        shared_space_id: context.shared_space_id,
+        message_count: context.messages.length,
+        artifact_count: context.artifacts.size,
+        metadata: context.metadata,
+        created_at: context.createdAt,
+        updated_at: context.updatedAt
+      });
+    }
+  );
+
+  // 获取 Agent 列表
+  fastify.get('/agents', async (_request: FastifyRequest, reply: FastifyReply) => {
+    const agents = router.getAllAgents();
+    reply.send(agents);
+  });
+
+  // 注册 Agent
+  fastify.post<{ Body: Partial<Agent> }>(
+    '/agents',
+    async (request: FastifyRequest<{ Body: Partial<Agent> }>, reply: FastifyReply) => {
+      const body = request.body || {};
+      router.registerAgent({
+        id: body.id || 'unknown',
+        name: body.name || 'Unknown',
+        type: body.type || 'process',
+        capabilities: body.capabilities || [],
+        status: 'online',
+        endpoint: body.endpoint,
+        lastSeen: Date.now()
+      });
+      reply.code(201).send({ id: body.id, status: 'registered' });
+    }
+  );
+}

package/src/routes/websocket.ts

@@ -0,0 +1,91 @@
+import type { FastifyInstance } from 'fastify';
+import { v4 as uuidv4 } from 'uuid';
+import type { AgentMessage } from '../types/index.js';
+import { taskManager } from '../core/task-manager.js';
+import { agentRegistry } from '../core/agent-registry.js';
+
+interface SSEClient {
+  id: string;
+  reply: any;
+}
+
+export async function websocketRoutes(fastify: FastifyInstance) {
+  const clients: Map<string, SSEClient> = new Map();
+
+  // SSE 端点 - 用于实时任务更新
+  fastify.get<{ Querystring: { taskId?: string; spaceId?: string } }>(
+    '/events',
+    async (request, reply) => {
+      const { taskId, spaceId } = request.query;
+
+      reply.raw.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive'
+      });
+
+      const clientId = uuidv4();
+
+      clients.set(clientId, {
+        id: clientId,
+        reply
+      });
+
+      // 发送初始连接消息
+      reply.raw.write(`data: ${JSON.stringify({ type: 'connected', client_id: clientId })}\n\n`);
+
+      // 订阅任务事件
+      if (taskId) {
+        const task = taskManager.getTask(taskId);
+        if (task) {
+          reply.raw.write(`data: ${JSON.stringify({ type: 'task_status', task })}\n\n`);
+        }
+      }
+
+      // 发送欢迎消息
+      reply.raw.write(`data: ${JSON.stringify({ type: 'welcome', agents: agentRegistry.getAgents() })}\n\n`);
+
+      // 心跳
+      const heartbeat = setInterval(() => {
+        reply.raw.write(`data: ${JSON.stringify({ type: 'heartbeat', timestamp: Date.now() })}\n\n`);
+      }, 30000);
+
+      request.raw.on('close', () => {
+        clearInterval(heartbeat);
+        clients.delete(clientId);
+      });
+    }
+  );
+
+  // WebSocket 模拟端点 - 返回 SSE 连接信息
+  fastify.get('/ws-info', async (_request, reply) => {
+    reply.send({
+      message: 'Use /events for Server-Sent Events streaming',
+      endpoints: {
+        events: '/events?taskId=<task_id>&spaceId=<space_id>',
+        description: 'Subscribe to real-time task updates and agent responses'
+      },
+      example: 'curl -N http://localhost:3000/events?taskId=<task_id>'
+    });
+  });
+
+  // 广播消息到所有客户端
+  fastify.post<{ Body: { type: string; data: any } }>(
+    '/broadcast',
+    async (request, reply) => {
+      const { type, data } = request.body || {};
+
+      const message = JSON.stringify({ type, data, timestamp: Date.now() });
+
+      for (const client of clients.values()) {
+        try {
+          client.reply.raw.write(`data: ${message}\n\n`);
+        } catch (e) {
+          // 客户端可能已断开
+        }
+      }
+
+      reply.send({ delivered: clients.size });
+    }
+  );
+}

package/src/types/index.ts

@@ -0,0 +1,90 @@
+// Agent Gateway 通信协议类型定义
+
+export type MessageType = 'request' | 'response' | 'event' | 'stream' | 'stream_end';
+export type EventType =
+  | 'agent.registered'
+  | 'agent.unregistered'
+  | 'task.submitted'
+  | 'task.assigned'
+  | 'task.started'
+  | 'task.progress'
+  | 'task.completed'
+  | 'task.failed'
+  | 'context.updated';
+
+export interface ContextRef {
+  shared_space_id: string;
+  history?: string[];
+  artifacts?: string[];
+}
+
+export interface Payload {
+  task?: string;
+  context?: ContextRef;
+  files?: string[];
+  options?: {
+    stream?: boolean;
+    timeout?: number;
+  };
+}
+
+export interface Error {
+  code: string;
+  message: string;
+}
+
+export interface AgentMessage {
+  id: string;
+  type: MessageType;
+  source: string;
+  target: string;
+  correlation_id: string;
+  timestamp: number;
+  payload?: Payload;
+  event_type?: EventType;
+  event_data?: Record<string, unknown>;
+  result?: unknown;
+  error?: Error;
+}
+
+export interface Agent {
+  id: string;
+  name: string;
+  type: 'claude-code' | 'openclaw' | 'process' | 'http';
+  capabilities: string[];
+  status: 'online' | 'offline' | 'busy';
+  endpoint?: string;
+  lastSeen: number;
+}
+
+export interface Task {
+  id: string;
+  status: 'pending' | 'assigned' | 'running' | 'completed' | 'failed';
+  request: AgentMessage;
+  assignedAgents: string[];
+  result?: unknown;
+  error?: Error;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface RoutingRule {
+  name: string;
+  keywords: string[];
+  agent?: string;
+  strategy?: 'direct' | 'broadcast';
+  agents?: string[];
+  priority: number;
+}
+
+export interface GatewayConfig {
+  port: number;
+  wsPort: number;
+  host: string;
+  dataDir: string;
+  logDir: string;
+  routing: {
+    rules: RoutingRule[];
+    defaultAgent?: string;
+  };
+}