@starlink-awaken/agentmesh 1.0.2 → 1.0.3

package/dist/core/router.d.ts

@@ -0,0 +1,46 @@
+import type { Agent, RoutingRule, AgentMessage } from '../types/index.js';
+export declare class Router {
+    private rules;
+    private agents;
+    private defaultAgent?;
+    /**
+     * 配置路由规则
+     */
+    configure(rules: RoutingRule[], defaultAgent?: string): void;
+    /**
+     * 注册 Agent
+     */
+    registerAgent(agent: Agent): void;
+    /**
+     * 注销 Agent
+     */
+    unregisterAgent(agentId: string): void;
+    /**
+     * 获取所有在线 Agent
+     */
+    getOnlineAgents(): Agent[];
+    /**
+     * 路由任务到合适的 Agent
+     */
+    route(message: AgentMessage): {
+        agentIds: string[];
+        strategy: 'direct' | 'broadcast';
+    };
+    /**
+     * 检查任务是否匹配路由关键词
+     */
+    private matchesRule;
+    /**
+     * 检查 Agent 是否在线
+     */
+    private isAgentOnline;
+    /**
+     * 获取 Agent 信息
+     */
+    getAgent(agentId: string): Agent | undefined;
+    /**
+     * 获取所有 Agent
+     */
+    getAllAgents(): Agent[];
+}
+export declare const router: Router;

package/dist/core/router.js

@@ -0,0 +1,90 @@
+export class Router {
+    rules = [];
+    agents = new Map();
+    defaultAgent;
+    /**
+     * 配置路由规则
+     */
+    configure(rules, defaultAgent) {
+        // 按优先级排序
+        this.rules = [...rules].sort((a, b) => b.priority - a.priority);
+        this.defaultAgent = defaultAgent;
+    }
+    /**
+     * 注册 Agent
+     */
+    registerAgent(agent) {
+        this.agents.set(agent.id, agent);
+    }
+    /**
+     * 注销 Agent
+     */
+    unregisterAgent(agentId) {
+        this.agents.delete(agentId);
+    }
+    /**
+     * 获取所有在线 Agent
+     */
+    getOnlineAgents() {
+        return Array.from(this.agents.values()).filter(a => a.status === 'online');
+    }
+    /**
+     * 路由任务到合适的 Agent
+     */
+    route(message) {
+        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' };
+    }
+    /**
+     * 检查任务是否匹配路由关键词
+     */
+    matchesRule(task, keywords) {
+        const lowerTask = task.toLowerCase();
+        return keywords.some(keyword => lowerTask.includes(keyword.toLowerCase()));
+    }
+    /**
+     * 检查 Agent 是否在线
+     */
+    isAgentOnline(agentId) {
+        const agent = this.agents.get(agentId);
+        return agent?.status === 'online';
+    }
+    /**
+     * 获取 Agent 信息
+     */
+    getAgent(agentId) {
+        return this.agents.get(agentId);
+    }
+    /**
+     * 获取所有 Agent
+     */
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+}
+export const router = new Router();

package/dist/core/task-manager.d.ts

@@ -0,0 +1,41 @@
+import type { Task, AgentMessage, Error } from '../types/index.js';
+export declare class TaskManager {
+    private tasks;
+    /**
+     * 创建新任务
+     */
+    createTask(request: AgentMessage): Promise<Task>;
+    /**
+     * 分配任务到 Agent
+     */
+    assignTask(taskId: string, agentIds: string[]): Task | null;
+    /**
+     * 开始执行任务
+     */
+    startTask(taskId: string): Task | null;
+    /**
+     * 完成任务
+     */
+    completeTask(taskId: string, result: unknown): Task | null;
+    /**
+     * 任务失败
+     */
+    failTask(taskId: string, error: Error): Task | null;
+    /**
+     * 获取任务
+     */
+    getTask(taskId: string): Task | undefined;
+    /**
+     * 获取所有任务
+     */
+    getAllTasks(): Task[];
+    /**
+     * 处理任务
+     */
+    processTask(message: AgentMessage): Promise<Task>;
+    /**
+     * 执行任务
+     */
+    private executeTask;
+}
+export declare const taskManager: TaskManager;

package/dist/core/task-manager.js

@@ -0,0 +1,197 @@
+import { v4 as uuidv4 } from 'uuid';
+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 {
+    tasks = new Map();
+    /**
+     * 创建新任务
+     */
+    async createTask(request) {
+        const taskId = uuidv4();
+        const 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, agentIds) {
+        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) {
+        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, result) {
+        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, error) {
+        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) {
+        return this.tasks.get(taskId);
+    }
+    /**
+     * 获取所有任务
+     */
+    getAllTasks() {
+        return Array.from(this.tasks.values());
+    }
+    /**
+     * 处理任务
+     */
+    async processTask(message) {
+        // 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;
+    }
+    /**
+     * 执行任务
+     */
+    async executeTask(task, agentIds, strategy) {
+        const results = {};
+        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) {
+                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) {
+                    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();

package/dist/core/vector-store.d.ts

@@ -0,0 +1,37 @@
+import type { AgentMessage } from '../types/index.js';
+export declare class VectorStore {
+    private client;
+    private collection;
+    private isInitialized;
+    private baseDir;
+    constructor(baseDir?: string);
+    /**
+     * 初始化向量数据库
+     */
+    initialize(): Promise<void>;
+    /**
+     * 添加消息到向量存储
+     */
+    addMessage(spaceId: string, message: AgentMessage): Promise<void>;
+    /**
+     * 搜索相似上下文
+     */
+    searchSimilar(spaceId: string, query: string, limit?: number): Promise<AgentMessage[]>;
+    /**
+     * 获取空间的向量数量
+     */
+    getCount(spaceId: string): Promise<number>;
+    /**
+     * 删除空间的向量
+     */
+    deleteSpace(spaceId: string): Promise<void>;
+    /**
+     * 将消息转换为可向量化的文本
+     */
+    private messageToText;
+    /**
+     * 检查是否可用
+     */
+    isAvailable(): boolean;
+}
+export declare const vectorStore: VectorStore;

package/dist/core/vector-store.js

@@ -0,0 +1,175 @@
+import { ChromaClient } from 'chromadb';
+export class VectorStore {
+    client = null;
+    collection = null;
+    isInitialized = false;
+    baseDir;
+    constructor(baseDir = './data/vector-db') {
+        this.baseDir = baseDir;
+    }
+    /**
+     * 初始化向量数据库
+     */
+    async initialize() {
+        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, message) {
+        if (!this.isInitialized || !this.collection) {
+            console.warn('[VectorStore] Not initialized, skipping add');
+            return;
+        }
+        const entry = {
+            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, query, limit = 5) {
+        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 = [];
+            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,
+                            type: 'event',
+                            source: metadata.source,
+                            target: 'search',
+                            correlation_id: '',
+                            timestamp: metadata.timestamp,
+                            payload: {
+                                task: results.documents[0][i] || ''
+                            }
+                        });
+                    }
+                }
+            }
+            return messages;
+        }
+        catch (error) {
+            console.error('[VectorStore] Search failed:', error);
+            return [];
+        }
+    }
+    /**
+     * 获取空间的向量数量
+     */
+    async getCount(spaceId) {
+        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) {
+        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);
+        }
+    }
+    /**
+     * 将消息转换为可向量化的文本
+     */
+    messageToText(message) {
+        const parts = [];
+        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() {
+        return this.isInitialized;
+    }
+}
+export const vectorStore = new VectorStore();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,73 @@
+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/dist/routes/api.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from 'fastify';
+export declare function apiRoutes(fastify: FastifyInstance): Promise<void>;