Upload 3 files

Dockerfile

@@ -0,0 +1,22 @@
+FROM node:20-slim
+
+WORKDIR /app
+
+# Copy package.json and package-lock.json
+COPY package.json package-lock.json* ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy source code
+COPY . .
+
+# Expose the port
+EXPOSE 7860
+
+# Set environment variables (these can be overridden at runtime)
+ENV PORT=7860
+ENV TZ=Asia/Shanghai
+
+# Start the application
+CMD ["node", "server.js"]

index.js

@@ -0,0 +1,903 @@
+// server.js
+const express = require('express');
+const axios = require('axios');
+const crypto = require('crypto');
+const { format } = require('date-fns');
+const stream = require('stream');
+const { promisify } = require('util');
+const Scheduler = require('node-schedule');
+
+const app = express();
+app.use(express.json());
+
+// Environment configuration
+process.env.TZ = 'Asia/Shanghai';
+const MAX_RETRIES = parseInt(process.env.MaxRetries || '3');
+const MAX_REQUESTS = parseInt(process.env.MaxRequests || '2');
+const LIMIT_WINDOW = parseInt(process.env.LimitWindow || '60');
+const RETRY_DELAY = 1;
+const MAX_RETRY_DELAY = 16;
+
+// Initialize logger
+const logger = {
+    info: (msg) => console.log(msg),
+    warning: (msg) => console.warn(msg),
+    error: (msg) => console.error(msg),
+    debug: (msg) => console.debug(msg)
+};
+
+// Request tracking for rate limiting
+const requestCounts = {};
+const apiKeyBlacklist = new Set();
+const apiKeyBlacklistDuration = 60; // seconds
+
+// Safety settings
+const safetySettings = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "BLOCK_NONE"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'BLOCK_NONE'
+    }
+];
+
+const safetySettingsG2 = [
+    {
+        "category": "HARM_CATEGORY_HARASSMENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_HATE_SPEECH",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_SEXUALLY_EXPLICIT",
+        "threshold": "OFF"
+    },
+    {
+        "category": "HARM_CATEGORY_DANGEROUS_CONTENT",
+        "threshold": "OFF"
+    },
+    {
+        "category": 'HARM_CATEGORY_CIVIC_INTEGRITY',
+        "threshold": 'OFF'
+    }
+];
+
+// Classes
+class ResponseWrapper {
+    constructor(data) {
+        this._data = data;
+        this._text = this._extractText();
+        this._finishReason = this._extractFinishReason();
+        this._promptTokenCount = this._extractPromptTokenCount();
+        this._candidatesTokenCount = this._extractCandidatesTokenCount();
+        this._totalTokenCount = this._extractTotalTokenCount();
+        this._thoughts = this._extractThoughts();
+        this._jsonDumps = JSON.stringify(this._data, null, 4);
+    }
+
+    _extractThoughts() {
+        try {
+            for (const part of this._data.candidates[0].content.parts) {
+                if ('thought' in part) {
+                    return part.text;
+                }
+            }
+            return "";
+        } catch (error) {
+            return "";
+        }
+    }
+
+    _extractText() {
+        try {
+            for (const part of this._data.candidates[0].content.parts) {
+                if (!('thought' in part)) {
+                    return part.text;
+                }
+            }
+            return "";
+        } catch (error) {
+            return "";
+        }
+    }
+
+    _extractFinishReason() {
+        try {
+            return this._data.candidates[0].finishReason;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    _extractPromptTokenCount() {
+        try {
+            return this._data.usageMetadata.promptTokenCount;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    _extractCandidatesTokenCount() {
+        try {
+            return this._data.usageMetadata.candidatesTokenCount;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    _extractTotalTokenCount() {
+        try {
+            return this._data.usageMetadata.totalTokenCount;
+        } catch (error) {
+            return null;
+        }
+    }
+
+    get text() {
+        return this._text;
+    }
+
+    get finishReason() {
+        return this._finishReason;
+    }
+
+    get promptTokenCount() {
+        return this._promptTokenCount;
+    }
+
+    get candidatesTokenCount() {
+        return this._candidatesTokenCount;
+    }
+
+    get totalTokenCount() {
+        return this._totalTokenCount;
+    }
+
+    get thoughts() {
+        return this._thoughts;
+    }
+
+    get jsonDumps() {
+        return this._jsonDumps;
+    }
+}
+
+class APIKeyManager {
+    constructor() {
+        this.apiKeys = (process.env.KeyArray || '').match(/AIzaSy[a-zA-Z0-9_-]{33}/g) || [];
+        this.currentIndex = Math.floor(Math.random() * this.apiKeys.length);
+    }
+
+    getAvailableKey() {
+        const numKeys = this.apiKeys.length;
+        for (let i = 0; i < numKeys; i++) {
+            if (this.currentIndex >= numKeys) {
+                this.currentIndex = 0;
+            }
+            const currentKey = this.apiKeys[this.currentIndex];
+            this.currentIndex++;
+
+            if (!apiKeyBlacklist.has(currentKey)) {
+                return currentKey;
+            }
+        }
+
+        logger.error("所有API key都已耗尽或被暂时禁用，请重新配置或稍后重试");
+        return null;
+    }
+
+    showAllKeys() {
+        logger.info(`当前可用API key个数: ${this.apiKeys.length}`);
+        this.apiKeys.forEach((apiKey, i) => {
+            logger.info(`API Key${i}: ${apiKey.substring(0, 8)}...${apiKey.slice(-3)}`);
+        });
+    }
+
+    blacklistKey(key) {
+        logger.warning(`${key.substring(0, 8)} → 暂时禁用 ${apiKeyBlacklistDuration} 秒`);
+        apiKeyBlacklist.add(key);
+
+        setTimeout(() => {
+            apiKeyBlacklist.delete(key);
+        }, apiKeyBlacklistDuration * 1000);
+    }
+}
+
+const keyManager = new APIKeyManager();
+keyManager.showAllKeys();
+let currentApiKey = keyManager.getAvailableKey();
+
+function switchApiKey() {
+    const key = keyManager.getAvailableKey();
+    if (key) {
+        currentApiKey = key;
+        logger.info(`API key 替换为 → ${currentApiKey.substring(0, 8)}...${currentApiKey.slice(-3)}`);
+    } else {
+        logger.error("API key 替换失败，所有API key都已耗尽或被暂时禁用，请重新配置或稍后重试");
+    }
+}
+
+logger.info(`当前 API key: ${currentApiKey.substring(0, 8)}...${currentApiKey.slice(-3)}`);
+
+// Gemini models
+const GEMINI_MODELS = [
+    { "id": "text-embedding-004" },
+    { "id": "gemini-1.5-flash-8b-latest" },
+    { "id": "gemini-1.5-flash-8b-exp-0924" },
+    { "id": "gemini-1.5-flash-latest" },
+    { "id": "gemini-1.5-flash-exp-0827" },
+    { "id": "gemini-1.5-pro-latest" },
+    { "id": "gemini-1.5-pro-exp-0827" },
+    { "id": "learnlm-1.5-pro-experimental" },
+    { "id": "gemini-exp-1114" },
+    { "id": "gemini-exp-1121" },
+    { "id": "gemini-exp-1206" },
+    { "id": "gemini-2.0-flash-exp" },
+    { "id": "gemini-2.0-flash-thinking-exp-1219" },
+    { "id": "gemini-2.0-flash-thinking-exp-01-21" },
+    { "id": "gemini-2.0-flash" },
+    { "id": "gemini-2.0-pro-exp-02-05" }
+];
+
+// Authentication and Message Processing Functions
+function authenticateRequest(req) {
+    const authHeader = req.headers.authorization;
+
+    if (!authHeader) {
+        return [false, { error: '缺少Authorization请求头' }, 401];
+    }
+
+    try {
+        const [authType, passWord] = authHeader.split(' ', 2);
+        if (authType.toLowerCase() !== 'bearer') {
+            return [false, { error: 'Authorization类型必须为Bearer' }, 401];
+        }
+
+        if (passWord !== process.env.password) {
+            return [false, { error: '未授权' }, 401];
+        }
+
+        return [true, null, null];
+    } catch (error) {
+        return [false, { error: 'Authorization请求头格式错误' }, 401];
+    }
+}
+
+function processMessagesForGemini(messages, useSystemPrompt = false) {
+    const geminiHistory = [];
+    const errors = [];
+    let systemInstructionText = "";
+    let isSystemPhase = useSystemPrompt;
+
+    for (const message of messages) {
+        const role = message.role;
+        const content = message.content;
+
+        if (typeof content === 'string') {
+            if (isSystemPhase && role === 'system') {
+                systemInstructionText = systemInstructionText
+                    ? `${systemInstructionText}\n${content}`
+                    : content;
+            } else {
+                isSystemPhase = false;
+
+                let roleToUse;
+                if (role === 'user' || role === 'system') {
+                    roleToUse = 'user';
+                } else if (role === 'assistant') {
+                    roleToUse = 'model';
+                } else {
+                    errors.push(`Invalid role: ${role}`);
+                    continue;
+                }
+
+                if (geminiHistory.length > 0 && geminiHistory[geminiHistory.length - 1].role === roleToUse) {
+                    geminiHistory[geminiHistory.length - 1].parts.push({ text: content });
+                } else {
+                    geminiHistory.push({ role: roleToUse, parts: [{ text: content }] });
+                }
+            }
+        } else if (Array.isArray(content)) {
+            const parts = [];
+            for (const item of content) {
+                if (item.type === 'text') {
+                    parts.push({ text: item.text });
+                } else if (item.type === 'image_url') {
+                    const imageData = item.image_url?.url || '';
+                    if (imageData.startsWith('data:image/')) {
+                        try {
+                            const mimeType = imageData.split(';')[0].split(':')[1];
+                            const base64Data = imageData.split(',')[1];
+                            parts.push({
+                                inline_data: {
+                                    mime_type: mimeType,
+                                    data: base64Data
+                                }
+                            });
+                        } catch (error) {
+                            errors.push(`Invalid data URI for image: ${imageData}`);
+                        }
+                    } else {
+                        errors.push(`Invalid image URL format for item: ${JSON.stringify(item)}`);
+                    }
+                } else if (item.type === 'file_url') {
+                    const fileData = item.file_url?.url || '';
+                    if (fileData.startsWith('data:')) {
+                        try {
+                            const mimeType = fileData.split(';')[0].split(':')[1];
+                            const base64Data = fileData.split(',')[1];
+                            parts.push({
+                                inline_data: {
+                                    mime_type: mimeType,
+                                    data: base64Data
+                                }
+                            });
+                        } catch (error) {
+                            errors.push(`Invalid data URI for file: ${fileData}`);
+                        }
+                    } else {
+                        errors.push(`Invalid file URL format for item: ${JSON.stringify(item)}`);
+                    }
+                }
+            }
+
+            if (parts.length > 0) {
+                let roleToUse;
+                if (role === 'user' || role === 'system') {
+                    roleToUse = 'user';
+                } else if (role === 'assistant') {
+                    roleToUse = 'model';
+                } else {
+                    errors.push(`Invalid role: ${role}`);
+                    continue;
+                }
+
+                if (geminiHistory.length > 0 && geminiHistory[geminiHistory.length - 1].role === roleToUse) {
+                    geminiHistory[geminiHistory.length - 1].parts.push(...parts);
+                } else {
+                    geminiHistory.push({ role: roleToUse, parts });
+                }
+            }
+        }
+    }
+
+    if (errors.length > 0) {
+        return [geminiHistory, { parts: [{ text: systemInstructionText }] }, { error: errors }];
+    } else {
+        return [geminiHistory, { parts: [{ text: systemInstructionText }] }, null];
+    }
+}
+
+// Rate limiting and API error handling
+function isWithinRateLimit(apiKey) {
+    const now = new Date();
+    if (!requestCounts[apiKey]) {
+        requestCounts[apiKey] = [];
+    }
+
+    // Remove expired requests
+    while (
+        requestCounts[apiKey].length > 0 &&
+        (now - requestCounts[apiKey][0]) > LIMIT_WINDOW * 1000
+    ) {
+        requestCounts[apiKey].shift();
+    }
+
+    if (requestCounts[apiKey].length >= MAX_REQUESTS) {
+        const earliestRequestTime = requestCounts[apiKey][0];
+        const waitTime = (earliestRequestTime + LIMIT_WINDOW * 1000 - now) / 1000;
+        return [false, waitTime];
+    } else {
+        return [true, 0];
+    }
+}
+
+function incrementRequestCount(apiKey) {
+    const now = new Date();
+    if (!requestCounts[apiKey]) {
+        requestCounts[apiKey] = [];
+    }
+    requestCounts[apiKey].push(now);
+}
+
+async function handleApiError(error, attempt, currentApiKey) {
+    if (attempt > MAX_RETRIES) {
+        logger.error(`${MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入`);
+        return [0, {
+            error: {
+                message: `${MAX_RETRIES} 次尝试后仍然失败，请修改预设或输入`,
+                type: 'max_retries_exceeded'
+            }
+        }];
+    }
+
+    if (error.response) {
+        const statusCode = error.response.status;
+
+        if (statusCode === 400) {
+            try {
+                const errorData = error.response.data;
+                if (errorData.error) {
+                    if (errorData.error.code === "invalid_argument") {
+                        logger.error(`${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → 无效，可能已过期或被删除`);
+                        keyManager.blacklistKey(currentApiKey);
+                        switchApiKey();
+                        return [0, null];
+                    }
+                    const errorMessage = errorData.error.message || 'Bad Request';
+                    const errorType = errorData.error.type || 'invalid_request_error';
+                    logger.warning(`400 错误请求: ${errorMessage}`);
+                    return [2, { error: { message: errorMessage, type: errorType } }];
+                }
+            } catch (parseError) {
+                logger.warning("400 错误请求：响应不是有效的JSON格式");
+                return [2, { error: { message: '', type: 'invalid_request_error' } }];
+            }
+        } else if (statusCode === 429) {
+            logger.warning(
+                `${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → 429 官方资源耗尽 → 立即重试...`
+            );
+            keyManager.blacklistKey(currentApiKey);
+            switchApiKey();
+            return [0, null];
+        } else if (statusCode === 403) {
+            logger.error(
+                `${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → 403 权限被拒绝，该 API KEY 可能已经被官方封禁`
+            );
+            keyManager.blacklistKey(currentApiKey);
+            switchApiKey();
+            return [0, null];
+        } else if (statusCode === 500) {
+            logger.warning(
+                `${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → 500 服务器内部错误 → 立即重试...`
+            );
+            switchApiKey();
+            return [0, null];
+        } else if (statusCode === 503) {
+            logger.warning(
+                `${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → 503 服务不可用 → 立即重试...`
+            );
+            switchApiKey();
+            return [0, null];
+        } else {
+            logger.warning(
+                `${currentApiKey.substring(0, 8)} ... ${currentApiKey.slice(-3)} → ${statusCode} 未知错误/模型不可用 → 不重试...`
+            );
+            switchApiKey();
+            return [2, null];
+        }
+    } else if (error.code === 'ECONNREFUSED' || error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT') {
+        const delay = Math.min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY);
+        logger.warning(`连接错误 → 立即重试...`);
+        await new Promise(resolve => setTimeout(resolve, delay * 1000));
+        return [0, null];
+    } else if (error.code === 'ETIMEDOUT') {
+        const delay = Math.min(RETRY_DELAY * (2 ** attempt), MAX_RETRY_DELAY);
+        logger.warning(`请求超时 → 立即重试...`);
+        await new Promise(resolve => setTimeout(resolve, delay * 1000));
+        return [0, null];
+    } else {
+        logger.error(`发生未知错误: ${error.message || error}`);
+        return [0, {
+            error: {
+                message: `发生未知错误: ${error.message || error}`,
+                type: 'unknown_error'
+            }
+        }];
+    }
+}
+
+// Route Handlers
+app.get('/', (req, res) => {
+    const mainContent = " gemini-rProxy v2.3.5 2025-01-25";
+    const htmlTemplate = `
+<!DOCTYPE html>
+<html>
+<head>
+<meta charset="utf-8">
+<script>
+function copyToClipboard(text) {
+  var textarea = document.createElement("textarea");
+  textarea.textContent = text;
+  textarea.style.position = "fixed";
+  document.body.appendChild(textarea);
+  textarea.select();
+  try {
+    return document.execCommand("copy");
+  } catch (ex) {
+    console.warn("Copy to clipboard failed.", ex);
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+  }
+}
+function copyLink(event) {
+  event.preventDefault();
+  const url = new URL(window.location.href);
+  const link = url.protocol + '//' + url.host + '/hf/v1';
+  copyToClipboard(link);
+  alert('链接已复制: ' + link);
+}
+</script>
+</head>
+<body>
+${mainContent}<br/><br/>完全开源、免费且禁止商用<br/><br/>点击复制反向代理: <a href="v1" onclick="copyLink(event)">Copy Link</a><br/>聊天来源选择"自定义(兼容 OpenAI)"<br/>将复制的网址填入到自定义端点<br/>将设置password填入自定义API秘钥<br/><br/><br/>
+</body>
+</html>
+  `;
+    res.send(htmlTemplate);
+});
+
+app.post('/hf/v1/chat/completions', async (req, res) => {
+    const [isAuthenticated, authError, statusCode] = authenticateRequest(req);
+    if (!isAuthenticated) {
+        return res.status(statusCode || 401).json(authError || { error: '未授权' });
+    }
+
+    const requestData = req.body;
+    const messages = requestData.messages || [];
+    const model = requestData.model || 'gemini-2.0-flash-exp';
+    const temperature = requestData.temperature || 1;
+    const maxTokens = requestData.max_tokens || 8192;
+    const showThoughts = requestData.show_thoughts || false;
+    const stream = requestData.stream || false;
+    const useSystemPrompt = requestData.use_system_prompt || false;
+    const hint = stream ? "流式" : "非流";
+
+    logger.info(`\n${model} [${hint}] → ${currentApiKey.substring(0, 8)}...${currentApiKey.slice(-3)}`);
+
+    const isThinking = model.includes('thinking');
+    const apiVersion = isThinking ? 'v1alpha' : 'v1beta';
+    const responseType = stream ? 'streamGenerateContent' : 'generateContent';
+    const isSSE = stream ? '&alt=sse' : '';
+
+    const [contents, systemInstruction, errorResponse] = processMessagesForGemini(messages, useSystemPrompt);
+
+    if (errorResponse) {
+        logger.error(`处理输入消息时出错↙\n ${JSON.stringify(errorResponse)}`);
+        return res.status(400).json(errorResponse);
+    }
+
+    async function doRequest(currentApiKey, attempt) {
+        const [isOk, timeRemaining] = isWithinRateLimit(currentApiKey);
+        if (!isOk) {
+            logger.warning(`暂时超过限额，该API key将在 ${timeRemaining} 秒后启用...`);
+            switchApiKey();
+            return [0, null];
+        }
+
+        incrementRequestCount(currentApiKey);
+
+        const url = `https://generativelanguage.googleapis.com/${apiVersion}/models/${model}:${responseType}?key=${currentApiKey}${isSSE}`;
+        const headers = {
+            "Content-Type": "application/json",
+        };
+
+        const data = {
+            contents,
+            generationConfig: {
+                temperature,
+                maxOutputTokens: maxTokens,
+            },
+            safetySettings: model.includes('gemini-2.0-flash-exp') ? safetySettingsG2 : safetySettings,
+        };
+
+        if (systemInstruction.parts[0].text) {
+            data.system_instruction = systemInstruction;
+        }
+
+        try {
+            const response = await axios({
+                method: 'post',
+                url,
+                headers,
+                data,
+                responseType: stream ? 'stream' : 'json'
+            });
+
+            if (stream) {
+                return [1, response];
+            } else {
+                return [1, new ResponseWrapper(response.data)];
+            }
+        } catch (error) {
+            return handleApiError(error, attempt, currentApiKey);
+        }
+    }
+
+    function generateStream(response) {
+        logger.info(`流式开始 →`);
+        let buffer = '';
+
+        response.data.on('data', (chunk) => {
+            const lines = chunk.toString().split('\n');
+
+            for (const line of lines) {
+                if (!line.trim()) continue;
+
+                try {
+                    let data = line;
+                    if (data.startsWith('data: ')) {
+                        data = data.substring(6);
+                    }
+
+                    buffer += data;
+
+                    try {
+                        const jsonData = JSON.parse(buffer);
+                        buffer = '';
+
+                        if (jsonData.candidates && jsonData.candidates.length > 0) {
+                            const candidate = jsonData.candidates[0];
+                            if (candidate.content) {
+                                const content = candidate.content;
+                                if (content.parts && content.parts.length > 0) {
+                                    let parts = content.parts;
+                                    if (isThinking && !showThoughts) {
+                                        parts = parts.filter(part => !part.thought);
+                                    }
+
+                                    if (parts.length > 0) {
+                                        const text = parts[0].text || '';
+                                        const finishReason = candidate.finishReason;
+
+                                        if (text) {
+                                            const data = {
+                                                choices: [{
+                                                    delta: {
+                                                        content: text
+                                                    },
+                                                    finish_reason: finishReason,
+                                                    index: 0
+                                                }],
+                                                object: 'chat.completion.chunk'
+                                            };
+                                            res.write(`data: ${JSON.stringify(data)}\n\n`);
+                                        }
+                                    }
+                                }
+                            }
+
+                            if (candidate.finishReason && candidate.finishReason !== "STOP") {
+                                const errorMessage = {
+                                    error: {
+                                        code: "content_filter",
+                                        message: `模型的响应因违反内容政策而被标记：${candidate.finishReason}`,
+                                        status: candidate.finishReason,
+                                        details: []
+                                    }
+                                };
+                                logger.warning(`模型的响应因违反内容政策而被标记: ${candidate.finishReason}`);
+                                res.write(`data: ${JSON.stringify(errorMessage)}\n\n`);
+                                break;
+                            }
+
+                            if (candidate.safetyRatings) {
+                                let shouldBreak = false;
+                                for (const rating of candidate.safetyRatings) {
+                                    if (rating.probability === 'HIGH') {
+                                        const errorMessage = {
+                                            error: {
+                                                code: "content_filter",
+                                                message: `模型的响应因高概率被标记为 ${rating.category}`,
+                                                status: "SAFETY_RATING_HIGH",
+                                                details: [rating]
+                                            }
+                                        };
+                                        logger.warning(`模型的响应因高概率被标记为 ${rating.category}`);
+                                        res.write(`data: ${JSON.stringify(errorMessage)}\n\n`);
+                                        shouldBreak = true;
+                                        break;
+                                    }
+                                }
+                                if (shouldBreak) break;
+                            }
+                        }
+                    } catch (jsonError) {
+                        // If JSON parsing fails, just continue collecting data
+                        continue;
+                    }
+                } catch (e) {
+                    logger.error(`流式处理期间发生错误: ${e}, 原始数据行↙\n${line}`);
+                    res.write(`data: ${JSON.stringify({ error: String(e) })}\n\n`);
+                }
+            }
+        });
+
+        response.data.on('end', () => {
+            res.write(`data: ${JSON.stringify({
+                choices: [{ delta: {}, finish_reason: 'stop', index: 0 }]
+            })}\n\n`);
+            logger.info(`流式结束 ←`);
+            logger.info(`200!`);
+            res.end();
+        });
+
+        response.data.on('error', (err) => {
+            logger.error(`流式处理错误↙\n${err}`);
+            res.write(`data: ${JSON.stringify({ error: String(err) })}\n\n`);
+            res.end();
+        });
+    }
+
+    // Main request handler logic
+    let success = 0;
+    let response = null;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        logger.info(`第 ${attempt}/${MAX_RETRIES} 次尝试 ...`);
+        [success, response] = await doRequest(currentApiKey, attempt);
+
+        if (success === 0) {
+            continue;
+        } else if (success === 1 && response === null) {
+            continue;
+        } else if (success === 1 && stream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+
+            generateStream(response);
+            return;
+        } else if (success === 1 && response instanceof ResponseWrapper) {
+            try {
+                const textContent = response.text;
+                const promptTokens = response.promptTokenCount;
+                const completionTokens = response.candidatesTokenCount;
+                const totalTokens = response.totalTokenCount;
+                const finishReason = response.finishReason;
+
+                if (textContent === '') {
+                    let errorMessage = null;
+                    if (response._data && response._data.error) {
+                        errorMessage = response._data.error.message;
+                    }
+                    if (errorMessage) {
+                        logger.error(`生成内容失败，API 返回错误: ${errorMessage}`);
+                    } else {
+                        logger.error(`生成内容失败: text_content 为空`);
+                    }
+                    continue;
+                }
+
+                let finalContent = textContent;
+                if (isThinking && showThoughts) {
+                    finalContent = response.thoughts + '\n' + textContent;
+                }
+
+                const responseData = {
+                    id: 'chatcmpl-xxxxxxxxxxxx',
+                    object: 'chat.completion',
+                    created: Math.floor(Date.now() / 1000),
+                    model: model,
+                    choices: [{
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: finalContent
+                        },
+                        finish_reason: finishReason
+                    }],
+                    usage: {
+                        prompt_tokens: promptTokens,
+                        completion_tokens: completionTokens,
+                        total_tokens: totalTokens
+                    }
+                };
+
+                logger.info(`200!`);
+                return res.json(responseData);
+            } catch (err) {
+                logger.error(`处理响应失败: ${err}`);
+                continue;
+            }
+        } else if (success === 2) {
+            logger.error(`${model} 可能暂时不可用，请更换模型或未来一段时间再试`);
+            return res.status(503).json({
+                error: {
+                    message: `${model} 可能暂时不可用，请更换模型或未来一段时间再试`,
+                    type: 'internal_server_error'
+                }
+            });
+        }
+    }
+
+    logger.error(`${MAX_RETRIES} 次尝试均失败，请重试或等待官方恢复`);
+    return res.status(response ? 500 : 503).json({
+        error: {
+            message: `${MAX_RETRIES} 次尝试均失败，请重试或等待官方恢复`,
+            type: 'internal_server_error'
+        }
+    });
+});
+
+app.get('/hf/v1/models', (req, res) => {
+    const response = { "object": "list", "data": GEMINI_MODELS };
+    return res.json(response);
+});
+
+app.post('/hf/v1/embeddings', async (req, res) => {
+    const data = req.body;
+    const modelInput = data.input;
+    const model = data.model || "text-embedding-004";
+
+    if (!modelInput) {
+        return res.status(400).json({ error: "没有提供输入" });
+    }
+
+    const inputs = Array.isArray(modelInput) ? modelInput : [modelInput];
+
+    const geminiRequest = {
+        model: `models/${model}`,
+        content: {
+            parts: inputs.map(text => ({ text }))
+        }
+    };
+
+    const geminiUrl = `https://generativelanguage.googleapis.com/v1beta/models/${model}:embedContent?key=${currentApiKey}`;
+    const headers = { "Content-Type": "application/json" };
+
+    try {
+        const geminiResponse = await axios.post(geminiUrl, geminiRequest, { headers });
+
+        const embeddings = [];
+        if (geminiResponse.data.embedding) {
+            embeddings.push({
+                object: "embedding",
+                embedding: geminiResponse.data.embedding.values,
+                index: 0
+            });
+        } else if (geminiResponse.data.embeddings) {
+            geminiResponse.data.embeddings.forEach((embedding, i) => {
+                embeddings.push({
+                    object: "embedding",
+                    embedding: embedding.values,
+                    index: i
+                });
+            });
+        }
+
+        const clientResponse = {
+            object: "list",
+            data: embeddings,
+            model: model,
+            usage: {
+                prompt_tokens: 0,
+                total_tokens: 0
+            }
+        };
+
+        switchApiKey();
+        return res.json(clientResponse);
+    } catch (e) {
+        console.log(`请求Embeddings失败↙\: ${e}`);
+        return res.status(500).json({ error: String(e) });
+    }
+});
+
+// Start the server
+const PORT = process.env.PORT || 7860;
+app.listen(PORT, '0.0.0.0', () => {
+    const scheduler = Scheduler;
+
+    logger.info(`Reminiproxy v2.3.5 启动`);
+    logger.info(`最大尝试次数/MaxRetries: ${MAX_RETRIES}`);
+    logger.info(`最大请求次数/MaxRequests: ${MAX_REQUESTS}`);
+    logger.info(`请求限额窗口/LimitWindow: ${LIMIT_WINDOW} 秒`);
+    logger.info(`服务器运行在端口: ${PORT}`);
+});

package.json

@@ -0,0 +1,18 @@
+{
+    "name": "hf1sthesh1t",
+    "version": "2.3.5",
+    "description": "A simple and lightweight Node.js web application for HF1sthesh1t",
+    "main": "index.js",
+    "scripts": {
+        "start": "node index.js"
+    },
+    "dependencies": {
+        "axios": "^1.6.2",
+        "date-fns": "^2.30.0",
+        "express": "^4.18.2",
+        "node-schedule": "^2.1.1"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    }
+}