@starlink-awaken/agentmesh 1.4.0 → 1.5.0

package/dist/src/core/agents.default.js

@@ -0,0 +1,154 @@
+// 默认 Agent CLI 配置 — 25+ 内置 Agent 命令映射
+// 这些是兜底默认值，gateway.yaml 中的 agents 配置会覆盖它们
+export const DEFAULT_AGENT_CONFIGS = {
+    'claude-code': {
+        name: 'Claude Code',
+        capabilities: ['code-generation', 'code-review', 'debugging', 'refactoring', 'documentation', 'file-operations'],
+        command: 'claude',
+        args: ['-p']
+    },
+    'openclaw': {
+        name: 'OpenClaw',
+        capabilities: ['browser-automation', 'web-scraping', 'form-filling', 'ui-testing'],
+        command: 'openclaw',
+        args: ['--task']
+    },
+    'opencode': {
+        name: 'OpenCode',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'debugging'],
+        command: 'opencode',
+        args: ['--task']
+    },
+    'gemini': {
+        name: 'Google Gemini CLI',
+        capabilities: ['code-generation', 'multimodal', 'reasoning', 'analysis'],
+        command: 'gemini',
+        args: ['--prompt']
+    },
+    'codex': {
+        name: 'OpenAI Codex',
+        capabilities: ['code-generation', 'code-explanation', 'refactoring'],
+        command: 'codex',
+        args: ['complete']
+    },
+    'github-copilot': {
+        name: 'GitHub Copilot',
+        capabilities: ['code-completion', 'code-suggestions', 'refactoring'],
+        command: 'copilot',
+        args: ['--ask']
+    },
+    'qwen-code': {
+        name: 'Qwen Code',
+        capabilities: ['code-generation', 'code-review', 'multilingual'],
+        command: 'qwen-code',
+        args: ['--task']
+    },
+    'crush': {
+        name: 'CRUSH AI',
+        capabilities: ['code-generation', 'debugging', 'security-analysis'],
+        command: 'crush',
+        args: ['run']
+    },
+    'droid': {
+        name: 'Droid Agent',
+        capabilities: ['android-development', 'mobile-debugging', 'device-control'],
+        command: 'droid',
+        args: ['--task']
+    },
+    'factory': {
+        name: 'Factory AI',
+        capabilities: ['code-generation', 'testing', 'documentation', 'refactoring'],
+        command: 'factory',
+        args: ['--task']
+    },
+    'cursor': {
+        name: 'Cursor',
+        capabilities: ['code-completion', 'code-generation', 'refactoring', 'chat'],
+        command: 'cursor',
+        args: ['--task']
+    },
+    'windsurf': {
+        name: 'Windsurf',
+        capabilities: ['code-generation', 'agentic-coding', 'flow-state'],
+        command: 'windsurf',
+        args: ['--task']
+    },
+    'zed': {
+        name: 'Zed AI',
+        capabilities: ['code-generation', 'collaboration', 'high-performance'],
+        command: 'zed',
+        args: ['--ai-task']
+    },
+    'aider': {
+        name: 'Aider',
+        capabilities: ['git-based-editing', 'code-refactoring', 'multi-file-changes'],
+        command: 'aider',
+        args: ['--message']
+    },
+    'cline': {
+        name: 'Cline',
+        capabilities: ['autonomous-coding', 'file-operations', 'command-execution'],
+        command: 'cline',
+        args: ['--task']
+    },
+    'roo-code': {
+        name: 'Roo Code',
+        capabilities: ['code-generation', 'agentic-mode', 'workspace-awareness'],
+        command: 'roo-code',
+        args: ['--task']
+    },
+    'perplexity': {
+        name: 'Perplexity',
+        capabilities: ['research', 'web-search', 'fact-checking', 'analysis'],
+        command: 'perplexity',
+        args: ['--query']
+    },
+    'grok': {
+        name: 'xAI Grok',
+        capabilities: ['reasoning', 'humor', 'code-generation', 'analysis'],
+        command: 'grok',
+        args: ['--prompt']
+    },
+    'phind': {
+        name: 'Phind',
+        capabilities: ['developer-search', 'code-search', 'documentation-search'],
+        command: 'phind',
+        args: ['--search']
+    },
+    'you': {
+        name: 'You.com AI',
+        capabilities: ['web-search', 'code-search', 'general-assistant'],
+        command: 'you',
+        args: ['--query']
+    },
+    'lepton': {
+        name: 'Lepton AI',
+        capabilities: ['code-generation', 'conversation', 'analysis'],
+        command: 'lepton',
+        args: ['--prompt']
+    },
+    'ollama': {
+        name: 'Ollama',
+        capabilities: ['local-llm', 'code-generation', 'privacy-focused'],
+        command: 'ollama',
+        args: ['run']
+    },
+    'llama': {
+        name: 'Meta Llama',
+        capabilities: ['code-generation', 'reasoning', 'open-source'],
+        command: 'llama',
+        args: ['--prompt']
+    },
+    'mistral': {
+        name: 'Mistral AI',
+        capabilities: ['code-generation', 'reasoning', 'multilingual'],
+        command: 'mistral',
+        args: ['--task']
+    },
+    'anthropic': {
+        name: 'Anthropic CLI',
+        capabilities: ['conversation', 'reasoning', 'code-generation'],
+        command: 'anthropic',
+        args: ['--prompt']
+    }
+};

