@starlink-awaken/agentmesh 1.0.2 → 1.0.3

package/dist/routes/api.js

@@ -0,0 +1,128 @@
+import { v4 as uuidv4 } from 'uuid';
+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) {
+    // 健康检查
+    fastify.get('/health', async (_request, _reply) => {
+        return {
+            status: 'ok',
+            timestamp: Date.now(),
+            agents: router.getAllAgents().map(a => ({
+                id: a.id,
+                name: a.name,
+                status: a.status
+            }))
+        };
+    });
+    // 提交任务
+    fastify.post('/tasks', async (request, reply) => {
+        const body = request.body || {};
+        const message = {
+            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) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            reply.code(500).send({
+                error: {
+                    code: 'TASK_FAILED',
+                    message: errorMessage
+                }
+            });
+        }
+    });
+    // 获取任务状态
+    fastify.get('/tasks/:taskId', async (request, reply) => {
+        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, reply) => {
+        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('/spaces', async (request, reply) => {
+        const { metadata } = request.body || {};
+        const spaceId = await contextManager.createSharedSpace(metadata);
+        reply.code(201).send({ space_id: spaceId });
+    });
+    // 获取共享空间
+    fastify.get('/spaces/:spaceId', async (request, reply) => {
+        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, reply) => {
+        const agents = router.getAllAgents();
+        reply.send(agents);
+    });
+    // 注册 Agent
+    fastify.post('/agents', async (request, reply) => {
+        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/dist/routes/websocket.d.ts

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

package/dist/routes/websocket.js

@@ -0,0 +1,64 @@
+import { v4 as uuidv4 } from 'uuid';
+import { taskManager } from '../core/task-manager.js';
+import { agentRegistry } from '../core/agent-registry.js';
+export async function websocketRoutes(fastify) {
+    const clients = new Map();
+    // SSE 端点 - 用于实时任务更新
+    fastify.get('/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('/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/dist/types/index.d.ts

@@ -0,0 +1,71 @@
+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;
+    };
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+// Agent Gateway 通信协议类型定义

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@starlink-awaken/agentmesh",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Unified Agent Gateway - Multi-Agent Scheduler and Router",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",