@starlink-awaken/agentmesh 1.0.2 → 1.2.0

package/dist/src/model-gateway/routes.js

@@ -0,0 +1,172 @@
+import { resolveProvider, getConfig } from './router.js';
+import { callChatCompletions, callResponsesApi } from './providers.js';
+import { getQuotaSummary, probeQuota } from './quota.js';
+import { circuitBreakerRegistry } from './circuit-breaker.js';
+import { checkAllProviders } from './health.js';
+export async function modelGatewayRoutes(fastify) {
+    // 健康检查 + 配额总览
+    fastify.get('/model-gateway/health', async (_req, _reply) => {
+        const quota = await probeQuota();
+        return {
+            status: 'ok',
+            timestamp: Date.now(),
+            providers_available: Array.from(quota.entries())
+                .filter(([_, info]) => info.available)
+                .map(([name, info]) => ({ name, summary: info.summary })),
+            providers_unavailable: Array.from(quota.entries())
+                .filter(([_, info]) => !info.available)
+                .map(([name, info]) => ({ name, summary: info.summary })),
+        };
+    });
+    // 配额详情
+    fastify.get('/model-gateway/quota', async (_req, reply) => {
+        await probeQuota();
+        reply.send(getQuotaSummary());
+    });
+    // 可用模型列表
+    fastify.get('/v1/models', async (_req, reply) => {
+        const { getConfig } = await import('./router.js');
+        const cfg = getConfig();
+        const models = [];
+        if (cfg) {
+            for (const [providerName, providerCfg] of Object.entries(cfg.providers)) {
+                const providerModels = providerCfg.models || [providerName];
+                for (const model of providerModels) {
+                    models.push({ id: model, object: 'model', owned_by: providerName });
+                }
+            }
+        }
+        reply.send({ object: 'list', data: models });
+    });
+    // POST /v1/chat/completions — 标准 OpenAI 兼容端点
+    fastify.post('/v1/chat/completions', async (request, reply) => {
+        const body = request.body;
+        if (!body || !body.messages) {
+            return reply.code(400).send({ error: { message: 'messages is required' } });
+        }
+        const model = body.model || 'deepseek-chat';
+        const provider = resolveProvider(model);
+        if (!provider) {
+            return reply.code(503).send({
+                error: { message: 'No available provider. Check API keys and quota.' },
+            });
+        }
+        console.log(`[ModelGW] ${model} → ${provider.name} (${body.stream ? 'stream' : 'sync'})`);
+        try {
+            const upstreamResp = await callChatCompletions(provider, {
+                model,
+                messages: body.messages,
+                stream: body.stream,
+                temperature: body.temperature,
+                max_tokens: body.max_tokens,
+                tools: body.tools,
+                tool_choice: body.tool_choice,
+            });
+            if (!upstreamResp.ok && upstreamResp.status !== 200) {
+                const errText = await upstreamResp.text();
+                console.error(`[ModelGW] ${provider.name} error ${upstreamResp.status}: ${errText.slice(0, 200)}`);
+                return reply.code(upstreamResp.status).send({
+                    error: { message: `${provider.name}: ${errText.slice(0, 500)}` },
+                });
+            }
+            if (body.stream) {
+                return reply.headers({
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                }).send(upstreamResp.body);
+            }
+            const data = await upstreamResp.json();
+            reply.send(data);
+        }
+        catch (err) {
+            console.error(`[ModelGW] Error calling ${provider.name}:`, err.message);
+            reply.code(502).send({
+                error: { message: `Provider error: ${err.message}` },
+            });
+        }
+    });
+    // POST /v1/responses — Codex Desktop Responses API 适配
+    fastify.post('/v1/responses', async (request, reply) => {
+        const body = request.body;
+        if (!body || !body.input) {
+            return reply.code(400).send({ error: { message: 'input is required' } });
+        }
+        const model = body.model || 'deepseek-chat';
+        const provider = resolveProvider(model);
+        if (!provider) {
+            return reply.code(503).send({
+                error: { message: 'No available provider. Check API keys and quota.' },
+            });
+        }
+        console.log(`[ModelGW:Responses] ${model} → ${provider.name}`);
+        try {
+            const upstreamResp = await callResponsesApi(provider, body);
+            if (!upstreamResp.ok) {
+                const errText = await upstreamResp.text();
+                return reply.code(upstreamResp.status).send({
+                    error: { message: `${provider.name}: ${errText.slice(0, 500)}` },
+                });
+            }
+            if (body.stream) {
+                return reply.headers({
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                }).send(upstreamResp.body);
+            }
+            // 将 Chat Completions 响应转回 Responses API 格式
+            const ccData = (await upstreamResp.json());
+            const choice = ccData.choices?.[0];
+            const responsesData = {
+                id: ccData.id,
+                object: 'response',
+                model: ccData.model,
+                output: [
+                    {
+                        type: 'message',
+                        role: 'assistant',
+                        content: [
+                            {
+                                type: 'output_text',
+                                text: choice?.message?.content || '',
+                            },
+                        ],
+                    },
+                ],
+                usage: ccData.usage,
+            };
+            reply.send(responsesData);
+        }
+        catch (err) {
+            console.error(`[ModelGW:Responses] Error:`, err.message);
+            reply.code(502).send({
+                error: { message: `Provider error: ${err.message}` },
+            });
+        }
+    });
+    // Provider 健康检查 + 熔断器状态
+    fastify.get('/model-gateway/health/:provider', async (request, reply) => {
+        const { provider } = request.params;
+        const cfg = getConfig();
+        if (!cfg || !cfg.providers[provider]) {
+            return reply.code(404).send({ error: { message: `Provider '${provider}' not found` } });
+        }
+        const results = await checkAllProviders(cfg);
+        const result = results.find(r => r.provider === provider);
+        if (!result) {
+            return reply.code(404).send({ error: { message: `Health check not available for '${provider}'` } });
+        }
+        reply.send({ ...result, circuit_breaker: circuitBreakerRegistry.getStatus() });
+    });
+    // 全部 Provider 健康检查
+    fastify.get('/model-gateway/health/all', async (_request, reply) => {
+        const cfg = getConfig();
+        if (!cfg)
+            return reply.code(503).send({ error: { message: 'Model gateway not configured' } });
+        const results = await checkAllProviders(cfg);
+        reply.send({
+            providers: results,
+            circuit_breaker: circuitBreakerRegistry.getStatus(),
+        });
+    });
+}

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

