feat(local-ai): isolate local gateway console

Author: awsl233777

cli.js

@@ -103,7 +103,10 @@ function buildUpstreamPool(readConfigFn, openaiBridgeFile, excludedProviders) {
         const baseUrl = typeof p.base_url === 'string' ? p.base_url.trim() : '';
         if (!isValidHttpUrl(normalizeBaseUrl(baseUrl))) continue;
         const authMethod = typeof p.preferred_auth_method === 'string' ? p.preferred_auth_method.trim() : '';
-        pool.push({ name, baseUrl: normalizeBaseUrl(baseUrl), authMethod, requiresOpenaiAuth: !!p.requires_openai_auth });
+        const models = Array.isArray(p.models) ? p.models.filter(item => typeof item === 'string' && item.trim()).map(item => item.trim()) : [];
+        const model = typeof p.selected_model === 'string' && p.selected_model.trim() ? p.selected_model.trim() : (models[0] || '');
+        const temperature = typeof p.temperature === 'number' && Number.isFinite(p.temperature) ? p.temperature : null;
+        pool.push({ name, baseUrl: normalizeBaseUrl(baseUrl), authMethod, requiresOpenaiAuth: !!p.requires_openai_auth, model, temperature });
     }
     if (pool.length === 0) return { error: '请先添加上游 provider' };
     return { pool };
@@ -151,8 +154,11 @@ function resolveUpstreamAuth(entry, openaiBridgeFile, reqAuthToken) {
         if (upstream && upstream.apiKey) {
             return upstream.apiKey.startsWith('Bearer ') ? upstream.apiKey : `Bearer ${upstream.apiKey}`;
         }
+        return '';
     }