package/dist/src/core/config.d.ts

@@ -1,3 +1,4 @@
+import type { ModelGatewayConfig } from '../model-gateway/types.js';
 export interface AgentConfig {
     id: string;
     name: string;
@@ -16,6 +17,25 @@ export interface RoutingRule {
     agents?: string[];
     priority: number;
 }
+export interface ModelsSection extends ModelGatewayConfig {
+    defaults?: {
+        circuit_breaker?: {
+            failure_threshold?: number;
+            half_open_max_requests?: number;
+            reset_timeout_ms?: number;
+        };
+        retry?: {
+            base_delay_ms?: number;
+            max_delay_ms?: number;
+            max_retries?: number;
+            retryable_statuses?: number[];
+        };
+        rate_limit?: Record<string, {
+            rpm?: number;
+            enabled?: boolean;
+        }>;
+    };
+}
 export interface GatewayConfig {
     port: number;
     wsPort: number;
@@ -28,6 +48,7 @@ export interface GatewayConfig {
         rules: RoutingRule[];
     };
     agents: AgentConfig[];
+    models?: ModelsSection;
 }
 /**
  * 加载配置文件

package/dist/src/core/context-manager.d.ts

@@ -11,6 +11,8 @@ export declare class ContextManager {
     private memoryCache;
     private baseDir;
     constructor(baseDir?: string);
+    /** 从配置中更新存储路径 */
+    configure(baseDir: string): void;
     /**
      * 创建共享空间
      */

package/dist/src/core/context-manager.js

@@ -8,6 +8,10 @@ export class ContextManager {
     constructor(baseDir = './data/tasks') {
         this.baseDir = baseDir;
     }
+    /** 从配置中更新存储路径 */
+    configure(baseDir) {
+        this.baseDir = baseDir;
+    }
     /**
      * 创建共享空间
      */

package/dist/src/core/gateway.d.ts

@@ -0,0 +1,79 @@
+import type { GatewayConfig } from './config.js';
+import { TaskStore } from './store.js';
+import type { Agent, AgentMessage, Task, EventType } from '../types/index.js';
+export declare function setGateway(instance: GatewayContainer): void;
+export declare function getGateway(): GatewayContainer | null;
+/**
+ * GatewayContainer — 核心实例生命周期管理器
+ * 包装现有模块级单例，提供统一的 init → reload → dispose 生命周期
+ */
+export declare class GatewayContainer {
+    readonly config: GatewayConfig;
+    readonly eventBus: import("./event-bus.js").EventBus;
+    readonly router: import("./router.js").Router;
+    readonly agentRegistry: import("./agent-registry.js").AgentRegistry;
+    readonly taskManager: import("./task-manager.js").TaskManager;
+    readonly contextManager: import("./context-manager.js").ContextManager;
+    readonly vectorStore: import("./vector-store.js").VectorStore;
+    readonly circuitBreakerRegistry: import("../model-gateway/circuit-breaker.js").CircuitBreakerRegistry;
+    readonly scheduler: import("./scheduler.js").Scheduler;
+    readonly pipeline: import("./pipeline.js").AgentPipeline;
+    readonly store: TaskStore;
+    private _started;
+    private _startTime;
+    private _configWatcher;
+    private _fsWatcher;
+    private _modelProviderCount;
+    constructor(config: GatewayConfig);
+    /** 完整初始化：配置 → Agent → 向量存储 */
+    initialize(): Promise<void>;
+    /** 运行时间（秒） */
+    get uptimeSeconds(): number;
+    /** 健康状态快照 */
+    health(): {
+        status: 'ok' | 'degraded' | 'starting';
+        uptime_seconds: number;
+        agents: {
+            total: number;
+            online: number;
+        };
+        models: {
+            total: number;
+        };
+        tasks: {
+            pending: number;
+            running: number;
+            completed: number;
+            failed: number;
+        };
+        circuit_breakers: Record<string, {
+            state: string;
+            failures: number;
+        }>;
+    };
+    /** 设置 Pino 日志桥接（Fastify 创建后调用） */
+    setPinoLogger(pino: any): void;
+    /** 热重载 Agent — 重新加载配置并增量更新注册 */
+    reloadAgents(): Promise<{
+        added: string[];
+        removed: string[];
+        updated: string[];
+    }>;
+    /** 启动配置文件监听（热重载） */
+    startConfigWatcher(configPath: string, debounceMs?: number): void;
+    /** 停止配置文件监听 */
+    stopConfigWatcher(): Promise<void>;
+    submitTask(message: AgentMessage): Promise<Task>;
+    getTask(taskId: string): Task | undefined;
+    getAllTasks(): Task[];
+    getOnlineAgents(): Agent[];
+    getAllAgents(): Agent[];
+    createSpace(metadata?: Record<string, unknown>): Promise<string>;
+    onEvent(eventType: EventType, handler: (event: {
+        type: EventType;
+        data: AgentMessage;
+        timestamp: number;
+    }) => void): () => void;
+    /** 优雅关闭 */
+    dispose(): Promise<void>;
+}

package/dist/src/core/gateway.js

@@ -0,0 +1,223 @@
+import { eventBus } from './event-bus.js';
+import { router } from './router.js';
+import { agentRegistry } from './agent-registry.js';
+import { taskManager } from './task-manager.js';
+import { contextManager } from './context-manager.js';
+import { vectorStore } from './vector-store.js';
+import { initLogger, logger } from './logger.js';
+import { circuitBreakerRegistry } from '../model-gateway/circuit-breaker.js';
+import { TaskStore } from './store.js';
+import { scheduler } from './scheduler.js';
+import { agentPipeline } from './pipeline.js';
+// 全局容器引用（供路由模块等访问）
+let _instance = null;
+export function setGateway(instance) { _instance = instance; }
+export function getGateway() { return _instance; }
+/**
+ * GatewayContainer — 核心实例生命周期管理器
+ * 包装现有模块级单例，提供统一的 init → reload → dispose 生命周期
+ */
+export class GatewayContainer {
+    config;
+    eventBus = eventBus;
+    router = router;
+    agentRegistry = agentRegistry;
+    taskManager = taskManager;
+    contextManager = contextManager;
+    vectorStore = vectorStore;
+    circuitBreakerRegistry = circuitBreakerRegistry;
+    scheduler = scheduler;
+    pipeline = agentPipeline;
+    store;
+    _started = false;
+    _startTime = 0;
+    _configWatcher = null;
+    _fsWatcher = null; // fs.StatsWatcher (类型取决于 @types/node 版本)
+    _modelProviderCount = 0;
+    constructor(config) {
+        this.config = config;
+        this.store = new TaskStore(config.dataDir + '/gateway.db');
+    }
+    /** 完整初始化：配置 → Agent → 向量存储 */
+    async initialize() {
+        if (this._started)
+            return;
+        // Logger 桥接（由 index.ts 在 Fastify 创建后调用 setPino）
+        initLogger({ dir: this.config.logDir, level: this.config.logLevel });
+        // 存储路径
+        this.contextManager.configure(this.config.dataDir + '/tasks');
+        this.vectorStore.configure(this.config.dataDir + '/vector-db');
+        // Task 持久化
+        this.taskManager.useStore(this.store);
+        // Router
+        this.router.configure(this.config.routing.rules, this.config.routing.defaultAgent);
+        // Agent Registry
+        this.agentRegistry.initialize();
+        for (const agent of this.agentRegistry.getAgents()) {
+            this.router.registerAgent(agent);
+        }
+        // VectorStore 异步预热
+        this.vectorStore.initialize().catch(err => {
+            logger.warn('[Gateway] VectorStore init failed:', { error: String(err) });
+        });
+        // 启动定时任务调度器
+        this.scheduler.start();
+        // 缓存静态模型计数
+        this._modelProviderCount = this.config.models ? Object.keys(this.config.models.providers || {}).length : 0;
+        this._started = true;
+        this._startTime = Date.now();
+        logger.info('[Gateway] Container initialized');
+    }
+    /** 运行时间（秒） */
+    get uptimeSeconds() {
+        if (!this._started)
+            return 0;
+        return Math.floor((Date.now() - this._startTime) / 1000);
+    }
+    /** 健康状态快照 */
+    health() {
+        const allAgents = this.router.getAllAgents();
+        const onlineAgents = allAgents.filter(a => a.status === 'online');
+        const allTasks = this.taskManager.getAllTasks();
+        return {
+            status: this._started ? 'ok' : 'starting',
+            uptime_seconds: this.uptimeSeconds,
+            agents: {
+                total: allAgents.length,
+                online: onlineAgents.length,
+            },
+            models: { total: this._modelProviderCount },
+            tasks: {
+                pending: allTasks.filter(t => t.status === 'pending').length,
+                running: allTasks.filter(t => t.status === 'running').length,
+                completed: allTasks.filter(t => t.status === 'completed').length,
+                failed: allTasks.filter(t => t.status === 'failed').length,
+            },
+            circuit_breakers: this.circuitBreakerRegistry.getStatus(),
+        };
+    }
+    /** 设置 Pino 日志桥接（Fastify 创建后调用） */
+    setPinoLogger(pino) {
+        initLogger({ pino, dir: this.config.logDir, level: this.config.logLevel });
+    }
+    /** 热重载 Agent — 重新加载配置并增量更新注册 */
+    async reloadAgents() {
+        const before = new Set(this.agentRegistry.getAgents().map(a => a.id));
+        this.agentRegistry.reload();
+        const after = this.agentRegistry.getAgents();
+        const afterIds = new Set(after.map(a => a.id));
+        const added = [];
+        const removed = [];
+        const updated = [];
+        for (const agent of after) {
+            if (!before.has(agent.id)) {
+                this.router.registerAgent(agent);
+                added.push(agent.id);
+                this.eventBus.publishAgentEvent('agent.registered', {
+                    id: agent.id, type: 'event',
+                    source: 'gateway', target: 'system',
+                    correlation_id: agent.id, timestamp: Date.now(),
+                });
+            }
+            else {
+                // 仅变更时重新注册
+                const existing = this.router.getAgent(agent.id);
+                if (!existing || existing.status !== agent.status || existing.capabilities.join(',') !== agent.capabilities.join(',')) {
+                    this.router.registerAgent(agent);
+                    updated.push(agent.id);
+                }
+            }
+        }
+        for (const oldId of before) {
+            if (!afterIds.has(oldId)) {
+                this.router.unregisterAgent(oldId);
+                removed.push(oldId);
+                this.eventBus.publishAgentEvent('agent.unregistered', {
+                    id: oldId, type: 'event',
+                    source: 'gateway', target: 'system',
+                    correlation_id: oldId, timestamp: Date.now(),
+                });
+            }
+        }
+        if (added.length || removed.length) {
+            logger.info('[Gateway] Agents reloaded', { added, removed, updated: updated.length });
+        }
+        return { added, removed, updated };
+    }
+    /** 启动配置文件监听（热重载） */
+    startConfigWatcher(configPath, debounceMs = 3000) {
+        if (this._configWatcher)
+            return;
+        import('node:fs').then(({ watchFile, existsSync }) => {
+            const handler = () => {
+                setTimeout(async () => {
+                    if (!existsSync(configPath))
+                        return;
+                    logger.info('[Gateway] Config changed, reloading...');
+                    try {
+                        const { reloadConfig, getRoutingRules, getDefaultAgent } = await import('./config.js');
+                        const newConfig = reloadConfig(configPath);
+                        this.contextManager.configure(newConfig.dataDir + '/tasks');
+                        this.vectorStore.configure(newConfig.dataDir + '/vector-db');
+                        const rules = getRoutingRules();
+                        const defaultAgent = getDefaultAgent();
+                        this.router.configure(rules, defaultAgent);
+                        await this.reloadAgents();
+                        logger.info('[Gateway] Config reloaded successfully');
+                    }
+                    catch (err) {
+                        logger.error('[Gateway] Config reload failed:', { error: err.message });
+                    }
+                }, debounceMs);
+            };
+            const watcher = watchFile(configPath, handler);
+            this._fsWatcher = watcher;
+            logger.info('[Gateway] Config watcher started: ' + configPath);
+        });
+        this._configWatcher = setInterval(() => { }, 2_147_483_647);
+    }
+    /** 停止配置文件监听 */
+    async stopConfigWatcher() {
+        if (this._configWatcher) {
+            clearInterval(this._configWatcher);
+            this._configWatcher = null;
+        }
+        if (this._fsWatcher) {
+            const { unwatchFile } = await import('node:fs');
+            unwatchFile(this._fsWatcher);
+            this._fsWatcher = null;
+        }
+    }
+    // —— 委托方法 ——
+    submitTask(message) {
+        return this.taskManager.processTask(message);
+    }
+    getTask(taskId) {
+        return this.taskManager.getTask(taskId);
+    }
+    getAllTasks() {
+        return this.taskManager.getAllTasks();
+    }
+    getOnlineAgents() {
+        return this.router.getOnlineAgents();
+    }
+    getAllAgents() {
+        return this.router.getAllAgents();
+    }
+    createSpace(metadata) {
+        return this.contextManager.createSharedSpace(metadata);
+    }
+    onEvent(eventType, handler) {
+        return this.eventBus.subscribe(eventType, handler);
+    }
+    /** 优雅关闭 */
+    async dispose() {
+        this.stopConfigWatcher();
+        this.scheduler.stop();
+        this.taskManager.purgeCompleted(30);
+        this.store.close();
+        this.eventBus.removeAllListeners();
+        this._started = false;
+        logger.info('[Gateway] Container disposed');
+    }
+}

package/dist/src/core/pipeline.d.ts

@@ -0,0 +1,21 @@
+interface PipelineStep {
+    agentId: string;
+    transform?: (input: string) => string;
+}
+export interface PipelineResult {
+    taskIds: string[];
+    outputs: Array<{
+        agentId: string;
+        result?: unknown;
+        error?: string;
+    }>;
+}
+/**
+ * AgentPipeline — 串联多个 Agent 依次执行
+ * 通过 taskManager.processTask() 委托执行，不重复实现任务生命周期
+ */
+export declare class AgentPipeline {
+    execute(steps: PipelineStep[], initialInput: string): Promise<PipelineResult>;
+}
+export declare const agentPipeline: AgentPipeline;
+export {};

package/dist/src/core/pipeline.js

@@ -0,0 +1,48 @@
+import { taskManager } from './task-manager.js';
+import { router } from './router.js';
+/**
+ * AgentPipeline — 串联多个 Agent 依次执行
+ * 通过 taskManager.processTask() 委托执行，不重复实现任务生命周期
+ */
+export class AgentPipeline {
+    async execute(steps, initialInput) {
+        const taskIds = [];
+        const outputs = [];
+        let currentInput = initialInput;
+        for (const step of steps) {
+            const input = step.transform ? step.transform(currentInput) : currentInput;
+            const message = {
+                id: '', type: 'request', source: 'pipeline', target: step.agentId,
+                correlation_id: '', timestamp: Date.now(),
+                payload: { task: input },
+            };
+            // 验证 Agent 可用
+            const { agentIds } = router.route(message);
+            if (agentIds.length === 0 || !agentIds.includes(step.agentId)) {
+                outputs.push({ agentId: step.agentId, error: `Agent ${step.agentId} not available` });
+                return { taskIds, outputs };
+            }
+            // 委托给 TaskManager 执行完整生命周期
+            let task;
+            try {
+                task = await taskManager.processTask(message);
+            }
+            catch (err) {
+                outputs.push({ agentId: step.agentId, error: err.message });
+                return { taskIds, outputs };
+            }
+            taskIds.push(task.id);
+            if (task.status === 'completed' && task.result !== undefined) {
+                const resultStr = typeof task.result === 'string' ? task.result : JSON.stringify(task.result);
+                outputs.push({ agentId: step.agentId, result: task.result });
+                currentInput = resultStr;
+            }
+            else {
+                outputs.push({ agentId: step.agentId, error: task.error?.message || 'Unknown error' });
+                break;
+            }
+        }
+        return { taskIds, outputs };
+    }
+}
+export const agentPipeline = new AgentPipeline();

package/dist/src/core/router.d.ts

@@ -1,4 +1,5 @@
-import type { Agent, RoutingRule, AgentMessage } from '../types/index.js';
+import type { Agent, AgentMessage } from '../types/index.js';
+import type { RoutingRule } from './config.js';
 export declare class Router {
     private rules;
     private agents;

package/dist/src/core/scheduler.d.ts

@@ -0,0 +1,28 @@
+import type { AgentMessage } from '../types/index.js';
+interface ScheduledTask {
+    id: string;
+    name: string;
+    cron: string;
+    message: AgentMessage;
+    enabled: boolean;
+    lastRun?: number;
+    nextRun?: number | null;
+}
+export declare class Scheduler {
+    private jobs;
+    private timer;
+    /** 添加定时任务 */
+    add(name: string, cronExpr: string, message: AgentMessage): string;
+    /** 移除定时任务 */
+    remove(id: string): boolean;
+    /** 列出所有定时任务 */
+    list(): ScheduledTask[];
+    /** 启动调度器 */
+    start(intervalMs?: number): void;
+    /** 停止调度器 */
+    stop(): void;
+    private _tick;
+    private _nextRun;
+}
+export declare const scheduler: Scheduler;
+export {};