@starlink-awaken/agentmesh 1.3.0 → 1.4.0

package/dist/src/cli.js

@@ -7,7 +7,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { resolve, dirname, join } from 'node:path';
 import { initLogger } from './core/logger.js';
 const PROJECT_ROOT = resolve(dirname(import.meta.dir), '..');
-const VERSION = '1.3.0';
+const VERSION = '1.4.0';
 const BANNER = `
    █████╗  ██████╗ ███████╗███╗   ██╗████████╗
   ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝

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

@@ -21,9 +21,9 @@ export function recordRequest(log) {
         m.lastError = log.error;
         m.lastErrorTime = log.timestamp;
     }
-    recentRequests.unshift(log);
+    recentRequests.push(log);
     if (recentRequests.length > MAX_RECENT)
-        recentRequests.pop();
+        recentRequests.shift();
 }
 export function getMetrics() {
     const providers = {};
@@ -46,7 +46,7 @@ export function getMetrics() {
         total_requests: totalRequests,
         total_failures: totalFailures,
         providers,
-        recent: recentRequests.slice(0, 20).map(r => ({
+        recent: recentRequests.slice(-20).reverse().map(r => ({
             time: new Date(r.timestamp).toISOString(),
             model: r.model,
             provider: r.provider,

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

@@ -1,4 +1,3 @@
 import type { ChatCompletionRequest, ResolvedProvider } from './types.js';
 export declare function callChatCompletions(provider: ResolvedProvider, request: ChatCompletionRequest): Promise<Response>;
 export declare function callResponsesApi(provider: ResolvedProvider, body: Record<string, any>): Promise<Response>;
-export declare function buildStreamingResponse(upstreamResp: Response): Response;

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

@@ -1,6 +1,5 @@
 import { circuitBreakerRegistry } from './circuit-breaker.js';
 import { withRetry, isRetryable } from './retry.js';
-// 所有目标 Provider 都兼容 OpenAI API 格式，统一客户端即可
 export async function callChatCompletions(provider, request) {
     const { base_url, api_key, name: providerName } = provider;
     const { model, messages, stream, temperature, max_tokens, tools, tool_choice } = request;
@@ -19,22 +18,18 @@ export async function callChatCompletions(provider, request) {
         'Content-Type': 'application/json',
         Authorization: `Bearer ${api_key}`,
     };
-    // OpenRouter 需要额外的头部
     if (providerName === 'openrouter') {
         headers['HTTP-Referer'] = 'http://127.0.0.1:3000';
         headers['X-Title'] = 'Agent Mesh Gateway';
     }
     const url = `${base_url.replace(/\/$/, '')}/chat/completions`;
-    // 熔断器检查
     if (!circuitBreakerRegistry.canRequest(providerName)) {
         throw new Error(`Circuit breaker open for ${providerName}`);
     }
     try {
         const resp = await withRetry(providerName, async () => {
             const r = await fetch(url, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
+                method: 'POST', headers, body: JSON.stringify(body),
                 signal: AbortSignal.timeout(120_000),
             });
             return r;
@@ -42,7 +37,6 @@ export async function callChatCompletions(provider, request) {
             console.warn(`[Retry] ${providerName} attempt ${attempt} after ${status} — retrying in ${delayMs}ms`);
         });
         if (!resp.ok && isRetryable(resp.status)) {
-            // Retry logic already handled in withRetry, but if we get here after max retries:
             circuitBreakerRegistry.recordFailure(providerName);
         }
         else if (resp.ok) {
@@ -59,37 +53,236 @@ export async function callChatCompletions(provider, request) {
     }
 }
 export async function callResponsesApi(provider, body) {
-    // Responses API → Chat Completions 转换
-    const messages = convertResponsesInputToMessages(body.input || []);
+    const messages = convertInputToMessages(body.input || []);
     if (body.instructions) {
         messages.unshift({ role: 'system', content: body.instructions });
     }
-    return callChatCompletions(provider, {
+    // 转换 tools 定义（Codex 的 tool schema → OpenAI format）
+    const tools = convertToolSchemas(body.tools);
+    const chatResp = await callChatCompletions(provider, {
         model: body.model,
         messages,
         stream: body.stream,
-        tools: body.tools,
+        tools,
+        tool_choice: body.tool_choice,
+    });
+    // 非流式：直接转换响应
+    if (!body.stream) {
+        const ccData = (await chatResp.json());
+        return new Response(JSON.stringify(convertChatToResponses(ccData)), {
+            status: 200,
+            headers: { 'Content-Type': 'application/json' },
+        });
+    }
+    // 流式：解析 SSE → 转换 → 重新打包 SSE
+    const transformed = transformSSEStream(chatResp.body);
+    return new Response(transformed, {
+        status: 200,
+        headers: { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache' },
     });
 }
-function convertResponsesInputToMessages(input) {
+function convertInputToMessages(input) {
     const messages = [];
     for (const item of input) {
-        if (item.role === 'system') {
-            messages.push({ role: 'system', content: extractTextContent(item.content) });
-        }
-        else if (item.role === 'user') {
-            messages.push({ role: 'user', content: extractTextContent(item.content) });
-        }
-        else if (item.role === 'assistant') {
-            messages.push({ role: 'assistant', content: extractTextContent(item.content) });
-        }
-        else if (item.type === 'message') {
-            const role = item.role || 'user';
-            messages.push({ role, content: extractTextContent(item.content) });
+        switch (item.type || item.role) {
+            // 标准消息类型
+            case 'message':
+                messages.push({ role: item.role || 'user', content: extractTextContent(item.content) });
+                break;
+            case 'function_call': {
+                messages.push({
+                    role: 'assistant',
+                    content: null,
+                    tool_calls: [{
+                            id: item.call_id,
+                            type: 'function',
+                            function: {
+                                name: item.name,
+                                arguments: typeof item.arguments === 'string' ? item.arguments : JSON.stringify(item.arguments),
+                            },
+                        }],
+                });
+                break;
+            }
+            case 'function_call_output':
+                messages.push({
+                    role: 'tool',
+                    tool_call_id: item.call_id,
+                    content: typeof item.output === 'string' ? item.output : JSON.stringify(item.output),
+                });
+                break;
+            case 'system':
+                messages.push({ role: 'system', content: extractTextContent(item.content) });
+                break;
+            case 'user':
+                messages.push({ role: 'user', content: extractTextContent(item.content) });
+                break;
+            case 'assistant':
+                messages.push({ role: 'assistant', content: extractTextContent(item.content) });
+                break;
+            default:
+                if (item.role) {
+                    messages.push({ role: item.role, content: extractTextContent(item.content) });
+                }
         }
     }
     return messages;
 }
+function convertChatToResponses(ccData) {
+    const choice = ccData.choices?.[0];
+    if (!choice) {
+        return { id: ccData.id, object: 'response', model: ccData.model, output: [], usage: ccData.usage };
+    }
+    const output = [];
+    if (choice.message?.content) {
+        output.push({
+            type: 'message',
+            role: 'assistant',
+            content: [{ type: 'output_text', text: choice.message.content }],
+        });
+    }
+    if (choice.message?.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+            output.push({
+                type: 'function_call',
+                call_id: tc.id,
+                name: tc.function?.name,
+                arguments: tc.function?.arguments,
+            });
+        }
+    }
+    // finish_reason = 'tool_calls' 表示等待 tool 结果（Codex 需要此信息）
+    const status = choice.finish_reason === 'tool_calls' ? 'requires_action' : 'completed';
+    return {
+        id: ccData.id,
+        object: 'response',
+        model: ccData.model,
+        status,
+        output,
+        usage: ccData.usage,
+    };
+}
+const EVENT_DELTA = 'response.output_text.delta';
+const EVENT_TOOL_DELTA = 'response.function_call_arguments.delta';
+const EVENT_COMPLETED = 'response.completed';
+const sseEncoder = new TextEncoder();
+function transformSSEStream(upstreamBody) {
+    let buffer = '';
+    let responseId = '';
+    let modelName = '';
+    let contentBuffer = '';
+    const toolCallAccum = {};
+    return new ReadableStream({
+        async start(controller) {
+            const reader = upstreamBody.getReader();
+            const decoder = new TextDecoder();
+            try {
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    let newlineIdx;
+                    while ((newlineIdx = buffer.indexOf('\n')) !== -1) {
+                        const line = buffer.slice(0, newlineIdx);
+                        buffer = buffer.slice(newlineIdx + 1);
+                        if (!line.startsWith('data: '))
+                            continue;
+                        const data = line.slice(6).trim();
+                        if (data === '[DONE]') {
+                            const finalEvt = buildResponseEvent(responseId, modelName, contentBuffer, toolCallAccum, true);
+                            controller.enqueue(sseEncoder.encode(finalEvt));
+                            controller.enqueue(sseEncoder.encode('data: [DONE]\n\n'));
+                            continue;
+                        }
+                        try {
+                            const chunk = JSON.parse(data);
+                            responseId = chunk.id || responseId;
+                            modelName = chunk.model || modelName;
+                            const delta = chunk.choices?.[0]?.delta;
+                            if (!delta)
+                                continue;
+                            if (delta.content) {
+                                contentBuffer += delta.content;
+                                const evt = `data: ${JSON.stringify({
+                                    type: EVENT_DELTA,
+                                    delta: delta.content,
+                                })}\n\n`;
+                                controller.enqueue(sseEncoder.encode(evt));
+                            }
+                            if (delta.tool_calls) {
+                                for (const tc of delta.tool_calls) {
+                                    if (!toolCallAccum[tc.index]) {
+                                        toolCallAccum[tc.index] = {
+                                            id: tc.id || '',
+                                            type: 'function',
+                                            function: { name: tc.function?.name || '', arguments: '' },
+                                        };
+                                    }
+                                    if (tc.function?.arguments) {
+                                        toolCallAccum[tc.index].function.arguments += tc.function.arguments;
+                                    }
+                                    if (tc.id)
+                                        toolCallAccum[tc.index].id = tc.id;
+                                    if (tc.function?.name)
+                                        toolCallAccum[tc.index].function.name = tc.function.name;
+                                }
+                                // 发送 tool_call delta 事件
+                                const tcEvt = `data: ${JSON.stringify({
+                                    type: EVENT_TOOL_DELTA,
+                                    tool_calls: Object.values(toolCallAccum),
+                                })}\n\n`;
+                                controller.enqueue(sseEncoder.encode(tcEvt));
+                            }
+                        }
+                        catch {
+                            // 非 JSON 行直接透传
+                            controller.enqueue(sseEncoder.encode(line + '\n'));
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                controller.error(err);
+            }
+            finally {
+                reader.releaseLock();
+                controller.close();
+            }
+        },
+    });
+}
+function buildResponseEvent(id, model, content, toolCalls, isFinal) {
+    const output = [];
+    if (content) {
+        output.push({ type: 'message', role: 'assistant', content: [{ type: 'output_text', text: content }] });
+    }
+    for (const tc of Object.values(toolCalls)) {
+        output.push({
+            type: 'function_call',
+            call_id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments,
+        });
+    }
+    return `data: ${JSON.stringify({
+        type: isFinal ? EVENT_COMPLETED : EVENT_DELTA,
+        response: isFinal ? { id, model, object: 'response', status: 'completed', output } : undefined,
+        delta: isFinal ? undefined : content,
+    })}\n\n`;
+}
+function convertToolSchemas(tools) {
+    if (!tools || !Array.isArray(tools))
+        return undefined;
+    return tools.map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters || t.input_schema,
+        },
+    }));
+}
 function extractTextContent(content) {
     if (typeof content === 'string')
         return content;
@@ -101,13 +294,3 @@ function extractTextContent(content) {
     }
     return String(content || '');
 }
-export function buildStreamingResponse(upstreamResp) {
-    return new Response(upstreamResp.body, {
-        status: upstreamResp.status,
-        headers: {
-            'Content-Type': 'text/event-stream',
-            'Cache-Control': 'no-cache',
-            Connection: 'keep-alive',
-        },
-    });
-}

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

@@ -1,7 +1,7 @@
 import { isProviderAvailable } from './quota.js';
 import { circuitBreakerRegistry } from './circuit-breaker.js';
-// 模型名重映射：对外模型名 → 实际 Provider 的模型名
-const MODEL_ALIASES = {
+// 模型名重映射：对外模型名 → 实际 Provider 的模型名（可从 config 覆盖）
+let modelAliases = {
     deepseek: {
         'gpt-5.3-codex': 'deepseek-v4-pro',
         'gpt-5.4': 'deepseek-v4-pro',
@@ -13,6 +13,26 @@ const MODEL_ALIASES = {
 let config;
 export function initModelRouter(cfg) {
     config = cfg;
+    // 从 config 加载模型别名（覆盖默认）
+    if (cfg.model_aliases) {
+        // cfg.model_aliases: { "gpt-x": "deepseek-v4-pro", "claude-y": "claude-opus" }
+        // 按目标模型名反查对应的 provider → 写入对应 provider 的别名表
+        for (const [aliasKey, realModel] of Object.entries(cfg.model_aliases)) {
+            for (const [providerName, providerCfg] of Object.entries(config.providers)) {
+                const providerModels = providerCfg.models || [];
+                if (providerModels.includes(realModel)) {
+                    modelAliases[providerName] = modelAliases[providerName] || {};
+                    modelAliases[providerName][aliasKey] = realModel;
+                    break;
+                }
+            }
+            // 兜底：如果没匹配到任何 provider，放入 deepseek
+            modelAliases.deepseek = modelAliases.deepseek || {};
+            if (!modelAliases.deepseek[aliasKey]) {
+                modelAliases.deepseek[aliasKey] = realModel;
+            }
+        }
+    }
 }
 export function getConfig() {
     return config;
@@ -24,7 +44,7 @@ export function resolveProvider(model) {
     // 1. 按 model_routing 配置查找
     const routingEntries = Object.entries(config.model_routing);
     for (const [pattern, providers] of routingEntries) {
-        if (model.includes(pattern)) {
+        if (model.startsWith(pattern)) {
             for (const providerName of providers) {
                 const providerCfg = config.providers[providerName];
                 if (!providerCfg)
@@ -79,7 +99,7 @@ export function resolveProvider(model) {
     return null;
 }
 export function remapModel(model, providerName) {
-    return MODEL_ALIASES[providerName]?.[model] || model;
+    return modelAliases[providerName]?.[model] || model;
 }
 function resolveApiKey(_name, providerCfg) {
     if (providerCfg.api_key && providerCfg.api_key !== '') {

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

@@ -4,6 +4,14 @@ import { getQuotaSummary, probeQuota } from './quota.js';
 import { circuitBreakerRegistry } from './circuit-breaker.js';
 import { checkAllProviders } from './health.js';
 import { getMetrics, recordRequest } from './metrics.js';
+import { checkRateLimit } from './rate-limit.js';
+function logReq(originalModel, providerName, actualModel, reqStart, status, streaming, error) {
+    recordRequest({
+        timestamp: Date.now(), model: originalModel,
+        provider: providerName, actualModel, latencyMs: Date.now() - reqStart,
+        status, streaming, error,
+    });
+}
 export async function modelGatewayRoutes(fastify) {
     // 健康检查 + 配额总览
     fastify.get('/model-gateway/health', async (_req, _reply) => {
@@ -41,6 +49,11 @@ export async function modelGatewayRoutes(fastify) {
     });
     // POST /v1/chat/completions — 标准 OpenAI 兼容端点
     fastify.post('/v1/chat/completions', async (request, reply) => {
+        const ip = request.ip || '127.0.0.1';
+        const rl = checkRateLimit('/v1/chat/completions', ip);
+        if (!rl.allowed) {
+            return reply.code(429).header('Retry-After', String(rl.resetSeconds)).header('X-RateLimit-Limit', rl.limit).header('X-RateLimit-Remaining', '0').send({ error: { message: 'Rate limit exceeded' } });
+        }
         const body = request.body;
         if (!body || !body.messages) {
             return reply.code(400).send({ error: { message: 'messages is required' } });
@@ -65,16 +78,16 @@ export async function modelGatewayRoutes(fastify) {
                 tools: body.tools,
                 tool_choice: body.tool_choice,
             });
-            if (!upstreamResp.ok && upstreamResp.status !== 200) {
+            if (!upstreamResp.ok) {
                 const errText = await upstreamResp.text();
-                recordRequest({ timestamp: Date.now(), model: originalModel, provider: provider.name, actualModel: model, latencyMs: Date.now() - reqStart, status: upstreamResp.status, error: errText.slice(0, 200), streaming: !!body.stream });
+                logReq(originalModel, provider.name, model, reqStart, upstreamResp.status, !!body.stream, errText.slice(0, 200));
                 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) {
-                recordRequest({ timestamp: Date.now(), model: originalModel, provider: provider.name, actualModel: model, latencyMs: Date.now() - reqStart, status: 200, streaming: true });
+                logReq(originalModel, provider.name, model, reqStart, 200, true);
                 return reply.headers({
                     'Content-Type': 'text/event-stream',
                     'Cache-Control': 'no-cache',
@@ -82,11 +95,11 @@ export async function modelGatewayRoutes(fastify) {
                 }).send(upstreamResp.body);
             }
             const data = await upstreamResp.json();
-            recordRequest({ timestamp: Date.now(), model: originalModel, provider: provider.name, actualModel: model, latencyMs: Date.now() - reqStart, status: 200, streaming: false });
+            logReq(originalModel, provider.name, model, reqStart, 200, false);
             reply.send(data);
         }
         catch (err) {
-            recordRequest({ timestamp: Date.now(), model: originalModel, provider: provider.name, actualModel: model, latencyMs: Date.now() - reqStart, status: 502, error: err.message, streaming: !!body.stream });
+            logReq(originalModel, provider.name, model, reqStart, 502, !!body.stream, err.message);
             console.error(`[ModelGW] Error calling ${provider.name}:`, err.message);
             reply.code(502).send({
                 error: { message: `Provider error: ${err.message}` },
@@ -95,6 +108,11 @@ export async function modelGatewayRoutes(fastify) {
     });
     // POST /v1/responses — Codex Desktop Responses API 适配
     fastify.post('/v1/responses', async (request, reply) => {
+        const ip = request.ip || '127.0.0.1';
+        const rl = checkRateLimit('/v1/responses', ip);
+        if (!rl.allowed) {
+            return reply.code(429).header('Retry-After', String(rl.resetSeconds)).send({ error: { message: 'Rate limit exceeded' } });
+        }
         const body = request.body;
         if (!body || !body.input) {
             return reply.code(400).send({ error: { message: 'input is required' } });
@@ -109,44 +127,28 @@ export async function modelGatewayRoutes(fastify) {
         const model = remapModel(originalModel, provider.name);
         body.model = model;
         console.log(`[ModelGW:Responses] ${originalModel} → ${provider.name}/${model}`);
+        const reqStart = Date.now();
         try {
             const upstreamResp = await callResponsesApi(provider, body);
             if (!upstreamResp.ok) {
                 const errText = await upstreamResp.text();
+                logReq(originalModel, provider.name, model, reqStart, upstreamResp.status, !!body.stream, errText.slice(0, 200));
                 return reply.code(upstreamResp.status).send({
                     error: { message: `${provider.name}: ${errText.slice(0, 500)}` },
                 });
             }
+            logReq(originalModel, provider.name, model, reqStart, 200, !!body.stream);
             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);
+            const data = await upstreamResp.json();
+            reply.send(data);
         }
         catch (err) {
+            logReq(originalModel, provider.name, model, reqStart, 502, !!body.stream, err.message);
             console.error(`[ModelGW:Responses] Error:`, err.message);
             reply.code(502).send({
                 error: { message: `Provider error: ${err.message}` },

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

@@ -9,6 +9,7 @@ export interface ModelGatewayConfig {
     providers: Record<string, ModelProviderConfig>;
     fallback_chain: string[];
     model_routing: Record<string, string[]>;
+    model_aliases?: Record<string, string>;
 }
 export interface ResolvedProvider {
     name: string;

package/package.json

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