-    return '';
+    const providerToken = typeof entry.authMethod === 'string' ? entry.authMethod.trim() : '';
+    if (!providerToken) return '';
+    return /^Bearer\s+/i.test(providerToken) ? providerToken : `Bearer ${providerToken}`;
 }
 
 function createLocalBridgeHttpHandler(options = {}) {
@@ -186,6 +192,20 @@ function createLocalBridgeHttpHandler(options = {}) {
         return { entry: pool[0], idx: 0 };
     }
 
+    function pickUpstreamExcluding(pool, excludedNames) {
+        const now = Date.now();
+        const excluded = excludedNames instanceof Set ? excludedNames : new Set();
+        for (let i = 0; i < pool.length; i++) {
+            const idx = rrIndex++ % pool.length;
+            const entry = pool[idx];
+            if (excluded.has(entry.name)) continue;
+            const st = circuitState.get(entry.name);
+            if (st && st.openUntil > now) continue;
+            return { entry, idx };
+        }
+        return null;
+    }
+
     function recordFailure(name) {
         let st = circuitState.get(name);
         if (!st) { st = { failures: 0, openUntil: 0 }; circuitState.set(name, st); }
@@ -722,25 +742,98 @@ function createLocalBridgeHttpHandler(options = {}) {
                 return;
             }
 
-            // passthrough for other v1/* paths
-            const upstreamUrl = joinApiUrl(upstreamBase, normalizedSuffix);
-            const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
-                method: req.method || 'GET',
-                body: null,
-                headers: { ...(authHeader ? { Authorization: authHeader } : {}) },
-                maxBytes: maxUpstreamBytes,
-                httpAgent,
-                httpsAgent
-            }));
-            if (!upstreamResult.ok) {
-                recordFailure(entry.name);
-                res.writeHead(502, { 'Content-Type': 'application/json; charset=utf-8' });
-                res.end(JSON.stringify({ error: `Upstream request failed: ${upstreamResult.error}` }));
+            // OpenAI-compatible passthrough for /bridge/local/v1/* paths.
+            // Automatic policy: retry transient errors, fail over to the next provider,
+            // and let the circuit breaker freeze repeatedly failing providers.
+            const method = (req.method || 'GET').toUpperCase();
+            let passthroughBody = null;
+            if (method !== 'GET' && method !== 'HEAD') {
+                const bodyResult = await readRequestBody(req, maxBodySize);
+                if (bodyResult.error) {
+                    res.writeHead(413, { 'Content-Type': 'application/json; charset=utf-8' });
+                    res.end(JSON.stringify({ error: bodyResult.error }));
+                    return;
+                }
+                if (String(bodyResult.body || '').trim()) {
+                    const parsedBody = parseJsonOrError(bodyResult.body);
+                    if (parsedBody.error) {
+                        res.writeHead(400, { 'Content-Type': 'application/json; charset=utf-8' });
+                        res.end(JSON.stringify({ error: `Invalid JSON: ${parsedBody.error}` }));
+                        return;
+                    }
+                    passthroughBody = parsedBody.value;
+                }
+            }
+
+            const attemptedProviders = [];
+            const attemptedProviderNames = new Set();
+            let lastResult = null;
+            let lastEntry = null;
+            const shouldFailover = (result) => {
+                if (!result || !result.ok) return true;
+                const status = Number(result.status || 0);
+                return status === 401 || status === 403 || status === 429 || status >= 500;
+            };
+
+            for (let attempt = 0; attempt < pool.length; attempt += 1) {
+                const selected = attempt === 0 ? { entry, idx } : pickUpstreamExcluding(pool, attemptedProviderNames);
+                if (!selected || !selected.entry) break;
+                const attemptEntry = selected.entry;
+                const attemptAuthHeader = resolveUpstreamAuth(attemptEntry, openaiBridgeFile, token);
+                const attemptBase = attemptEntry.baseUrl.replace(/\/+$/, '');
+                const upstreamUrl = joinApiUrl(attemptBase, normalizedSuffix);
+                let attemptBody = passthroughBody;
+                if (normalizedSuffix === 'chat/completions' && attemptBody && typeof attemptBody === 'object' && !Array.isArray(attemptBody)) {
+                    attemptBody = { ...attemptBody };
+                    if (!attemptBody.model && attemptEntry.model) {
+                        attemptBody.model = attemptEntry.model;
+                    }
+                    if (attemptBody.temperature === undefined && attemptEntry.temperature !== null && attemptEntry.temperature !== undefined) {
+                        attemptBody.temperature = attemptEntry.temperature;
+                    }
+                }
+                attemptedProviders.push(attemptEntry.name);
+                attemptedProviderNames.add(attemptEntry.name);
+                const upstreamResult = await retryTransientRequest(() => proxyRequestJson(upstreamUrl, {
+                    method,
+                    body: attemptBody,
+                    headers: {
+                        ...(attemptAuthHeader ? { Authorization: attemptAuthHeader } : {}),
+                        ...(attemptBody !== null ? { 'Content-Type': 'application/json' } : {})
+                    },
+                    maxBytes: maxUpstreamBytes,
+                    httpAgent,
+                    httpsAgent
+                }));
+                lastResult = upstreamResult;
+                lastEntry = attemptEntry;
+                if (!shouldFailover(upstreamResult)) {
+                    recordSuccess(attemptEntry.name);
+                    res.writeHead(upstreamResult.status, {
+                        'Content-Type': 'application/json; charset=utf-8',
+                        'X-Codexmate-Upstream-Provider': attemptEntry.name,
+                        'X-Codexmate-Attempted-Providers': attemptedProviders.join(',')
+                    });
+                    res.end(upstreamResult.bodyText);
+                    return;
+                }
+                recordFailure(attemptEntry.name);
+            }
+
+            if (!lastResult || !lastResult.ok) {
+                res.writeHead(502, {
+                    'Content-Type': 'application/json; charset=utf-8',
+                    'X-Codexmate-Attempted-Providers': attemptedProviders.join(',')
+                });
+                res.end(JSON.stringify({ error: `Upstream request failed: ${lastResult && lastResult.error ? lastResult.error : 'unknown error'}` }));
                 return;
             }
-            recordSuccess(entry.name);
-            res.writeHead(upstreamResult.status, { 'Content-Type': 'application/json; charset=utf-8' });
-            res.end(upstreamResult.bodyText);
+            res.writeHead(lastResult.status || 502, {
+                'Content-Type': 'application/json; charset=utf-8',
+                'X-Codexmate-Upstream-Provider': lastEntry ? lastEntry.name : '',
+                'X-Codexmate-Attempted-Providers': attemptedProviders.join(',')
+            });
+            res.end(lastResult.bodyText || JSON.stringify({ error: 'Upstream error' }));
             } catch (e) {
                 res.writeHead(500, { 'Content-Type': 'application/json; charset=utf-8' });
                 res.end(JSON.stringify({ error: e && e.message ? e.message : 'Internal Error' }));