Refactor: Extract Gemini proxy logic into dedicated modules

Move core functionalities such as Gemini client management, session handling, image proxying, and API format conversion from `app/api/gemini_proxy.py` into new, dedicated modules:
- `app/core/`: For core logic like client and session management.
- `app/services/`: For specific services like image proxying.
- `app/utils/`: For utility functions like API format conversion.

This refactoring significantly improves code organization, maintainability, and separation of concerns, reducing the complexity of the main API endpoint file.

app/api/gemini_proxy.py

@@ -1,190 +1,39 @@
 # app/api/gemini_proxy.py
 
 import os  # 导入 os 模块用于读取环境变量
-import itertools  # 导入 itertools 模块用于循环 cookie
 import time
 import base64
-import re
 import logging
 import asyncio
-import uuid  # 导入 uuid 模块用于生成会话 ID
 import tempfile # 导入 tempfile 模块用于创建临时文件
 from fastapi import APIRouter, Request, HTTPException, Depends, status
-from cachetools import LRUCache  # 导入 LRU 缓存
 from fastapi.responses import JSONResponse
 from typing import Dict, Any, List, Optional
-from fastapi.responses import StreamingResponse # 导入 StreamingResponse
 
 # 导入自定义模块
 from app.api.auth import (
     get_user_api_key,
     get_admin_api_key,
-    get_auth_token, # 更改为 get_auth_token
+    get_auth_token,
 )  # 从 auth 模块导入认证依赖
 from app.api.metrics import (
     update_metrics_on_request,
     update_metrics_on_response,
     get_current_metrics,
 )  # 从 metrics 模块导入指标和记录获取函数
-from gemini_webapi import GeminiClient, ModelOutput
-import gemini_webapi.exceptions # 导入 gemini_webapi 的异常模块
-import httpx # 导入 httpx 模块
-
+from app.core.gemini_client_manager import get_gemini_client, reload_gemini_cookies # 从 core 模块导入 Gemini 客户端管理器
+from app.core.session_manager import (
+    Session,
+    get_or_create_session,
+    delete_session_by_id,
+    list_all_sessions,
+    cleanup_expired_sessions,
+) # 从 core 模块导入会话管理器
+from app.services.image_proxy_service import proxy_image_request # 从 services 模块导入图片代理服务
+from app.utils.gemini_converter import format_gemini_response_to_openai, convert_openai_messages_to_gemini_history # 从 utils 模块导入格式转换工具
 
 logger = logging.getLogger(__name__)
 
-# 定义需要跳过后端下载的域名，这些域名的图片将通过代理加载
-# 定义需要跳过后端下载的域名，这些域名的图片将通过代理加载
-SKIP_DOWNLOAD_DOMAINS = ["googleusercontent.com", "blogger.googleusercontent.com", "lh3.googleusercontent.com"]
-
-# 新的环境变量读取方式
-GEMINI_PSID_COOKIES_STR = os.getenv("GEMINI_PSID_COOKIES", "")
-GEMINI_PSIDTS_COOKIES_STR = os.getenv("GEMINI_PSIDTS_COOKIES", "")
-
-raw_psid_cookies = [c.strip() for c in GEMINI_PSID_COOKIES_STR.split(",") if c.strip()]
-raw_psidts_cookies = [
-    c.strip() for c in GEMINI_PSIDTS_COOKIES_STR.split(",") if c.strip()
-]
-
-gemini_cookie_pairs = []
-if raw_psid_cookies and raw_psidts_cookies:
-    if len(raw_psid_cookies) == len(raw_psidts_cookies):
-        valid_pairs = []
-        for sid, sidts in zip(raw_psid_cookies, raw_psidts_cookies):
-            if sid and sidts:  # Both must be non-empty
-                valid_pairs.append((sid, sidts))
-            else:
-                logger.warning(
-                    f"检测到无效的 Cookie 对 (一个或两个值为空): SID='{sid}', SIDTS='{sidts}'. 此对将被忽略。"
-                )
-
-        gemini_cookie_pairs = valid_pairs
-        if gemini_cookie_pairs:
-            logger.info(
-                f"成功加载并验证 {len(gemini_cookie_pairs)} 组 Gemini Cookie 对。"
-            )
-        else:
-            logger.warning(
-                "所有提供的 Cookie 对均无效 (一个或两个值为空) 或 GEMINI_PSID_COOKIES / GEMINI_PSIDTS_COOKIES 列表长度匹配但内容无效。"
-            )
-    else:
-        logger.warning(
-            "GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量中的 Cookie 数量不匹配。请检查配置。"
-        )
-else:
-    if not raw_psid_cookies and not raw_psidts_cookies:
-        logger.warning(
-            "GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量均未设置或为空。Gemini API 调用可能会失败。"
-        )
-    elif not raw_psid_cookies:
-        logger.warning(
-            "GEMINI_PSID_COOKIES 环境变量未设置或为空，但 GEMINI_PSIDTS_COOKIES 可能已设置。Cookie 对不完整或无效。"
-        )
-    else:  # not raw_psidts_cookies
-        logger.warning(
-            "GEMINI_PSIDTS_COOKIES 环境变量未设置或为空，但 GEMINI_PSID_COOKIES 可能已设置。Cookie 对不完整或无效。"
-        )
-
-# 全局变量，用于存储 cookie 轮询器和客户端实例
-cookie_cycler = itertools.cycle(gemini_cookie_pairs) if gemini_cookie_pairs else None
-gemini_clients: Dict[str, GeminiClient] = {} # 存储 {auth_token: GeminiClient实例}
-
-# 每个认证令牌的最大会话数
-MAX_SESSIONS_PER_TOKEN = 5
-
-# 会话数据结构
-class Session:
-    def __init__(self, thread_id, name=None):
-        self.thread_id = thread_id
-        self.name = name or f"会话-{time.strftime('%m%d')}-{str(uuid.uuid4())[:4]}"
-        self.created_at = time.time()
-        self.last_active = time.time()
-        self._chat_instance = None  # 新增：存储 Gemini Chat 实例
-
-# 全局变量，用于存储每个认证令牌的聊天会话
-chat_sessions: Dict[str, Dict[str, Session]] = {}
-
-def cleanup_expired_sessions(auth_token: str):
-    """清理过期会话（24小时未活动）和超出限制的会话"""
-    now = time.time()
-    sessions = chat_sessions.get(auth_token, {})
-    
-    # 清理超过24小时的会话
-    expired_threads = [
-        tid for tid, session in sessions.items()
-        if now - session.last_active > 86400
-    ]
-    for tid in expired_threads:
-        del sessions[tid]
-    
-    # 清理超出数量限制的旧会话
-    if len(sessions) > MAX_SESSIONS_PER_TOKEN:
-        oldest = sorted(sessions.items(), key=lambda x: x[1].last_active)[0]
-        del sessions[oldest[0]]
-    
-    return sessions
-
-def reload_gemini_cookies():
-    """
-    重新加载 Gemini Cookies 环境变量并重新初始化 cookie 轮询器。
-    此函数应在需要刷新 cookies 时调用。
-    """
-    global gemini_cookie_pairs, cookie_cycler, gemini_clients # 声明为全局变量以便修改
-
-    logger.info("开始重新加载 Gemini Cookies...")
-
-    # 重新读取环境变量
-    new_psid_cookies_str = os.getenv("GEMINI_PSID_COOKIES", "")
-    new_psidts_cookies_str = os.getenv("GEMINI_PSIDTS_COOKIES", "")
-
-    new_raw_psid_cookies = [c.strip() for c in new_psid_cookies_str.split(",") if c.strip()]
-    new_raw_psidts_cookies = [c.strip() for c in new_psidts_cookies_str.split(",") if c.strip()]
-
-    new_gemini_cookie_pairs = []
-    if new_raw_psid_cookies and new_raw_psidts_cookies:
-        if len(new_raw_psid_cookies) == len(new_raw_psidts_cookies):
-            valid_pairs = []
-            for sid, sidts in zip(new_raw_psid_cookies, new_raw_psidts_cookies):
-                if sid and sidts:
-                    valid_pairs.append((sid, sidts))
-                else:
-                    logger.warning(
-                        f"重新加载时检测到无效的 Cookie 对 (一个或两个值为空): SID='{sid}', SIDTS='{sidts}'. 此对将被忽略。"
-                    )
-            new_gemini_cookie_pairs = valid_pairs
-            if new_gemini_cookie_pairs:
-                logger.info(
-                    f"成功重新加载并验证 {len(new_gemini_cookie_pairs)} 组 Gemini Cookie 对。"
-                )
-            else:
-                logger.warning(
-                    "重新加载时所有提供的 Cookie 对均无效或列表长度匹配但内容无效。"
-                )
-        else:
-            logger.warning(
-                "重新加载时 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量中的 Cookie 数量不匹配。请检查配置。"
-            )
-    else:
-        logger.warning(
-            "重新加载时 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量均未设置或为空。Gemini API 调用可能会失败。"
-        )
-
-    gemini_cookie_pairs = new_gemini_cookie_pairs
-    cookie_cycler = itertools.cycle(gemini_cookie_pairs) if gemini_cookie_pairs else None
-
-    # 清空所有现有的 GeminiClient 实例，强制下次请求时重新初始化
-    gemini_clients.clear()
-    logger.info("所有现有 GeminiClient 实例已清空，将在下次请求时重新初始化。")
-    logger.info("Gemini Cookies 重新加载完成。")
-
-# 在应用启动时调用一次，确保初始加载
-reload_gemini_cookies()
-
-DEFAULT_IMAGE_MIME_TYPE = "image/jpeg"  # 默认图片MIME类型
-
-# 创建 APIRouter 实例
-router = APIRouter()
-
 # 创建 APIRouter 实例
 router = APIRouter()
 