@@ -0,0 +1,47 @@
+export interface ModelProviderConfig {
+    base_url: string;
+    api_key_env?: string;
+    api_key?: string;
+    models?: string[];
+}
+export interface ModelGatewayConfig {
+    default_model: string;
+    providers: Record<string, ModelProviderConfig>;
+    fallback_chain: string[];
+    model_routing: Record<string, string[]>;
+}
+export interface ResolvedProvider {
+    name: string;
+    base_url: string;
+    api_key: string;
+}
+export interface QuotaInfo {
+    provider: string;
+    available: boolean;
+    usedPercent?: number;
+    balance?: number;
+    summary: string;
+}
+export interface ChatCompletionRequest {
+    model: string;
+    messages: Array<{
+        role: string;
+        content: string | any;
+    }>;
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+    tools?: any[];
+    tool_choice?: any;
+}
+export interface ResponsesRequest {
+    model: string;
+    input: Array<{
+        role?: string;
+        type?: string;
+        content?: string | any[];
+    }>;
+    stream?: boolean;
+    tools?: any[];
+    instructions?: string;
+}

package/dist/src/model-gateway/types.js

@@ -0,0 +1 @@
+// 模型网关类型定义

package/dist/src/routes/api.d.ts

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

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

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

package/dist/src/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/src/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/src/types/index.js

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

package/dist/tests/core/context-manager.test.d.ts

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

package/dist/tests/core/context-manager.test.js

@@ -0,0 +1,35 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { ContextManager } from '../../src/core/context-manager.js';
+describe('context manager', () => {
+    let cm;
+    beforeEach(() => {
+        cm = new ContextManager();
+    });
+    test('creates shared space with id', async () => {
+        const spaceId = await cm.createSharedSpace({ name: 'test' });
+        expect(spaceId).toBeDefined();
+        expect(typeof spaceId).toBe('string');
+        expect(spaceId.length).toBeGreaterThan(0);
+    });
+    test('retrieves created shared space', async () => {
+        const spaceId = await cm.createSharedSpace({ name: 'test' });
+        const space = await cm.getSharedSpace(spaceId);
+        expect(space).toBeDefined();
+        expect(space.shared_space_id).toBe(spaceId);
+    });
+    test('returns null for non-existent space', async () => {
+        const space = await cm.getSharedSpace('non-existent-id');
+        expect(space).toBeNull();
+    });
+    test('different calls create different space ids', async () => {
+        const id1 = await cm.createSharedSpace({});
+        const id2 = await cm.createSharedSpace({});
+        expect(id1).not.toBe(id2);
+    });
+    test('space stores metadata', async () => {
+        const metadata = { project: 'test', version: 1 };
+        const spaceId = await cm.createSharedSpace(metadata);
+        const space = await cm.getSharedSpace(spaceId);
+        expect(space.metadata).toEqual(metadata);
+    });
+});

