@starlink-awaken/agentmesh 1.0.2 → 1.2.0

package/dist/src/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/src/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/src/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/src/index.d.ts

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

package/dist/src/index.js

@@ -0,0 +1,105 @@
+import Fastify from 'fastify';
+import cors from '@fastify/cors';
+import { apiRoutes } from './routes/api.js';
+import { websocketRoutes } from './routes/websocket.js';
+import { modelGatewayRoutes } from './model-gateway/routes.js';
+import { initModelRouter } from './model-gateway/router.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';
+import { circuitBreakerRegistry } from './model-gateway/circuit-breaker.js';
+import { configureRetry } from './model-gateway/retry.js';
+import { initRateLimiter } from './model-gateway/rate-limit.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);
+    await fastify.register(modelGatewayRoutes);
+    // 初始化模型网关
+    const modelsConfig = config.models;
+    if (modelsConfig) {
+        // 配置熔断器
+        const cbDefaults = modelsConfig.defaults?.circuit_breaker;
+        if (cbDefaults) {
+            for (const [name] of Object.entries(modelsConfig.providers || {})) {
+                circuitBreakerRegistry.configure(name, cbDefaults);
+            }
+        }
+        // 配置重试
+        const retryDefaults = modelsConfig.defaults?.retry;
+        if (retryDefaults) {
+            configureRetry(retryDefaults);
+        }
+        // 初始化限流器
+        initRateLimiter();
+        initModelRouter(modelsConfig);
+        console.log(`[ModelGW] Initialized: ${Object.keys(modelsConfig.providers || {}).length} providers, fallback: ${modelsConfig.fallback_chain?.join(' → ')}`);
+        // 配额预热（异步，不阻塞启动）
+        import('./model-gateway/quota.js').then(m => m.probeQuota()).catch(() => { });
+        console.log('[ModelGW] Quota pre-warming started (background)');
+    }
+    // 初始化组件
+    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 Mesh Gateway                      ║
+╠═══════════════════════════════════════════════════╣
+║  HTTP:       http://${config.host}:${config.port}                  ║
+║  WebSocket:  ws://${config.host}:${config.port}/ws                 ║
+║  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           ║
+╠═══════════════════════════════════════════════════╣
+║  Model GW:   http://${config.host}:${config.port}/v1/chat/completions ║
+║  Models:     http://${config.host}:${config.port}/v1/models        ║
+║  Quota:      http://${config.host}:${config.port}/model-gateway/quota ║
+╚═══════════════════════════════════════════════════╝
+    `);
+        // 订阅事件日志
+        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/src/model-gateway/circuit-breaker.d.ts

@@ -0,0 +1,21 @@
+export type CircuitState = 'CLOSED' | 'OPEN' | 'HALF_OPEN';
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeoutMs: number;
+    halfOpenMaxRequests: number;
+}
+export declare class CircuitBreakerRegistry {
+    private circuits;
+    private configs;
+    configure(provider: string, config?: Partial<CircuitBreakerConfig>): void;
+    getState(provider: string): CircuitState;
+    isOpen(provider: string): boolean;
+    canRequest(provider: string): boolean;
+    recordSuccess(provider: string): void;
+    recordFailure(provider: string): void;
+    getStatus(): Record<string, {
+        state: CircuitState;
+        failures: number;
+    }>;
+}
+export declare const circuitBreakerRegistry: CircuitBreakerRegistry;

package/dist/src/model-gateway/circuit-breaker.js

@@ -0,0 +1,86 @@
+const DEFAULTS = {
+    failureThreshold: 3,
+    resetTimeoutMs: 30_000,
+    halfOpenMaxRequests: 1,
+};
+export class CircuitBreakerRegistry {
+    circuits = new Map();
+    configs = new Map();
+    configure(provider, config = {}) {
+        this.configs.set(provider, { ...DEFAULTS, ...config });
+    }
+    getState(provider) {
+        const entry = this.circuits.get(provider);
+        if (!entry)
+            return 'CLOSED';
+        // OPEN → HALF_OPEN after timeout
+        if (entry.state === 'OPEN') {
+            const cfg = this.configs.get(provider) || DEFAULTS;
+            if (Date.now() - entry.lastFailureTime >= cfg.resetTimeoutMs) {
+                entry.state = 'HALF_OPEN';
+                entry.halfOpenCount = 0;
+            }
+        }
+        return entry.state;
+    }
+    isOpen(provider) {
+        return this.getState(provider) === 'OPEN';
+    }
+    canRequest(provider) {
+        const state = this.getState(provider);
+        if (state === 'CLOSED')
+            return true;
+        if (state === 'OPEN')
+            return false;
+        // HALF_OPEN: allow limited probe requests
+        const cfg = this.configs.get(provider) || DEFAULTS;
+        const entry = this.circuits.get(provider);
+        return (entry?.halfOpenCount ?? 0) < cfg.halfOpenMaxRequests;
+    }
+    recordSuccess(provider) {
+        const entry = this.circuits.get(provider);
+        if (!entry)
+            return;
+        if (entry.state === 'HALF_OPEN') {
+            // Half-open success → reset to closed
+            this.circuits.delete(provider);
+        }
+        else {
+            // Reset failure count on success in closed state
+            entry.failures = 0;
+        }
+    }
+    recordFailure(provider) {
+        let entry = this.circuits.get(provider);
+        if (!entry) {
+            entry = {
+                failures: 0,
+                lastFailureTime: 0,
+                state: 'CLOSED',
+                halfOpenCount: 0,
+            };
+            this.circuits.set(provider, entry);
+        }
+        const cfg = this.configs.get(provider) || DEFAULTS;
+        if (entry.state === 'HALF_OPEN') {
+            // Half-open failure → back to open
+            entry.state = 'OPEN';
+            entry.lastFailureTime = Date.now();
+            entry.halfOpenCount = 0;
+            return;
+        }
+        entry.failures++;
+        entry.lastFailureTime = Date.now();
+        if (entry.failures >= cfg.failureThreshold) {
+            entry.state = 'OPEN';
+        }
+    }
+    getStatus() {
+        const status = {};
+        for (const [name, entry] of this.circuits) {
+            status[name] = { state: this.getState(name), failures: entry.failures };
+        }
+        return status;
+    }
+}
+export const circuitBreakerRegistry = new CircuitBreakerRegistry();

package/dist/src/model-gateway/health.d.ts

@@ -0,0 +1,12 @@
+import type { ModelGatewayConfig, ResolvedProvider } from './types.js';
+interface ProviderHealth {
+    provider: string;
+    status: 'healthy' | 'unhealthy' | 'unknown';
+    latency_ms: number;
+    circuit: string;
+    error?: string;
+    checked_at: string;
+}
+export declare function checkProviderHealth(provider: ResolvedProvider): Promise<ProviderHealth>;
+export declare function checkAllProviders(config: ModelGatewayConfig): Promise<ProviderHealth[]>;
+export {};