@@ -200,377 +49,43 @@ async def refresh_gemini_cookies_endpoint(admin_token: str = Depends(get_admin_a
     reload_gemini_cookies()
     return JSONResponse(content={"status": "ok", "message": "Gemini Cookies 已重新加载，所有客户端实例已清空。"})
 
-
-def parse_gemini_cookies(cookie_string: str) -> tuple[Optional[str], Optional[str]]:
-    """
-    解析 Gemini Cookie 字符串，提取 __Secure-1PSID 和 __Secure-1PSIDTS。
-    Args:
-        cookie_string: 包含 Gemini Cookies 的字符串，例如 "cookie1=value1; __Secure-1PSID=sid_value; cookie2=value2; __Secure-1PSIDTS=sidts_value"
-    Returns:
-        包含 (sid, sidts) 的元组，如果未找到则为 (None, None)。
-    """
-    sid = None
-    sidts = None
-    cookies = cookie_string.split(";")
-    for cookie in cookies:
-        parts = cookie.strip().split("=", 1)
-        if len(parts) == 2:
-            name, value = parts
-            if name == "__Secure-1PSID":
-                sid = value
-            elif name == "__Secure-1PSIDTS":
-                sidts = value
-    return sid, sidts
-
-
-def get_next_gemini_cookie_tuple() -> Optional[tuple[str, str]]:
-    """获取下一组可用的 Gemini Cookie (SID, SIDTS) 元组。"""
-    if not cookie_cycler:
-        # Extensive logging during gemini_cookie_pairs creation should cover most scenarios.
-        # This check is a final safeguard if cookie_cycler is None (no valid cookies loaded).
-        return None
-
-    try:
-        # Directly from cycler, which contains pre-validated (sid, sidts) pairs
-        return next(cookie_cycler)
-    except StopIteration:
-        # This case implies gemini_cookie_pairs was empty, leading to cookie_cycler being None,
-        # which should be caught by the 'if not cookie_cycler:' check above.
-        # If somehow StopIteration is raised here with a non-None cookie_cycler, it's an unexpected state.
-        logger.error(
-            "Gemini Cookie 轮询器意外耗尽或无法获取下一个元素。这可能表明初始化的 gemini_cookie_pairs 为空或所有元素均无效，尽管 cookie_cycler 不是 None。"
-        )
-        return None
-    except Exception as e:
-        logger.error(f"获取下一组 Gemini Cookie 时发生意外错误: {e}", exc_info=True)
-        return None
-
-
-async def format_gemini_response_to_openai(gemini_output: ModelOutput) -> Dict[str, Any]:
-    """
-    将 gemini-webapi 的 ModelOutput 格式转换为 OpenAI API 的聊天完成响应格式。
-    这里只实现核心字段的转换。
-    """
-    openai_response = {
-        "id": "chatcmpl-placeholder",  # 占位符
-        "object": "chat.completion",
-        "created": int(time.time()),
-        "model": "gemini-pro",  # 假设都使用 gemini-pro
-        "choices": [],
-        "usage": {  # 占位符，gemini-webapi 可能不提供详细 usage
-            "prompt_tokens": 0,
-            "completion_tokens": 0,
-            "total_tokens": 0,
-        },
-    }
-
-    content_parts = []
-    image_data_urls = []  # 用于存储 Base64 编码的图片 Data URL 列表
-
-    # 定义需要跳过后端下载的域名
-    # 这里的 SKIP_DOWNLOAD_DOMAINS 应该用于决定是否直接转换为代理 URL，而不是尝试下载
-    # 统一处理所有 googleusercontent.com 和 lh3.googleusercontent.com 的图片通过代理
-    PROXY_IMAGE_DOMAINS = ["googleusercontent.com", "blogger.googleusercontent.com", "lh3.googleusercontent.com"]
-
-    if gemini_output:
-        if gemini_output.text:
-            original_text = gemini_output.text
-            logger.info(f"Gemini 原始文本内容: {original_text[:200]}...") # 记录原始文本内容，截取前200字符
-
-            # 提取 Markdown 格式的图片链接和纯 URL 格式的图片链接
-            markdown_image_regex = r"!\[.*?\]\((https?:\/\/[^\s)]+)\)"
-            direct_image_url_regex = r"(https?:\/\/(?:lh3\.)?googleusercontent\.com\/(?:image_generation_content|gg-dl|image_collection\/image_retrieval)\/[^\s]+)"
-
-            # 存储所有从文本中提取的图片 URL
-            all_extracted_urls_from_text = []
-
-            # 第一次匹配：Markdown 格式的图片链接
-            temp_text_after_markdown_extraction = original_text
-            markdown_matches = re.findall(markdown_image_regex, temp_text_after_markdown_extraction)
-            for url in markdown_matches:
-                all_extracted_urls_from_text.append(url)
-            temp_text_after_markdown_extraction = re.sub(markdown_image_regex, '', temp_text_after_markdown_extraction)
-
-            # 第二次匹配：纯 URL 格式的图片链接
-            direct_url_matches = re.findall(direct_image_url_regex, temp_text_after_markdown_extraction)
-            for url in direct_url_matches:
-                all_extracted_urls_from_text.append(url)
-            temp_text_after_direct_url_extraction = re.sub(direct_image_url_regex, '', temp_text_after_markdown_extraction)
-
-            content_parts.append(temp_text_after_direct_url_extraction.strip()) # 将处理后的文本添加到内容部分
-
-            # 处理从文本中提取的图片
-            if all_extracted_urls_from_text:
-                logger.info(f"从文本中检测到图片 URL: {all_extracted_urls_from_text}")
-                async with httpx.AsyncClient(follow_redirects=True, trust_env=True, max_redirects=100) as client: # 增加最大重定向次数
-                    headers = {
-                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36",
-                        "Referer": "https://gemini.google.com/",
-                    }
-                    for i, image_url in enumerate(all_extracted_urls_from_text):
-                        # 判断是否属于需要代理的域名
-                        should_proxy = any(domain in image_url for domain in PROXY_IMAGE_DOMAINS)
-
-                        if should_proxy:
-                            logger.warning(f"图片 URL 属于代理域名 ({image_url})，将通过代理加载。")
-                            proxied_url = f"/v1/image_proxy?image_url={image_url}"
-                            image_data_urls.append(proxied_url)
-                            continue # 跳过直接下载逻辑
-
-                        # 否则，尝试直接下载并转换为 Base64
-                        try:
-                            logger.info(f"尝试直接下载文本中的图片: {image_url}")
-                            response = await client.get(image_url, timeout=60, headers=headers)
-                            response.raise_for_status()
-                            image_bytes = response.content
-
-                            mime_type = response.headers.get("Content-Type", "application/octet-stream").split(';')[0].strip()
-                            if not mime_type.startswith("image/"):
-                                ext = image_url.split('.')[-1].lower()
-                                if ext in ["jpg", "jpeg"]: mime_type = "image/jpeg"
-                                elif ext == "png": mime_type = "image/png"
-                                elif ext == "gif": mime_type = "image/gif"
-                                elif ext == "webp": mime_type = "image/webp"
-                                else:
-                                    logger.warning(f"文本中的图片 {image_url} 的 MIME 类型未知或非图片类型: {mime_type}，尝试使用 image/jpeg 作为默认。")
-                                    mime_type = "image/jpeg"
-
-                            base64_image = base64.b64encode(image_bytes).decode("utf-8")
-                            data_url = f"data:{mime_type};base64,{base64_image}"
-                            image_data_urls.append(data_url)
-                            logger.info(f"成功下载并转换文本中的图片 {i+1} ({image_url}) 为 Base64 Data URL (MIME: {mime_type})")
-                        except httpx.RequestError as e:
-                            logger.error(f"直接下载文本中的图片失败 (RequestError): URL: {image_url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-                        except httpx.HTTPStatusError as e:
-                            logger.error(f"直接下载文本中的图片失败 (HTTPStatusError): URL: {image_url}, 状态码: {e.response.status_code}, 响应文本: {e.response.text}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-                        except Exception as e:
-                            logger.error(f"处理文本中的图片时发生未知错误: URL: {image_url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-
-        # 处理 gemini_output.images，如果存在图片，将其下载并转换为 Base64 Data URL
-        if gemini_output.images:
-            logger.info(f"检测到 Gemini 返回图片列表: {[img.url for img in gemini_output.images if img.url]}")
-            async with httpx.AsyncClient(follow_redirects=True, trust_env=True, max_redirects=100) as client: # 增加最大重定向次数
-                headers = {
-                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36",
-                    "Referer": "https://gemini.google.com/",
-                }
-                for i, image in enumerate(gemini_output.images):
-                    if image.url:
-                        # 判断是否属于需要代理的域名
-                        should_proxy = any(domain in image.url for domain in PROXY_IMAGE_DOMAINS)
-
-                        if should_proxy:
-                            logger.warning(f"图片 URL 属于代理域名 (来自gemini_output.images) ({image.url})，将通过代理加载。")
-                            proxied_url = f"/v1/image_proxy?image_url={image.url}"
-                            image_data_urls.append(proxied_url)
-                            continue # 跳过直接下载逻辑
-
-                        # 否则，尝试直接下载并转换为 Base64
-                        try:
-                            logger.info(f"尝试直接下载图片 (来自gemini_output.images): {image.url}")
-                            response = await client.get(image.url, timeout=60, headers=headers)
-                            response.raise_for_status()
-                            image_bytes = response.content
-
-                            mime_type = response.headers.get("Content-Type", "application/octet-stream").split(';')[0].strip()
-                            if not mime_type.startswith("image/"):
-                                ext = image.url.split('.')[-1].lower()
-                                if ext in ["jpg", "jpeg"]: mime_type = "image/jpeg"
-                                elif ext == "png": mime_type = "image/png"
-                                elif ext == "gif": mime_type = "image/gif"
-                                elif ext == "webp": mime_type = "image/webp"
-                                else:
-                                    logger.warning(f"图片 {image.url} 的 MIME 类型未知或非图片类型: {mime_type}，尝试使用 image/jpeg 作为默认。")
-                                    mime_type = "image/jpeg"
-
-                            base64_image = base64.b64encode(image_bytes).decode("utf-8")
-                            data_url = f"data:{mime_type};base64,{base64_image}"
-                            image_data_urls.append(data_url)
-                            logger.info(f"成功下载并转换图片 {i+1} (来自gemini_output.images) ({image.url}) 为 Base64 Data URL (MIME: {mime_type})")
-                        except httpx.RequestError as e:
-                            logger.error(f"直接下载图片失败 (RequestError, 来自gemini_output.images): URL: {image.url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-                        except httpx.HTTPStatusError as e:
-                            logger.error(f"直接下载图片失败 (HTTPStatusError, 来自gemini_output.images): URL: {image.url}, 状态码: {e.response.status_code}, 响应文本: {e.response.text}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-                        except Exception as e:
-                            logger.error(f"处理图片时发生未知错误 (来自gemini_output.images): URL: {image.url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
-                            image_data_urls.append("") # 下载失败时，返回空字符串
-        else:
-            logger.info("Gemini 返回的 ModelOutput 中没有检测到 'images' 字段或其为空。")
-
-    # 将所有内容部分合并
-    content = "\n\n".join(content_parts).strip()
-    logger.info(f"最终合并的文本内容: {content[:200]}...") # 记录最终合并的文本内容
-    logger.info(f"最终 Base64 图片 Data URL 数量: {len(image_data_urls)}") # 记录最终图片数量
-
-    if not content: # 如果没有文本内容
-        if image_data_urls: # 但有图片 URL
-            logger.warning("Gemini API 返回了图片但没有文本内容。")
-            content = "无响应文本" # 提示改为“无响应文本”
-            finish_reason = "stop" # 仍然是正常停止
-        else: # 既没有文本内容也没有图片 URL
-            logger.warning("Gemini API 返回了空文本响应且没有图片。")
-            content = "Gemini API 返回了空响应或内容处理失败"
-            finish_reason = "length"
-    else:
-        finish_reason = "stop"
-
-    message_content = {"role": "assistant", "content": content}
-    if image_data_urls:  # 如果有 Base64 图片 Data URL，添加到 message 中
-        message_content["image_urls"] = image_data_urls  # 仍然使用 image_urls 字段名，前端无需修改
-
-    openai_response["choices"] = [
-        {
-            "index": 0,
-            "message": message_content,
-            "finish_reason": finish_reason,
-        }
-    ]
-
-    return openai_response
-
-
 @router.get("/image_proxy", summary="图片代理接口")
-async def image_proxy(image_url: str, request: Request):
+async def image_proxy_endpoint(image_url: str, request: Request):
     """
     代理图片下载，解决前端跨域或防盗链问题。
     """
-    logger.info(f"接收到图片代理请求: {image_url}")
-    
-    # 获取下一组Gemini Cookie
-    cookie_tuple = get_next_gemini_cookie_tuple()
-    cookies = {}
-    if cookie_tuple:
-        sid, sidts = cookie_tuple
-        cookies = {
-            "__Secure-1PSID": sid,
-            "__Secure-1PSIDTS": sidts
-        }
-        logger.info(f"使用Cookie代理图片下载: sid={sid[:5]}..., sidts={sidts[:5]}...")
-    
-    # 设置更安全的请求头
-    headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
-        "Accept": "image/webp,image/apng,image/*,*/*;q=0.8",
-        "Accept-Language": "en-US,en;q=0.9",
-        "Referer": "https://gemini.google.com/",
-        "Sec-Fetch-Dest": "image",
-        "Sec-Fetch-Mode": "no-cors",
-        "Sec-Fetch-Site": "same-origin",
-    }
-    
-    async with httpx.AsyncClient(
-        follow_redirects=True, 
-        trust_env=False,  # 禁用环境代理
-        max_redirects=5,  # 减少最大重定向次数
-        cookies=cookies,
-        http2=True  # 启用HTTP/2
-    ) as client:
-        try:
-            # 添加详细日志
-            logger.debug(f"开始代理下载图片: {image_url}")
-            response = await client.get(image_url, timeout=30, headers=headers)
-            response.raise_for_status()
-            
-            # 记录响应详情
-            logger.info(f"图片代理成功: URL={image_url}, 状态码={response.status_code}, 类型={response.headers.get('Content-Type')}")
-            
-            # 返回流式响应
-            return StreamingResponse(
-                content=response.iter_bytes(),
-                media_type=response.headers.get("Content-Type", "image/jpeg"),
-                headers={
-                    "Cache-Control": "public, max-age=86400",  # 缓存一天
-                    "Access-Control-Allow-Origin": "*"
-                }
-            )
-        except httpx.HTTPStatusError as e:
-            logger.error(f"代理下载图片失败: URL: {image_url}, 状态码: {e.response.status_code}")
-            # 返回错误响应
-            return JSONResponse(
-                status_code=e.response.status_code,
-                content={"error": f"代理下载失败: {e.response.status_code}"}
-            )
-        except httpx.TooManyRedirects:
-            logger.error(f"代理下载图片重定向过多: URL: {image_url}")
-            return JSONResponse(
-                status_code=400,
-                content={"error": "图片重定向过多，无法下载"}
-            )
-        except (httpx.RequestError, Exception) as e:
-            logger.error(f"代理下载图片失败: URL: {image_url}, 错误: {type(e).__name__} - {e}")
-            # 返回一个透明的 1x1 像素 GIF 图片作为占位符
-            transparent_gif_base64 = "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
-            transparent_gif_bytes = base64.b64decode(transparent_gif_base64)
-            from fastapi.responses import Response # 导入 Response 类
-            return Response(
-                content=transparent_gif_bytes,
-                media_type="image/gif",
-                headers={
-                    "Cache-Control": "public, max-age=60",  # 短时间缓存
-                    "Access-Control-Allow-Origin": "*"  # 允许跨域
-                }
-            )
+    return await proxy_image_request(image_url, request)
 
-
-def convert_openai_messages_to_gemini_history(
-    messages: List[Dict[str, Any]],
-) -> List[Any]:
-    """
-    尝试将 OpenAI API 的 messages 格式转换为 gemini-webapi 的历史格式。
-    由于 gemini_webapi 库的 send_message 方法不直接接受历史，
-    此函数将提取所有消息内容并合并为一个字符串。
-    """
-    history_text = ""
-    for message in messages:
-        role = message.get("role")
-        content = message.get("content")
-        if role and content:
-            history_text += f"{role}: {content}\n"
-    logger.info(f"将消息历史合并为文本: {history_text[:200]}...")
-    return history_text
-
-
-# OpenAI 兼容接口 (核心功能待实现)
 @router.post("/sessions", summary="创建新会话")
-async def create_session(auth_token: str = Depends(get_auth_token)):
+async def create_session_endpoint(auth_token: str = Depends(get_auth_token)):
     """创建新会话并返回会话ID"""
     # 清理过期会话
-    sessions = cleanup_expired_sessions(auth_token)
+    cleanup_expired_sessions(auth_token)
     
+    # 获取 Gemini 客户端实例
+    try:
+        client = await get_gemini_client(auth_token)
+    except Exception as e:
+        raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+
     # 创建新会话
-    thread_id = str(uuid.uuid4())
-    sessions[thread_id] = Session(thread_id)
-    chat_sessions[auth_token] = sessions
+    session = get_or_create_session(auth_token, None, client) # thread_id 为 None 表示创建新会话
     
     return JSONResponse({
-        "thread_id": thread_id,
-        "name": sessions[thread_id].name
+        "thread_id": session.thread_id,
+        "name": session.name
     })
 
 @router.get("/sessions", summary="获取会话列表")
-async def list_sessions(auth_token: str = Depends(get_auth_token)):
+async def list_sessions_endpoint(auth_token: str = Depends(get_auth_token)):
     """获取当前认证令牌下的会话列表"""
-    sessions = cleanup_expired_sessions(auth_token)
-    return JSONResponse([
-        {
-            "thread_id": tid,
-            "name": session.name,
-            "created_at": session.created_at,
-            "last_active": session.last_active
-        } for tid, session in sessions.items()
-    ])
+    sessions_list = list_all_sessions(auth_token)
+    return JSONResponse(sessions_list)
 
 @router.delete("/sessions/{thread_id}", summary="删除会话")
-async def delete_session(thread_id: str, auth_token: str = Depends(get_auth_token)):
+async def delete_session_endpoint(thread_id: str, auth_token: str = Depends(get_auth_token)):
     """删除指定会话"""
-    sessions = chat_sessions.get(auth_token, {})
-    if thread_id in sessions:
-        del sessions[thread_id]
+    if delete_session_by_id(auth_token, thread_id):
         return JSONResponse({"status": "deleted"})
     raise HTTPException(status_code=404, detail="Session not found")
 
@@ -588,52 +103,13 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
     update_metrics_on_request(auth_token, client_host) # 使用 auth_token
 
     try:
-        # 从请求体中获取 Gemini cookies 和 OpenAI 格式的请求
+        # 从请求体中获取 OpenAI 格式的请求
         request_body = await request.json()
-        # 从环境变量或轮询器中获取 Gemini cookies
-        cookie_tuple = get_next_gemini_cookie_tuple()
-        if not cookie_tuple:
-            logger.error("未配置有效的 Gemini Cookies (GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES)。请检查环境变量。")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail="服务端未配置有效的 Gemini Cookies，无法连接到 Gemini API。",
-            )
-        sid, sidts = cookie_tuple
-
-        # --- 完善 GeminiClient 的初始化和管理逻辑 ---
-        # 每个认证令牌对应一个 GeminiClient 实例，该实例内部会管理会话
-        # 客户端的 cookie 轮询逻辑应该在 GeminiClient 内部处理，或者在创建客户端时就确定
-        # 这里简化为每个认证令牌维护一个 GeminiClient 实例，并尝试复用
-        client = gemini_clients.get(auth_token) # 使用 auth_token
-
-        if client:
-            logger.info(f"认证令牌 {auth_token} 复用现有 GeminiClient 实例") # 使用 auth_token
-            # 理论上，如果客户端已经存在，其内部的 cookie 应该已经通过轮询器设置
-            # 如果需要强制刷新 cookie，可以在这里重新 init，但会增加开销
-            # 暂时不重新 init，依赖于初始化的 cookie_cycler
-            pass
-        else:
-            logger.info(f"认证令牌 {auth_token} 创建新的 GeminiClient 实例") # 使用 auth_token
-            try:
-                # 创建新的 GeminiClient 实例，使用从轮询器获取的 cookie
-                client = GeminiClient(sid, sidts)
-                await client.init(timeout=30)  # 设置初始化超时时间
-                gemini_clients[auth_token] = client  # 存储新的客户端实例，使用 auth_token
-                logger.info(f"认证令牌 {auth_token} 成功初始化并存储 GeminiClient") # 使用 auth_token
-            except Exception as client_init_error:
-                logger.error(
-                    f"认证令牌 {auth_token} 初始化 GeminiClient 失败: {client_init_error}", # 使用 auth_token
-                    exc_info=True,
-                )
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail=f"初始化 Gemini 客户端失败: {client_init_error}。请检查 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 是否有效。",
-                )
-        # --- 客户端管理逻辑结束 ---
+        
+        # 获取 Gemini 客户端实例
+        client = await get_gemini_client(auth_token)
 
         # 解析 OpenAI 格式的请求体
-        # 提取 OpenAI 兼容的参数
-        # 提取 OpenAI 兼容的参数
         model_name = request_body.get("model", "gemini-2.5-flash")  # 默认模型改为 gemini-2.5-flash
         
         # 模型名称映射
@@ -648,7 +124,6 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
         temperature = request_body.get("temperature")
         max_tokens = request_body.get("max_tokens")
         top_p = request_body.get("top_p")  # 提取 top_p 参数
-        # frequency_penalty, presence_penalty 等参数在 gemini-webapi 文档中未明确提及，暂不映射。
 
         thread_id = request_body.get("thread_id")  # 提取会话 ID
 
@@ -657,55 +132,12 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
                 status_code=status.HTTP_400_BAD_REQUEST, detail="缺少 messages 参数"
             )
 
-        # --- 多轮对话管理 ---
         # 获取或创建用户对应的会话
-        sessions = chat_sessions.get(auth_token, {})
-        if not sessions:
-            sessions = {}
-            chat_sessions[auth_token] = sessions
-
-        # 如果没有提供 thread_id，生成一个新的
-        if not thread_id:
-            thread_id = str(uuid.uuid4())
-            sessions[thread_id] = Session(thread_id)
-            logger.info(f"认证令牌 {auth_token} 生成新会话: {thread_id}")
-
-        # 获取现有会话
-        session = sessions.get(thread_id)
-        chat = None # 确保 chat 变量在所有路径中都被初始化
-
-        # 确保 session 存在且 _chat_instance 已初始化
-        if not session or not session._chat_instance: # 检查 session 是否存在或 _chat_instance 是否为 None
-            logger.info(f"认证令牌 {auth_token} 会话 {thread_id} 不存在或聊天实例未初始化，创建新会话/初始化聊天实例")
-            if not session: # 如果 session 也不存在，则创建
-                session = Session(thread_id)
-                sessions[thread_id] = session
-            
-            # 无论 session 是否新创建，都初始化 chat 实例
-            chat = client.start_chat(model=model_name)
-            session._chat_instance = chat
-            logger.info(f"认证令牌 {auth_token} 会话 {thread_id} 聊天实例初始化成功")
-        else:
-            chat = session._chat_instance
-            session.last_active = time.time()
-            logger.info(f"认证令牌 {auth_token} 复用现有会话 {thread_id}")
-
-            # 如果客户端在复用会话时仍发送了历史消息，记录一个警告，因为我们将使用会话中已��的历史。
-            # 更复杂的逻辑可以尝试合并或验证历史，但目前简化处理。
-            # 这里的逻辑是，如果会话已存在，我们假设其历史是完整的，不再处理请求中的历史消息。
-            # 如果需要支持客户端在复用会话时更新历史，需要更复杂的逻辑。
-            if messages[:-1]: # 如果除了最后一条消息外还有其他消息，说明客户端尝试发送历史
-                logger.warning(
-                    f"认证令牌 {auth_token} 会话 {thread_id}: 复用现有会话，但请求中包含历史消息。将忽略请求中的历史，使用会话的当前历史。" # 使用 auth_token
-                )
+        session = get_or_create_session(auth_token, thread_id, client)
+        chat = session._chat_instance # 获取聊天实例
 
         # 构建完整的对话历史文本
-        history_text = ""
-        for message in messages:
-            role = message.get("role")
-            content = message.get("content")
-            if role and content:
-                history_text += f"{role}: {content}\n"
+        history_text = convert_openai_messages_to_gemini_history(messages[:-1]) # 排除最后一条消息作为历史
 
         # 获取最后一条用户消息作为当前输入
         current_user_message = messages[-1]
@@ -727,7 +159,6 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
                 item_type = item.get("type")
                 if item_type == "text":
                     current_message_text += item.get("text", "") + "\n"
-                # 注意：这里不再处理 image_url，因为前端会单独发送 base64 数据
             current_message_text = current_message_text.strip()
         else:
             raise HTTPException(
@@ -743,9 +174,6 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
         if image_data_b64 and image_mime_type:
             try:
                 image_bytes = base64.b64decode(image_data_b64)
-                # 创建临时文件
-                # tempfile.NamedTemporaryFile 默认以二进制模式打开，并返回文件对象
-                # delete=False 确保文件在关闭后不会立即删除，我们手动删除
                 with tempfile.NamedTemporaryFile(delete=False, suffix=f".{image_mime_type.split('/')[-1]}") as temp_file:
                     temp_file.write(image_bytes)
                     temp_file_path = temp_file.name
@@ -758,7 +186,7 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
                 )
 
         # 将历史消息和当前输入合并
-        prompt_text = history_text + f"user: {user_input_content}"
+        prompt_text = history_text + f"user: {current_message_text}" # 使用 current_message_text
 
         # 调用 gemini-webapi 发送消息，并添加重试逻辑
         gemini_response = None
@@ -787,81 +215,49 @@ async def create_chat_completion(request: Request, auth_token: str = Depends(get
                     )
                 # 如果调用成功，跳出重试循环
                 break
-            except (gemini_webapi.exceptions.TimeoutError, httpx.ReadTimeout) as e:
-                # 捕获超时错误，进行重试
+            except (Exception) as e: # 捕获所有异常，包括超时
                 if attempt < max_retries - 1:
                     logger.warning(
-                        f"认证令牌 {auth_token} 会话 {thread_id} 调用 Gemini API 超时 (尝试 {attempt + 1}/{max_retries})，将在 {retry_delay} 秒后重试: {e}" # 使用 auth_token
+                        f"认证令牌 {auth_token} 会话 {session.thread_id} 调用 Gemini API 失败 (尝试 {attempt + 1}/{max_retries})，将在 {retry_delay} 秒后重试: {e}"
                     )
                     await asyncio.sleep(retry_delay)
                 else:
-                    # 重试次数耗尽，记录错误并抛出异常
                     logger.error(
-                        f"认证令牌 {auth_token} 会话 {thread_id} 调用 Gemini API 失败，重试次数耗尽: {e}", # 使用 auth_token
+                        f"认证令牌 {auth_token} 会话 {session.thread_id} 调用 Gemini API 失败，重试次数耗尽: {e}",
                         exc_info=True,
                     )
-                    # 发生异常时，考虑移除当前会话，避免无效会话残留
-                    if (
-                        thread_id
-                        and auth_token in chat_sessions # 使用 auth_token
-                        and thread_id in chat_sessions[auth_token] # 使用 auth_token
-                    ):
-                        del chat_sessions[auth_token][thread_id] # 使用 auth_token
-                        logger.info(f"认证令牌 {auth_token} 会话 {thread_id} 因错误已移除") # 使用 auth_token
+                    # 发生异常时，移除当前会话，避免无效会话残留
+                    delete_session_by_id(auth_token, session.thread_id)
                     raise HTTPException(
                         status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                         detail=f"Gemini API 调用失败，重试次数耗尽: {e}",
                     )
-            except Exception as gemini_error:
-                # 捕获其他类型的异常，记录错误并抛出
-                logger.error(
-                    f"认证令牌 {auth_token} 会话 {thread_id} 调用 Gemini API 失败: {gemini_error}", # 使用 auth_token
-                    exc_info=True,
-                )
-                # 发生异常时，考虑移除当前会话，避免无效会话残留
-                if (
-                    thread_id
-                    and auth_token in chat_sessions # 极客学编程
-                    and thread_id in chat_sessions[auth_token] # 使用 auth_token
-                ):
-                    del chat_sessions[auth_token][thread_id] # 使用 auth_token
-                    logger.info(f"认证令牌 {auth_token} 会话 {thread_id} 因错误已移除") # 使用 auth_token
-                raise HTTPException(
-                    status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                    detail=f"Gemini API 调用失败: {gemini_error}",
-                )
 
         if not gemini_response:
-            # 如果循环结束但 gemini_response 仍然是 None (理论上不会发生，除非所有重试都捕获了异常但没有抛出)
-            logger.error(f"认证令牌 {auth_token} 会话 {thread_id} 调用 Gemini API 未返回响应，尽管没有捕获到异常。") # 使用 auth_token
+            logger.error(f"认证令牌 {auth_token} 会话 {session.thread_id} 调用 Gemini API 未返回响应，尽管没有捕获到异常。")
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                 detail="Gemini API 返回空响应",
             )
 
         # 将 gemini-webapi 响应转换为 OpenAI 格式
-        openai_response = await format_gemini_response_to_openai(gemini_response) # 添加 await
+        openai_response = await format_gemini_response_to_openai(gemini_response)
 
         # 记录成功调用
         end_time = time.time()
         response_time = end_time - start_time
-        update_metrics_on_response(auth_token, "success", response_time, client_host, request_body, openai_response) # 使用 auth_token
+        update_metrics_on_response(auth_token, "success", response_time, client_host, request_body, openai_response)
 
         # 返回 OpenAI 格式的响应
-        # 在响应中包含 thread_id，方便客户端继续同一会话
-        openai_response["thread_id"] = thread_id
+        openai_response["thread_id"] = session.thread_id
         return JSONResponse(content=openai_response)
 
     except HTTPException as e:
-        # 认证失败等 HTTPException 直接抛出
-        # 确保 request_body 在这里可用
-        update_metrics_on_response(auth_token, "failed", time.time() - start_time, client_host, request_body, {"detail": e.detail}) # 使用 auth_token
+        update_metrics_on_response(auth_token, "failed", time.time() - start_time, client_host, request_body, {"detail": e.detail})
         raise e
     except Exception as e:
-        # 记录其他异常
         logger.error(f"处理请求时发生错误: {e}", exc_info=True)
-        # 确保 request_body 在这里可用
-        update_metrics_on_response(auth_token, "failed", time.time() - start_time, client_host, request_body, {"detail": str(e)}) # 使用 auth_token
+        update_metrics_on_response(auth_token, "failed", time.time() - start_time, client_host, request_body, {"detail": str(e)})
         raise HTTPException(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail=f"内部服务器错误: {e}",

app/core/gemini_client_manager.py

@@ -0,0 +1,171 @@
+# app/core/gemini_client_manager.py
+
+import os  # 导入 os 模块用于读取环境变量
+import itertools  # 导入 itertools 模块用于循环 cookie
+import logging
+from typing import Dict, Any, List, Optional, Tuple
+from gemini_webapi import GeminiClient
+import gemini_webapi.exceptions # 导入 gemini_webapi 的异常模块
+import asyncio # 导入 asyncio 模块用于异步操作
+
+logger = logging.getLogger(__name__)
+
+# 新的环境变量读取方式
+GEMINI_PSID_COOKIES_STR = os.getenv("GEMINI_PSID_COOKIES", "")
+GEMINI_PSIDTS_COOKIES_STR = os.getenv("GEMINI_PSIDTS_COOKIES", "")
+
+raw_psid_cookies = [c.strip() for c in GEMINI_PSID_COOKIES_STR.split(",") if c.strip()]
+raw_psidts_cookies = [
+    c.strip() for c in GEMINI_PSIDTS_COOKIES_STR.split(",") if c.strip()
+]
+
+gemini_cookie_pairs: List[Tuple[str, str]] = []
+if raw_psid_cookies and raw_psidts_cookies:
+    if len(raw_psid_cookies) == len(raw_psidts_cookies):
+        valid_pairs = []
+        for sid, sidts in zip(raw_psid_cookies, raw_psidts_cookies):
+            if sid and sidts:  # Both must be non-empty
+                valid_pairs.append((sid, sidts))
+            else:
+                logger.warning(
+                    f"检测到无效的 Cookie 对 (一个或两个值为空): SID='{sid}', SIDTS='{sidts}'. 此对将被忽略。"
+                )
+
+        gemini_cookie_pairs = valid_pairs
+        if gemini_cookie_pairs:
+            logger.info(
+                f"成功加载并验证 {len(gemini_cookie_pairs)} 组 Gemini Cookie 对。"
+            )
+        else:
+            logger.warning(
+                "所有提供的 Cookie 对均无效 (一个或两个值为空) 或 GEMINI_PSID_COOKIES / GEMINI_PSIDTS_COOKIES 列表长度匹配但内容无效。"
+            )
+    else:
+        logger.warning(
+            "GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量中的 Cookie 数量不匹配。请检查配置。"
+        )
+else:
+    if not raw_psid_cookies and not raw_psidts_cookies:
+        logger.warning(
+            "GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量均未设置或为空。Gemini API 调用可能会失败。"
+        )
+    elif not raw_psid_cookies:
+        logger.warning(
+            "GEMINI_PSID_COOKIES 环境变量未设置或为空，但 GEMINI_PSIDTS_COOKIES 可能已设置。Cookie 对不完整或无效。"
+        )
+    else:  # not raw_psidts_cookies
+        logger.warning(
+            "GEMINI_PSIDTS_COOKIES 环境变量未设置或为空，但 GEMINI_PSID_COOKIES 可能已设置。Cookie 对不完整或无效。"
+        )
+
+# 全局变量，用于存储 cookie 轮询器和客户端实例
+cookie_cycler = itertools.cycle(gemini_cookie_pairs) if gemini_cookie_pairs else None
+gemini_clients: Dict[str, GeminiClient] = {} # 存储 {auth_token: GeminiClient实例}
+
+def reload_gemini_cookies():
+    """
+    重新加载 Gemini Cookies 环境变量并重新初始化 cookie 轮询器。
+    此函数应在需要刷新 cookies 时调用。
+    """
+    global gemini_cookie_pairs, cookie_cycler, gemini_clients # 声明为全局变量以便修改
+
+    logger.info("开始重新加载 Gemini Cookies...")
+
+    # 重新读取环境变量
+    new_psid_cookies_str = os.getenv("GEMINI_PSID_COOKIES", "")
+    new_psidts_cookies_str = os.getenv("GEMINI_PSIDTS_COOKIES", "")
+
+    new_raw_psid_cookies = [c.strip() for c in new_psid_cookies_str.split(",") if c.strip()]
+    new_raw_psidts_cookies = [c.strip() for c in new_psidts_cookies_str.split(",") if c.strip()]
+
+    new_gemini_cookie_pairs = []
+    if new_raw_psid_cookies and new_raw_psidts_cookies:
+        if len(new_raw_psid_cookies) == len(new_raw_psidts_cookies):
+            valid_pairs = []
+            for sid, sidts in zip(new_raw_psid_cookies, new_raw_psidts_cookies):
+                if sid and sidts:
+                    valid_pairs.append((sid, sidts))
+                else:
+                    logger.warning(
+                        f"重新加载时检测到无效的 Cookie 对 (一个或两个值为空): SID='{sid}', SIDTS='{sidts}'. 此对将被忽略。"
+                    )
+            new_gemini_cookie_pairs = valid_pairs
+            if new_gemini_cookie_pairs:
+                logger.info(
+                    f"成功重新加载并验证 {len(new_gemini_cookie_pairs)} 组 Gemini Cookie 对。"
+                )
+            else:
+                logger.warning(
+                    "重新加载时所有提供的 Cookie 对均无效或列表长度匹配但内容无效。"
+                )
+        else:
+            logger.warning(
+                "重新加载时 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量中的 Cookie 数量不匹配。请检查配置。"
+            )
+    else:
+        logger.warning(
+            "重新加载时 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量均未设置或为空。Gemini API 调用可能会失败。"
+        )
+
+    gemini_cookie_pairs = new_gemini_cookie_pairs
+    cookie_cycler = itertools.cycle(gemini_cookie_pairs) if gemini_cookie_pairs else None
+
+    # 清空所有现有的 GeminiClient 实例，强制下次请求时重新初始化
+    gemini_clients.clear()
+    logger.info("所有现有 GeminiClient 实例已清空，将在下次请求时重新初始化。")
+    logger.info("Gemini Cookies 重新加载完成。")
+
+def get_next_gemini_cookie_tuple() -> Optional[Tuple[str, str]]:
+    """获取下一组可用的 Gemini Cookie (SID, SIDTS) 元组。"""
+    if not cookie_cycler:
+        logger.error(
+            "Gemini Cookie 轮询器未初始化或为空。请检查 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 环境变量。"
+        )
+        return None
+
+    try:
+        return next(cookie_cycler)
+    except StopIteration:
+        logger.error(
+            "Gemini Cookie 轮询器意外耗尽。这可能表明初始化的 gemini_cookie_pairs 为空或所有元素均无效。"
+        )
+        return None
+    except Exception as e:
+        logger.error(f"获取下一组 Gemini Cookie 时发生意外错误: {e}", exc_info=True)
+        return None
+
+async def get_gemini_client(auth_token: str) -> GeminiClient:
+    """
+    获取或初始化与给定认证令牌关联的 GeminiClient 实例。
+    如果客户端不存在，则创建一个新的。
+    """
+    client = gemini_clients.get(auth_token)
+
+    if client:
+        logger.info(f"认证令牌 {auth_token} 复用现有 GeminiClient 实例。")
+        return client
+    else:
+        logger.info(f"认证令牌 {auth_token} 创建新的 GeminiClient 实例。")
+        cookie_tuple = get_next_gemini_cookie_tuple()
+        if not cookie_tuple:
+            logger.error("未配置有效的 Gemini Cookies。请检查环境变量。")
+            raise Exception("服务端未配置有效的 Gemini Cookies，无法连接到 Gemini API。")
+        sid, sidts = cookie_tuple
+
+        try:
+            client = GeminiClient(sid, sidts)
+            await client.init(timeout=30)  # 设置初始化超时时间
+            gemini_clients[auth_token] = client  # 存储新的客户端实例
+            logger.info(f"认证令牌 {auth_token} 成功初始化并存储 GeminiClient。")
+            return client
+        except Exception as client_init_error:
+            logger.error(
+                f"认证令牌 {auth_token} 初始化 GeminiClient 失败: {client_init_error}",
+                exc_info=True,
+            )
+            raise Exception(
+                f"初始化 Gemini 客户端失败: {client_init_error}。请检查 GEMINI_PSID_COOKIES 和 GEMINI_PSIDTS_COOKIES 是否有效。"
+            )
+
+# 在应用启动时调用一次，确保初始加载
+reload_gemini_cookies()

app/core/session_manager.py

@@ -0,0 +1,111 @@
+# app/core/session_manager.py
+
+import time
+import uuid  # 导入 uuid 模块用于生成会话 ID
+import logging
+from typing import Dict, Any, List, Optional
+from gemini_webapi import GeminiClient, ChatSession # 导入 ChatSession 类型
+
+logger = logging.getLogger(__name__)
+
+# 每个认证令牌的最大会话数
+MAX_SESSIONS_PER_TOKEN = 5
+
+# 会话数据结构
+class Session:
+    def __init__(self, thread_id: str, name: Optional[str] = None):
+        self.thread_id = thread_id
+        self.name = name or f"会话-{time.strftime('%m%d')}-{str(uuid.uuid4())[:4]}"
+        self.created_at = time.time()
+        self.last_active = time.time()
+        self._chat_instance: Optional[ChatSession] = None  # 存储 Gemini Chat 实例
+
+# 全局变量，用于存储每个认证令牌的聊天会话
+chat_sessions: Dict[str, Dict[str, Session]] = {}
+
+def cleanup_expired_sessions(auth_token: str):
+    """清理过期会话（24小时未活动）和超出限制的会话"""
+    now = time.time()
+    sessions = chat_sessions.get(auth_token, {})
+    
+    # 清理超过24小时的会话
+    expired_threads = [
+        tid for tid, session in sessions.items()
+        if now - session.last_active > 86400
+    ]
+    for tid in expired_threads:
+        logger.info(f"清理过期会话: {tid}")
+        del sessions[tid]
+    
+    # 清理超出数量限制的旧会话
+    if len(sessions) > MAX_SESSIONS_PER_TOKEN:
+        # 按照最后活跃时间排序，删除最旧的会话
+        oldest_sessions = sorted(sessions.items(), key=lambda x: x[1].last_active)
+        for i in range(len(sessions) - MAX_SESSIONS_PER_TOKEN):
+            tid_to_delete = oldest_sessions[i][0]
+            logger.info(f"清理超出限制的会话: {tid_to_delete}")
+            del sessions[tid_to_delete]
+    
+    chat_sessions[auth_token] = sessions # 确保更新全局字典
+    return sessions
+
+def get_or_create_session(auth_token: str, thread_id: Optional[str], client: GeminiClient) -> Session:
+    """
+    获取或创建一个新的聊天会话。
+    如果 thread_id 为 None，则创建一个新会话。
+    如果会话存在但其 _chat_instance 为 None，则重新初始化 _chat_instance。
+    """
+    sessions = chat_sessions.get(auth_token, {})
+    if not sessions:
+        sessions = {}
+        chat_sessions[auth_token] = sessions
+
+    session = None
+    if thread_id:
+        session = sessions.get(thread_id)
+
+    if not session:
+        thread_id = str(uuid.uuid4())
+        session = Session(thread_id)
+        sessions[thread_id] = session
+        logger.info(f"认证令牌 {auth_token} 生成新会话: {thread_id}")
+    
+    # 确保 chat 实例已初始化
+    if not session._chat_instance:
+        logger.info(f"认证令牌 {auth_token} 会话 {session.thread_id} 聊天实例未初始化，正在创建...")
+        session._chat_instance = client.start_chat() # 使用 client 启动聊天
+        logger.info(f"认证令牌 {auth_token} 会话 {session.thread_id} 聊天实例初始化成功。")
+    
+    session.last_active = time.time() # 更新最后活跃时间
+    return session
+
+def get_session(auth_token: str, thread_id: str) -> Optional[Session]:
+    """根据认证令牌和会话ID获取会话。"""
+    sessions = chat_sessions.get(auth_token)
+    if sessions:
+        session = sessions.get(thread_id)
+        if session:
+            session.last_active = time.time() # 更新最后活跃时间
+        return session
+    return None
+
+def delete_session_by_id(auth_token: str, thread_id: str) -> bool:
+    """根据认证令牌和会话ID删除会话。"""
+    sessions = chat_sessions.get(auth_token)
+    if sessions and thread_id in sessions:
+        del sessions[thread_id]
+        logger.info(f"认证令牌 {auth_token} 会话 {thread_id} 已删除。")
+        return True
+    return False
+
+def list_all_sessions(auth_token: str) -> List[Dict[str, Any]]:
+    """列出指定认证令牌下的所有会话。"""
+    sessions = cleanup_expired_sessions(auth_token) # 清理并获取最新会话列表
+    return [
+        {
+            "thread_id": tid,
+            "name": session.name,
+            "created_at": session.created_at,
+            "last_active": session.last_active
+        } for tid, session in sessions.items()
+    ]

app/services/image_proxy_service.py

@@ -0,0 +1,96 @@
+# app/services/image_proxy_service.py
+
+import logging
+import base64
+import httpx
+from fastapi import Request, HTTPException
+from fastapi.responses import StreamingResponse, JSONResponse, Response # 导入 Response 类
+from typing import Optional, Tuple
+
+# 导入自定义模块
+from app.core.gemini_client_manager import get_next_gemini_cookie_tuple # 从 core 模块导入获取 cookie 的函数
+
+logger = logging.getLogger(__name__)
+
+# 定义需要跳过后端下载的域名，这些域名的图片将通过代理加载
+SKIP_DOWNLOAD_DOMAINS = ["googleusercontent.com", "blogger.googleusercontent.com", "lh3.googleusercontent.com"]
+
+async def proxy_image_request(image_url: str, request: Request):
+    """
+    代理图片下载，解决前端跨域或防盗链问题。
+    """
+    logger.info(f"接收到图片代理请求: {image_url}")
+    
+    # 获取下一组Gemini Cookie
+    cookie_tuple: Optional[Tuple[str, str]] = get_next_gemini_cookie_tuple()
+    cookies = {}
+    if cookie_tuple:
+        sid, sidts = cookie_tuple
+        cookies = {
+            "__Secure-1PSID": sid,
+            "__Secure-1PSIDTS": sidts
+        }
+        logger.info(f"使用Cookie代理图片下载: sid={sid[:5]}..., sidts={sidts[:5]}...")
+    
+    # 设置更安全的请求头
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+        "Accept": "image/webp,image/apng,image/*,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+        "Referer": "https://gemini.google.com/",
+        "Sec-Fetch-Dest": "image",
+        "Sec-Fetch-Mode": "no-cors",
+        "Sec-Fetch-Site": "same-origin",
+    }
+    
+    async with httpx.AsyncClient(
+        follow_redirects=True, 
+        trust_env=False,  # 禁用环境代理
+        max_redirects=5,  # 减少最大重定向次数
+        cookies=cookies,
+        http2=True  # 启用HTTP/2
+    ) as client:
+        try:
+            # 添加详细日志
+            logger.debug(f"开始代理下载图片: {image_url}")
+            response = await client.get(image_url, timeout=30, headers=headers)
+            response.raise_for_status()
+            
+            # 记录响应详情
+            logger.info(f"图片代理成功: URL={image_url}, 状态码={response.status_code}, 类型={response.headers.get('Content-Type')}")
+            
+            # 返回流式响应
+            return StreamingResponse(
+                content=response.iter_bytes(),
+                media_type=response.headers.get("Content-Type", "image/jpeg"),
+                headers={
+                    "Cache-Control": "public, max-age=86400",  # 缓存一天
+                    "Access-Control-Allow-Origin": "*"
+                }
+            )
+        except httpx.HTTPStatusError as e:
+            logger.error(f"代理下载图片失败: URL: {image_url}, 状态码: {e.response.status_code}")
+            # 返回错误响应
+            return JSONResponse(
+                status_code=e.response.status_code,
+                content={"error": f"代理下载失败: {e.response.status_code}"}
+            )
+        except httpx.TooManyRedirects:
+            logger.error(f"代理下载图片重定向过多: URL: {image_url}")
+            return JSONResponse(
+                status_code=400,
+                content={"error": "图片重定向过多，无法下载"}
+            )
+        except (httpx.RequestError, Exception) as e:
+            logger.error(f"代理下载图片失败: URL: {image_url}, 错误: {type(e).__name__} - {e}")
+            # 返回一个透明的 1x1 像素 GIF 图片作为占位符
+            transparent_gif_base64 = "R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
+            transparent_gif_bytes = base64.b64decode(transparent_gif_base64)
+            return Response(
+                content=transparent_gif_bytes,
+                media_type="image/gif",
+                headers={
+                    "Cache-Control": "public, max-age=60",  # 短时间缓存
+                    "Access-Control-Allow-Origin": "*"  # 允许跨域
+                }
+            )

app/utils/gemini_converter.py

@@ -0,0 +1,213 @@
+# app/utils/gemini_converter.py
+
+import time
+import base64
+import re
+import logging
+import httpx
+from typing import Dict, Any, List, Optional
+from gemini_webapi import ModelOutput
+
+logger = logging.getLogger(__name__)
+
+# 定义需要跳过后端下载的域名，这些域名的图片将通过代理加载
+PROXY_IMAGE_DOMAINS = ["googleusercontent.com", "blogger.googleusercontent.com", "lh3.googleusercontent.com"]
+
+async def format_gemini_response_to_openai(gemini_output: ModelOutput) -> Dict[str, Any]:
+    """
+    将 gemini-webapi 的 ModelOutput 格式转换为 OpenAI API 的聊天完成响应格式。
+    这里只实现核心字段的转换。
+    """
+    openai_response = {
+        "id": "chatcmpl-placeholder",  # 占位符
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": "gemini-pro",  # 假设都使用 gemini-pro
+        "choices": [],
+        "usage": {  # 占位符，gemini-webapi 可能不提供详细 usage
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": 0,
+        },
+    }
+
+    content_parts = []
+    image_data_urls = []  # 用于存储 Base64 编码的图片 Data URL 列表
+
+    if gemini_output:
+        if gemini_output.text:
+            original_text = gemini_output.text
+            logger.info(f"Gemini 原始文本内容: {original_text[:200]}...") # 记录原始文本内容，截取前200字符
+
+            # 提取 Markdown 格式的图片链接和纯 URL 格式的图片链接
+            markdown_image_regex = r"!\[.*?\]\((https?:\/\/[^\s)]+)\)"
+            direct_image_url_regex = r"(https?:\/\/(?:lh3\.)?googleusercontent\.com\/(?:image_generation_content|gg-dl|image_collection\/image_retrieval)\/[^\s]+)"
+
+            # 存储所有从文本中提取的图片 URL
+            all_extracted_urls_from_text = []
+
+            # 第一次匹配：Markdown 格式的图片链接
+            temp_text_after_markdown_extraction = original_text
+            markdown_matches = re.findall(markdown_image_regex, temp_text_after_markdown_extraction)
+            for url in markdown_matches:
+                all_extracted_urls_from_text.append(url)
+            temp_text_after_markdown_extraction = re.sub(markdown_image_regex, '', temp_text_after_markdown_extraction)
+
+            # 第二次匹配：纯 URL 格式的图片链接
+            direct_url_matches = re.findall(direct_image_url_regex, temp_text_after_markdown_extraction)
+            for url in direct_url_matches:
+                all_extracted_urls_from_text.append(url)
+            temp_text_after_direct_url_extraction = re.sub(direct_image_url_regex, '', temp_text_after_markdown_extraction)
+
+            content_parts.append(temp_text_after_direct_url_extraction.strip()) # 将处理后的文本添加到内容部分
+
+            # 处理从文本中提取的图片
+            if all_extracted_urls_from_text:
+                logger.info(f"从文本中检测到图片 URL: {all_extracted_urls_from_text}")
+                async with httpx.AsyncClient(follow_redirects=True, trust_env=True, max_redirects=100) as client: # 增加最大重定向次数
+                    headers = {
+                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36",
+                        "Referer": "https://gemini.google.com/",
+                    }
+                    for i, image_url in enumerate(all_extracted_urls_from_text):
+                        # 判断是否属于需要代理的域名
+                        should_proxy = any(domain in image_url for domain in PROXY_IMAGE_DOMAINS)
+
+                        if should_proxy:
+                            logger.warning(f"图片 URL 属于代理域名 ({image_url})，将通过代理加载。")
+                            proxied_url = f"/v1/image_proxy?image_url={image_url}"
+                            image_data_urls.append(proxied_url)
+                            continue # 跳过直接下载逻辑
+
+                        # 否则，尝试直接下载并转换为 Base64
+                        try:
+                            logger.info(f"尝试直接下载文本中的图片: {image_url}")
+                            response = await client.get(image_url, timeout=60, headers=headers)
+                            response.raise_for_status()
+                            image_bytes = response.content
+
+                            mime_type = response.headers.get("Content-Type", "application/octet-stream").split(';')[0].strip()
+                            if not mime_type.startswith("image/"):
+                                ext = image_url.split('.')[-1].lower()
+                                if ext in ["jpg", "jpeg"]: mime_type = "image/jpeg"
+                                elif ext == "png": mime_type = "image/png"
+                                elif ext == "gif": mime_type = "image/gif"
+                                elif ext == "webp": mime_type = "image/webp"
+                                else:
+                                    logger.warning(f"文本中的图片 {image_url} 的 MIME 类型未知或非图片类型: {mime_type}，尝试使用 image/jpeg 作为默认。")
+                                    mime_type = "image/jpeg"
+
+                            base64_image = base64.b64encode(image_bytes).decode("utf-8")
+                            data_url = f"data:{mime_type};base64,{base64_image}"
+                            image_data_urls.append(data_url)
+                            logger.info(f"成功下载并转换文本中的图片 {i+1} ({image_url}) 为 Base64 Data URL (MIME: {mime_type})")
+                        except httpx.RequestError as e:
+                            logger.error(f"直接下载文本中的图片失败 (RequestError): URL: {image_url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+                        except httpx.HTTPStatusError as e:
+                            logger.error(f"直接下载文本中的图片失败 (HTTPStatusError): URL: {image_url}, 状态码: {e.response.status_code}, 响应文本: {e.response.text}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+                        except Exception as e:
+                            logger.error(f"处理文本中的图片时发生未知错误: URL: {image_url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+
+        # 处理 gemini_output.images，如果存在图片，将其下载并转换为 Base64 Data URL
+        if gemini_output.images:
+            logger.info(f"检测到 Gemini 返回图片列表: {[img.url for img in gemini_output.images if img.url]}")
+            async with httpx.AsyncClient(follow_redirects=True, trust_env=True, max_redirects=100) as client: # 增加最大重定向次数
+                headers = {
+                    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36",
+                    "Referer": "https://gemini.google.com/",
+                }
+                for i, image in enumerate(gemini_output.images):
+                    if image.url:
+                        # 判断是否属于需要代理的域名
+                        should_proxy = any(domain in image.url for domain in PROXY_IMAGE_DOMAINS)
+
+                        if should_proxy:
+                            logger.warning(f"图片 URL 属于代理域名 (来自gemini_output.images) ({image.url})，将通过代理加载。")
+                            proxied_url = f"/v1/image_proxy?image_url={image.url}"
+                            image_data_urls.append(proxied_url)
+                            continue # 跳过直接下载逻辑
+
+                        # 否则，尝试直接下载并转换为 Base64
+                        try:
+                            logger.info(f"尝试直接下载图片 (来自gemini_output.images): {image.url}")
+                            response = await client.get(image.url, timeout=60, headers=headers)
+                            response.raise_for_status()
+                            image_bytes = response.content
+
+                            mime_type = response.headers.get("Content-Type", "application/octet-stream").split(';')[0].strip()
+                            if not mime_type.startswith("image/"):
+                                ext = image.url.split('.')[-1].lower()
+                                if ext in ["jpg", "jpeg"]: mime_type = "image/jpeg"
+                                elif ext == "png": mime_type = "image/png"
+                                elif ext == "gif": mime_type = "image/gif"
+                                elif ext == "webp": mime_type = "image/webp"
+                                else:
+                                    logger.warning(f"图片 {image.url} 的 MIME 类型未知或非图片类型: {mime_type}，尝试使用 image/jpeg 作为默认。")
+                                    mime_type = "image/jpeg"
+
+                            base64_image = base64.b64encode(image_bytes).decode("utf-8")
+                            data_url = f"data:{mime_type};base64,{base64_image}"
+                            image_data_urls.append(data_url)
+                            logger.info(f"成功下载并转换图片 {i+1} (来自gemini_output.images) ({image.url}) 为 Base64 Data URL (MIME: {mime_type})")
+                        except httpx.RequestError as e:
+                            logger.error(f"直接下载图片失败 (RequestError, 来自gemini_output.images): URL: {image.url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+                        except httpx.HTTPStatusError as e:
+                            logger.error(f"直接下载图片失败 (HTTPStatusError, 来自gemini_output.images): URL: {image.url}, 状态码: {e.response.status_code}, 响应文本: {e.response.text}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+                        except Exception as e:
+                            logger.error(f"处理图片时发生未知错误 (来自gemini_output.images): URL: {image.url}, 类型: {type(e).__name__}, 错误: {e}", exc_info=True)
+                            image_data_urls.append("") # 下载失败时，返回空字符串
+        else:
+            logger.info("Gemini 返回的 ModelOutput 中没有检测到 'images' 字段或其为空。")
+
+    # 将所有内容部分合并
+    content = "\n\n".join(content_parts).strip()
+    logger.info(f"最终合并的文本内容: {content[:200]}...") # 记录最终合并的文本内容
+    logger.info(f"最终 Base64 图片 Data URL 数量: {len(image_data_urls)}") # 记录最终图片数量
+
+    if not content: # 如果没有文本内容
+        if image_data_urls: # 但有图片 URL
+            logger.warning("Gemini API 返回了图片但没有文本内容。")
+            content = "无响应文本" # 提示改为“无响应文本”
+            finish_reason = "stop" # 仍然是正常停止
+        else: # 既没有文本内容也没有图片 URL
+            logger.warning("Gemini API 返回了空文本响应且没有图片。")
+            content = "Gemini API 返回了空响应或内容处理失败"
+            finish_reason = "length"
+    else:
+        finish_reason = "stop"
+
+    message_content = {"role": "assistant", "content": content}
+    if image_data_urls:  # 如果有 Base64 图片 Data URL，添加到 message 中
+        message_content["image_urls"] = image_data_urls  # 仍然使用 image_urls 字段名，前端无需修改
+
+    openai_response["choices"] = [
+        {
+            "index": 0,
+            "message": message_content,
+            "finish_reason": finish_reason,
+        }
+    ]
+
+    return openai_response
+
+def convert_openai_messages_to_gemini_history(
+    messages: List[Dict[str, Any]],
+) -> str: # 返回类型改为 str
+    """
+    尝试将 OpenAI API 的 messages 格式转换为 gemini-webapi 的历史格式。
+    由于 gemini_webapi 库的 send_message 方法不直接接受历史，
+    此函数将提取所有消息内容并合并为一个字符串。
+    """
+    history_text = ""
+    for message in messages:
+        role = message.get("role")
+        content = message.get("content")
+        if role and content:
+            history_text += f"{role}: {content}\n"
+    logger.info(f"将消息历史合并为文本: {history_text[:200]}...")
+    return history_text