@starlink-awaken/agentmesh 1.0.2 → 1.2.0

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

@@ -0,0 +1,80 @@
+import { circuitBreakerRegistry } from './circuit-breaker.js';
+const healthCache = new Map();
+const CACHE_TTL = 30_000; // 30s
+export async function checkProviderHealth(provider) {
+    const cached = healthCache.get(provider.name);
+    if (cached && Date.now() - cached.ts < CACHE_TTL) {
+        return { ...cached.result, checked_at: new Date(cached.result.checked_at).toISOString() };
+    }
+    const circuit = circuitBreakerRegistry.getState(provider.name);
+    if (circuit === 'OPEN') {
+        const result = {
+            provider: provider.name,
+            status: 'unhealthy',
+            latency_ms: 0,
+            circuit,
+            error: 'circuit_breaker_open',
+            checked_at: new Date().toISOString(),
+        };
+        healthCache.set(provider.name, { result, ts: Date.now() });
+        return result;
+    }
+    const start = Date.now();
+    try {
+        const resp = await fetch(`${provider.base_url.replace(/\/$/, '')}/models`, {
+            headers: { Authorization: `Bearer ${provider.api_key}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        const latency = Date.now() - start;
+        const result = {
+            provider: provider.name,
+            status: resp.ok ? 'healthy' : 'unhealthy',
+            latency_ms: latency,
+            circuit,
+            error: resp.ok ? undefined : `HTTP ${resp.status}`,
+            checked_at: new Date().toISOString(),
+        };
+        healthCache.set(provider.name, { result, ts: Date.now() });
+        return result;
+    }
+    catch (err) {
+        const result = {
+            provider: provider.name,
+            status: 'unhealthy',
+            latency_ms: Date.now() - start,
+            circuit,
+            error: err.message?.slice(0, 100) || 'unknown error',
+            checked_at: new Date().toISOString(),
+        };
+        healthCache.set(provider.name, { result, ts: Date.now() });
+        return result;
+    }
+}
+export async function checkAllProviders(config) {
+    const results = await Promise.allSettled(Object.entries(config.providers).map(async ([name, cfg]) => {
+        const apiKey = Bun.env[cfg.api_key_env || ''] || cfg.api_key || '';
+        if (!apiKey) {
+            return {
+                provider: name,
+                status: 'unknown',
+                latency_ms: 0,
+                circuit: circuitBreakerRegistry.getState(name),
+                error: 'no_api_key',
+                checked_at: new Date().toISOString(),
+            };
+        }
+        return checkProviderHealth({ name, base_url: cfg.base_url, api_key: apiKey });
+    }));
+    return results.map(r => {
+        if (r.status === 'fulfilled')
+            return r.value;
+        return {
+            provider: 'unknown',
+            status: 'unhealthy',
+            latency_ms: 0,
+            circuit: 'unknown',
+            error: r.reason?.message || 'check failed',
+            checked_at: new Date().toISOString(),
+        };
+    });
+}

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

@@ -0,0 +1,4 @@
+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

@@ -0,0 +1,113 @@
+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;
+    const body = { model, messages };
+    if (stream !== undefined)
+        body.stream = stream;
+    if (temperature !== undefined)
+        body.temperature = temperature;
+    if (max_tokens !== undefined)
+        body.max_tokens = max_tokens;
+    if (tools)
+        body.tools = tools;
+    if (tool_choice)
+        body.tool_choice = tool_choice;
+    const headers = {
+        '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),
+                signal: AbortSignal.timeout(120_000),
+            });
+            return r;
+        }, (attempt, status, delayMs) => {
+            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) {
+            circuitBreakerRegistry.recordSuccess(providerName);
+        }
+        else {
+            circuitBreakerRegistry.recordFailure(providerName);
+        }
+        return resp;
+    }
+    catch (err) {
+        circuitBreakerRegistry.recordFailure(providerName);
+        throw err;
+    }
+}
+export async function callResponsesApi(provider, body) {
+    // Responses API → Chat Completions 转换
+    const messages = convertResponsesInputToMessages(body.input || []);
+    if (body.instructions) {
+        messages.unshift({ role: 'system', content: body.instructions });
+    }
+    return callChatCompletions(provider, {
+        model: body.model,
+        messages,
+        stream: body.stream,
+        tools: body.tools,
+    });
+}
+function convertResponsesInputToMessages(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) });
+        }
+    }
+    return messages;
+}
+function extractTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((p) => p.type === 'input_text' || p.type === 'output_text')
+            .map((p) => p.text || '')
+            .join('\n');
+    }
+    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/quota.d.ts

@@ -0,0 +1,4 @@
+import type { QuotaInfo } from './types.js';
+export declare function probeQuota(): Promise<Map<string, QuotaInfo>>;
+export declare function isProviderAvailable(provider: string): boolean;
+export declare function getQuotaSummary(): Record<string, QuotaInfo>;

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

@@ -0,0 +1,107 @@
+let quotaCache = new Map();
+let lastProbeTime = 0;
+const QUOTA_TTL = 60_000; // 60秒缓存
+export async function probeQuota() {
+    const now = Date.now();
+    if (now - lastProbeTime < QUOTA_TTL && quotaCache.size > 0) {
+        return quotaCache;
+    }
+    try {
+        const proc = Bun.spawn(['codexbar', 'usage', '--format', 'json', '--provider', 'all'], { stdout: 'pipe', stderr: 'pipe' });
+        const output = await new Response(proc.stdout).text();
+        if (output.trim()) {
+            const entries = JSON.parse(output);
+            quotaCache = new Map();
+            for (const entry of entries) {
+                const provider = entry.provider;
+                if (!provider)
+                    continue;
+                const info = parseQuota(provider, entry);
+                quotaCache.set(provider, info);
+            }
+            lastProbeTime = now;
+            console.log(`[Quota] Refreshed: ${quotaCache.size} providers`);
+        }
+    }
+    catch (err) {
+        console.warn('[Quota] Probe failed, using stale cache:', err.message);
+    }
+    return quotaCache;
+}
+function parseQuota(provider, entry) {
+    let available = true;
+    let usedPercent;
+    let balance;
+    let summary = '';
+    try {
+        switch (provider) {
+            case 'codex': {
+                const credits = entry.credits;
+                const remaining = credits?.remaining ?? 0;
+                const secUsed = entry.usage?.secondary?.usedPercent ?? 0;
+                available = remaining > 0 || secUsed < 100;
+                usedPercent = secUsed;
+                summary = `Credits: ${remaining}, Secondary: ${secUsed}%`;
+                break;
+            }
+            case 'openai': {
+                // 直接 API Key 方式，总是 available（除非有 error）
+                available = !entry.error;
+                summary = entry.error ? `Error: ${entry.error.message}` : 'API Key configured';
+                break;
+            }
+            case 'deepseek': {
+                const desc = entry.usage?.primary?.resetDescription ?? '';
+                const match = desc.match(/¥([\d.]+)/);
+                balance = match ? parseFloat(match[1]) : -1;
+                available = (balance ?? -1) > 0;
+                summary = `Balance: ¥${(balance ?? -1).toFixed(2)}`;
+                break;
+            }
+            case 'openrouter': {
+                const orUsage = entry.usage?.openRouterUsage ?? {};
+                balance = orUsage.balance ?? 0;
+                usedPercent = orUsage.usedPercent ?? 0;
+                available = (balance ?? 0) > 0;
+                summary = `Balance: $${(balance ?? 0).toFixed(2)}, Used: ${usedPercent ?? 0}%`;
+                break;
+            }
+            case 'gemini': {
+                usedPercent = entry.usage?.primary?.usedPercent ?? 0;
+                available = (usedPercent ?? 100) < 95;
+                summary = `Used: ${usedPercent ?? 0}%`;
+                break;
+            }
+            case 'copilot': {
+                usedPercent = entry.usage?.primary?.usedPercent ?? 0;
+                available = (usedPercent ?? 0) < 100;
+                summary = `Used: ${usedPercent ?? 0}%`;
+                break;
+            }
+            case 'cursor': {
+                usedPercent = entry.usage?.primary?.usedPercent ?? 0;
+                available = (usedPercent ?? 0) < 100;
+                summary = `Used: ${usedPercent ?? 0}%`;
+                break;
+            }
+            case 'ollama':
+                available = true;
+                summary = 'Local - always available';
+                break;
+            default:
+                available = !entry.error;
+                summary = entry.error ? `Error: ${entry.error.message}` : 'Status unknown';
+        }
+    }
+    catch {
+        available = true; // 解析失败时假设可用
+        summary = 'Parse error, assuming available';
+    }
+    return { provider, available, usedPercent, balance, summary };
+}
+export function isProviderAvailable(provider) {
+    return quotaCache.get(provider)?.available ?? true;
+}
+export function getQuotaSummary() {
+    return Object.fromEntries(quotaCache);
+}

package/dist/src/model-gateway/rate-limit.d.ts

@@ -0,0 +1,12 @@
+interface LimitConfig {
+    rpm: number;
+    enabled: boolean;
+}
+export declare function initRateLimiter(configsOverride?: Record<string, Partial<LimitConfig>>): void;
+export declare function checkRateLimit(path: string, ip: string): {
+    allowed: boolean;
+    limit: number;
+    remaining: number;
+    resetSeconds: number;
+};
+export {};

package/dist/src/model-gateway/rate-limit.js

@@ -0,0 +1,51 @@
+const buckets = new Map();
+const configs = new Map();
+let cleanupTimer = null;
+const DEFAULTS = {
+    '/v1/chat/completions': { rpm: 60, enabled: true },
+    '/v1/responses': { rpm: 30, enabled: true },
+};
+export function initRateLimiter(configsOverride) {
+    for (const [path, defaults] of Object.entries(DEFAULTS)) {
+        configs.set(path, { ...defaults, ...configsOverride?.[path] });
+    }
+    // 每 60 秒清理过期桶
+    if (!cleanupTimer) {
+        cleanupTimer = setInterval(cleanupStaleBuckets, 60_000);
+        if (cleanupTimer.unref)
+            cleanupTimer.unref();
+    }
+}
+export function checkRateLimit(path, ip) {
+    const cfg = configs.get(path);
+    if (!cfg || !cfg.enabled) {
+        return { allowed: true, limit: 0, remaining: 0, resetSeconds: 0 };
+    }
+    const key = `${path}:${ip}`;
+    const now = Date.now();
+    let bucket = buckets.get(key);
+    if (!bucket) {
+        bucket = { tokens: cfg.rpm, lastRefill: now };
+        buckets.set(key, bucket);
+    }
+    const elapsed = (now - bucket.lastRefill) / 1000;
+    const refillRate = cfg.rpm / 60;
+    bucket.tokens = Math.min(cfg.rpm, bucket.tokens + elapsed * refillRate);
+    bucket.lastRefill = now;
+    // 重置时间 = 令牌桶回到满的时间
+    const tokensNeeded = cfg.rpm - bucket.tokens;
+    const resetSeconds = Math.ceil(tokensNeeded / refillRate);
+    if (bucket.tokens >= 1) {
+        bucket.tokens -= 1;
+        return { allowed: true, limit: cfg.rpm, remaining: Math.floor(bucket.tokens), resetSeconds };
+    }
+    return { allowed: false, limit: cfg.rpm, remaining: 0, resetSeconds: Math.max(1, resetSeconds) };
+}
+function cleanupStaleBuckets() {
+    const now = Date.now();
+    for (const [key, bucket] of buckets) {
+        if (now - bucket.lastRefill > 300_000) {
+            buckets.delete(key);
+        }
+    }
+}

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

@@ -0,0 +1,14 @@
+export interface RetryConfig {
+    maxRetries: number;
+    baseDelayMs: number;
+    maxDelayMs: number;
+    retryableStatuses: number[];
+}
+export declare function configureRetry(config?: Partial<RetryConfig>): void;
+export declare function getRetryConfig(): RetryConfig;
+export declare function isRetryable(status: number): boolean;
+export declare function getRetryDelay(attempt: number): number;
+export declare function withRetry<T>(provider: string, fn: () => Promise<{
+    ok: boolean;
+    status: number;
+} & T>, onRetry?: (attempt: number, status: number, delayMs: number) => void): Promise<T>;

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

@@ -0,0 +1,48 @@
+const DEFAULTS = {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 10_000,
+    retryableStatuses: [429, 500, 502, 503, 504],
+};
+let globalConfig = { ...DEFAULTS };
+export function configureRetry(config = {}) {
+    globalConfig = { ...DEFAULTS, ...config };
+}
+export function getRetryConfig() {
+    return globalConfig;
+}
+export function isRetryable(status) {
+    return globalConfig.retryableStatuses.includes(status);
+}
+export function getRetryDelay(attempt) {
+    const base = globalConfig.baseDelayMs * Math.pow(2, attempt);
+    const withJitter = base * (0.75 + Math.random() * 0.5);
+    return Math.min(withJitter, globalConfig.maxDelayMs);
+}
+export async function withRetry(provider, fn, onRetry) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= globalConfig.maxRetries; attempt++) {
+        try {
+            const result = await fn();
+            if (!result.ok && isRetryable(result.status) && attempt < globalConfig.maxRetries) {
+                const delay = getRetryDelay(attempt);
+                onRetry?.(attempt + 1, result.status, delay);
+                await sleep(delay);
+                continue;
+            }
+            return result;
+        }
+        catch (err) {
+            lastError = err;
+            if (attempt < globalConfig.maxRetries) {
+                const delay = getRetryDelay(attempt);
+                onRetry?.(attempt + 1, 0, delay);
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError || new Error(`${provider}: max retries exhausted`);
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,4 @@
+import type { ModelGatewayConfig, ResolvedProvider } from './types.js';
+export declare function initModelRouter(cfg: ModelGatewayConfig): void;
+export declare function getConfig(): ModelGatewayConfig;
+export declare function resolveProvider(model: string): ResolvedProvider | null;

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

@@ -0,0 +1,79 @@
+import { isProviderAvailable } from './quota.js';
+import { circuitBreakerRegistry } from './circuit-breaker.js';
+let config;
+export function initModelRouter(cfg) {
+    config = cfg;
+}
+export function getConfig() {
+    return config;
+}
+// 解析 Provider，按优先级查找第一个可用的
+export function resolveProvider(model) {
+    if (!config)
+        return null;
+    // 1. 按 model_routing 配置查找
+    const routingEntries = Object.entries(config.model_routing);
+    for (const [pattern, providers] of routingEntries) {
+        if (model.includes(pattern)) {
+            for (const providerName of providers) {
+                const providerCfg = config.providers[providerName];
+                if (!providerCfg)
+                    continue;
+                const apiKey = resolveApiKey(providerName, providerCfg);
+                if (!apiKey)
+                    continue;
+                // 熔断器检查：跳过 OPEN 状态的 Provider
+                if (circuitBreakerRegistry.isOpen(providerName))
+                    continue;
+                // codex 和 openai 特殊处理：检查 Codex Plus 配额
+                if (providerName === 'openai') {
+                    const codexAvailable = isProviderAvailable('codex');
+                    if (!codexAvailable)
+                        continue; // Codex Plus 配额耗尽，跳过
+                }
+                return {
+                    name: providerName,
+                    base_url: providerCfg.base_url,
+                    api_key: apiKey,
+                };
+            }
+            break;
+        }
+    }
+    // 2. 全局 fallback 链
+    for (const providerName of config.fallback_chain) {
+        const providerCfg = config.providers[providerName];
+        if (!providerCfg)
+            continue;
+        const apiKey = resolveApiKey(providerName, providerCfg);
+        if (!apiKey)
+            continue;
+        // 熔断器检查：跳过 OPEN 状态的 Provider
+        if (circuitBreakerRegistry.isOpen(providerName))
+            continue;
+        return {
+            name: providerName,
+            base_url: providerCfg.base_url,
+            api_key: apiKey,
+        };
+    }
+    // 3. 终极兜底：第一个有 API Key 的 Provider（也检查熔断器）
+    for (const [name, cfg] of Object.entries(config.providers)) {
+        if (circuitBreakerRegistry.isOpen(name))
+            continue;
+        const key = resolveApiKey(name, cfg);
+        if (key) {
+            return { name, base_url: cfg.base_url, api_key: key };
+        }
+    }
+    return null;
+}
+function resolveApiKey(_name, providerCfg) {
+    if (providerCfg.api_key && providerCfg.api_key !== '') {
+        return providerCfg.api_key;
+    }
+    if (providerCfg.api_key_env) {
+        return Bun.env[providerCfg.api_key_env] || null;
+    }
+    return null;
+}

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

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