package/dist/tests/core/router.test.d.ts

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

package/dist/tests/core/router.test.js

@@ -0,0 +1,79 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import { Router } from '../../src/core/router.js';
+function makeAgent(id, caps, status = 'online') {
+    return { id, name: `Agent ${id}`, type: 'process', capabilities: caps, status, lastSeen: Date.now() };
+}
+describe('agent router', () => {
+    let router;
+    beforeEach(() => {
+        router = new Router();
+    });
+    test('registers and retrieves agents', () => {
+        router.registerAgent(makeAgent('test-agent', ['code-generation']));
+        expect(router.getAgent('test-agent').id).toBe('test-agent');
+    });
+    test('unregisters agents', () => {
+        router.registerAgent(makeAgent('test-agent', ['code-generation']));
+        router.unregisterAgent('test-agent');
+        expect(router.getAgent('test-agent')).toBeUndefined();
+    });
+    test('filters offline from online agents', () => {
+        router.registerAgent(makeAgent('a', ['x'], 'online'));
+        router.registerAgent(makeAgent('b', ['x'], 'offline'));
+        router.registerAgent(makeAgent('c', ['x'], 'online'));
+        expect(router.getOnlineAgents()).toHaveLength(2);
+    });
+    test('routes by keyword match', () => {
+        const rules = [
+            { name: 'review', keywords: ['review', 'code review'], agent: 'review-bot', priority: 15 },
+            { name: 'code', keywords: ['write code'], agent: 'code-bot', priority: 10 },
+        ];
+        router.configure(rules, 'fallback');
+        router.registerAgent(makeAgent('review-bot', ['review']));
+        router.registerAgent(makeAgent('code-bot', ['coding']));
+        router.registerAgent(makeAgent('fallback', ['general']));
+        const msg = {
+            id: '1', type: 'request', source: 'test', target: 'gateway',
+            correlation_id: '1', timestamp: Date.now(),
+            payload: { task: 'please review this code' },
+        };
+        const result = router.route(msg);
+        expect(result.agentIds).toContain('review-bot');
+    });
+    test('higher priority wins when keywords overlap', () => {
+        const rules = [
+            { name: 'low', keywords: ['code'], agent: 'low', priority: 5 },
+            { name: 'high', keywords: ['code'], agent: 'high', priority: 20 },
+        ];
+        router.configure(rules);
+        router.registerAgent(makeAgent('low', ['general']));
+        router.registerAgent(makeAgent('high', ['general']));
+        const msg = {
+            id: '1', type: 'request', source: 'test', target: 'gateway',
+            correlation_id: '1', timestamp: Date.now(),
+            payload: { task: 'help with code' },
+        };
+        expect(router.route(msg).agentIds).toContain('high');
+    });
+    test('falls back to default when no rule matches', () => {
+        router.configure([], 'default-bot');
+        router.registerAgent(makeAgent('default-bot', ['general']));
+        const msg = {
+            id: '1', type: 'request', source: 'test', target: 'gateway',
+            correlation_id: '1', timestamp: Date.now(),
+            payload: { task: 'something unrelated' },
+        };
+        expect(router.route(msg).agentIds).toContain('default-bot');
+    });
+    test('skips offline agents and uses fallback', () => {
+        router.configure([{ name: 'code', keywords: ['code'], agent: 'offline-bot', priority: 10 }], 'online-fallback');
+        router.registerAgent(makeAgent('offline-bot', ['coding'], 'offline'));
+        router.registerAgent(makeAgent('online-fallback', ['general'], 'online'));
+        const msg = {
+            id: '1', type: 'request', source: 'test', target: 'gateway',
+            correlation_id: '1', timestamp: Date.now(),
+            payload: { task: 'write code' },
+        };
+        expect(router.route(msg).agentIds).toContain('online-fallback');
+    });
+});

package/dist/tests/model-gateway/circuit-breaker.test.d.ts

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