think buddy

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.10.16-slim
+
+WORKDIR /app
+
+# 复制所需文件到容器中
+COPY . .
+
+
+RUN pip install --no-cache-dir -r requirements.txt
+ENV APP_SECRET="sk-123456"
+ENV REQUEST_TIMEOUT=30
+
+# Expose port
+EXPOSE 8001
+
+# Run the application
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8001"]

README.md

@@ -5,6 +5,7 @@ colorFrom: blue
 colorTo: red
 sdk: docker
 pinned: false
+app_port: 8001
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

core/app.py

@@ -0,0 +1,69 @@
+import asyncio
+
+from fastapi import FastAPI, Request
+from starlette.middleware.cors import CORSMiddleware
+from starlette.middleware.trustedhost import TrustedHostMiddleware
+from fastapi.responses import JSONResponse
+from core.config import get_settings
+from core.logger import setup_logger
+from core.refresh_token import TokenManager
+from core.router import router
+
+settings = get_settings()
+logger = setup_logger(__name__)
+
+# print(settings.SECRET)
+def create_app() -> FastAPI:
+    app = FastAPI(
+        title=settings.PROJECT_NAME,
+        version="0.0.1",
+        description=settings.DESCRIPTION,
+    )
+    # 配置中间件
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # # 添加可信主机中间件
+    app.add_middleware(
+        TrustedHostMiddleware,
+        allowed_hosts=["*"]  # 在生产环境中应该限制允许的主机
+    )
+    # 添加路由
+    app.include_router(router, prefix="/api/v1")
+    app.include_router(router, prefix="/v1")  # 兼容性路由
+
+    @app.exception_handler(Exception)
+    async def global_exception_handler(request: Request, exc: Exception):
+        logger.error(f"An error occurred: {str(exc)}", exc_info=True)
+        return JSONResponse(
+            status_code=500,
+            content={
+                "message": "An internal server error occurred.",
+                "detail": str(exc)
+            },
+        )
+
+    # # 创建 TokenManager 实例
+    token_manager = TokenManager()
+    @app.on_event("startup")
+    async def startup_event():
+        # 在应用启动时创建任务
+        app.state.refresh_task = asyncio.create_task(token_manager.start_auto_refresh())
+
+    @app.on_event("shutdown")
+    async def shutdown_event():
+        # 在应用关闭时取消任务
+        if hasattr(app.state, 'refresh_task'):
+            app.state.refresh_task.cancel()
+            try:
+                await app.state.refresh_task
+            except asyncio.CancelledError:
+                pass
+    return app
+
+app = create_app()

core/auth.py

@@ -0,0 +1,12 @@
+from fastapi import Depends, HTTPException
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from core.config import get_settings
+
+settings = get_settings()
+APP_SECRET = settings.APP_SECRET
+security = HTTPBearer()
+
+def verify_app_secret(credentials: HTTPAuthorizationCredentials = Depends(security)):
+    if credentials.credentials != APP_SECRET:
+        raise HTTPException(status_code=403, detail="Invalid SECRET")
+    return credentials.credentials

core/config.py

@@ -0,0 +1,79 @@
+import os
+import platform
+import uuid
+from typing import List, Dict
+
+import httpx
+from dotenv import load_dotenv
+from pydantic_settings import BaseSettings
+
+load_dotenv()
+
+
+class Settings(BaseSettings):
+    APP_SECRET: str = os.getenv('APP_SECRET', '')
+    TOKEN: str = os.getenv('TOKEN', '')
+    PROJECT_NAME: str = os.getenv('PROJECT_NAME', 'FastAPI')
+    DESCRIPTION: str = os.getenv('DESCRIPTION', 'FastAPI template')
+    FIREBASE_API_KEY: str = os.getenv('FIREBASE_API_KEY', '')
+    REFRESH_TOKEN: str = os.getenv('REFRESH_TOKEN', '')
+    AUTHORIZATION_TOKEN: str = os.getenv('AUTHORIZATION_TOKEN', '')
+
+    ALLOWED_MODELS: List[Dict[str, str]] = [
+        {"id": "gpt-4o", "name": "GPT-4o [thinkbuddy]"},
+        {"id": "claude-3-5-sonnet", "name": "Claude 3.5 Sonnet v2 [thinkbuddy]"},
+        {"id": "gemini-2-flash", "name": "Gemini 2 Flash [thinkbuddy]"},
+        {"id": "nova-pro", "name": "Nova Pro [thinkbuddy]"},
+        {"id": "deepseek-v3", "name": "DeepSeek v3 [thinkbuddy]"},
+        {"id": "llama-3-3", "name": "Llama 3.3 (70B) [thinkbuddy]"},
+        {"id": "mistral-large-2", "name": "Mistral Large v2 [thinkbuddy]"},
+        {"id": "command-r-plus", "name": "Command R+ [thinkbuddy]"},
+        {"id": "o1-preview", "name": "o1-preview [thinkbuddy]"},
+        {"id": "o1-mini", "name": "o1-mini [thinkbuddy]"},
+        {"id": "gemini-2-thinking", "name": "Gemini 2 Thinking [thinkbuddy]"},
+        {"id": "claude-3-5-haiku", "name": "Claude 3.5 Haiku [thinkbuddy]"},
+        {"id": "gemini-1-5-flash", "name": "Gemini 1.5 Flash [thinkbuddy]"},
+        {"id": "gpt-4o-mini", "name": "GPT-4o mini [thinkbuddy]"},
+        {"id": "nova-lite", "name": "Nova Lite [thinkbuddy]"},
+        {"id": "gemini-1-5-pro", "name": "Gemini 1.5 Pro [thinkbuddy]"},
+        {"id": "claude-3-opus", "name": "Claude 3 Opus [thinkbuddy]"},
+        {"id": "gpt-4-turbo", "name": "GPT-4 Turbo [thinkbuddy]"},
+        {"id": "llama-3-1", "name": "Llama 3.1 [thinkbuddy]"}
+    ]
+    MODEL_MAPPING: Dict[str, str] = {
+        "gpt-4o": "gpt-4o",
+        "o1-preview": "o1-preview",
+        "claude-3-5-sonnet": "claude-3-5-sonnet",
+        "o1-mini": "o1-mini",
+        "gemini-1.5-pro": "gemini-1.5-pro",
+        "gemini-2.0-flash": "gemini-2.0-flash",
+    }
+    HEADERS: Dict[str, str] = {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Content-Type': 'application/json',
+        'sec-ch-ua-platform': 'Windows',
+        'authorization': f"Bearer {os.getenv('TOKEN', '')}",
+        'sec-ch-ua': '"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"',
+        'dnt': '1',
+        'sec-ch-ua-mobile': '?0',
+        'origin': 'https://thinkbuddy.ai',
+        'sec-fetch-site': 'same-site',
+        'sec-fetch-mode': 'cors',
+        'sec-fetch-dest': 'empty',
+        'referer': 'https://thinkbuddy.ai/',
+        'accept-language': 'en-US,en;q=0.9,zh-CN;q=0.8,zh-TW;q=0.7,zh;q=0.6',
+        'priority': 'u=1, i'
+    }
+
+    class Config:
+        env_file = '.env'
+        case_sensitive = True
+
+_settings = None
+
+def get_settings():
+    global _settings
+    if _settings is None:
+        _settings = Settings()
+    return _settings

core/logger.py

@@ -0,0 +1,20 @@
+import logging
+
+def setup_logger(name):
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        logger.setLevel(logging.INFO)
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+
+        # 控制台处理器
+        console_handler = logging.StreamHandler()
+        console_handler.setFormatter(formatter)
+        logger.addHandler(console_handler)
+
+        # 文件处理器 - 错误级别
+        # error_file_handler = logging.FileHandler('error.log')
+        # error_file_handler.setFormatter(formatter)
+        # error_file_handler.setLevel(logging.ERROR)
+        # logger.addHandler(error_file_handler)
+
+    return logger

core/models.py

@@ -0,0 +1,16 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+
+class Message(BaseModel):
+    role: str
+    content: str | list
+
+
+class ChatRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    stream: Optional[bool] = False
+    temperature: Optional[float] = 0.7
+    top_p: Optional[float] = 0.9
+    max_tokens: Optional[int] = 8192

core/refresh_token.py

@@ -0,0 +1,105 @@
+# 用于刷新idToken的定时任务
+import asyncio
+import os
+import time
+from typing import Optional
+from datetime import datetime
+from core.utils import sign_in_with_idp, handle_firebase_response, refresh_token_via_rest
+
+
+class TokenManager:
+    def __init__(self):
+        self.id_token: Optional[str] = None
+        self.last_refresh_time: Optional[float] = None
+        self.refresh_interval = 30 * 60  # 30分钟，单位：秒
+        self.is_running = False
+
+    async def get_token(self) -> str:
+        """
+        获取当前的 idToken，如果不存在或已过期则刷新
+        """
+        if not self.id_token or self._should_refresh():
+            await self.refresh_token()
+        return self.id_token
+
+    def _should_refresh(self) -> bool:
+        """
+        检查是否需要刷新 token
+        """
+        if not self.last_refresh_time:
+            return True
+        return time.time() - self.last_refresh_time >= self.refresh_interval
+
+    async def refresh_token(self):
+        """
+        刷新 idToken
+        """
+        try:
+            if os.getenv("REFRESH_TOKEN", "") == "" or os.getenv("REFRESH_TOKEN", "") == "None":
+                response = await sign_in_with_idp()
+                result = await handle_firebase_response(response) # idToken 实际就是bearer token
+            else:
+                result = await refresh_token_via_rest(os.getenv("REFRESH_TOKEN"))
+            if result is not None:
+                self.id_token = result
+                # 修改配置中的 TOKEN
+                print(f"Before Token is {os.getenv('TOKEN', '')}")
+                os.environ["TOKEN"] = self.id_token
+                print(f"Now Token is {os.getenv('TOKEN', '')}")
+                self.last_refresh_time = time.time()
+                print(f"Token refreshed at {datetime.now()}")
+            else:
+                print(f"Failed to refresh token: {result['error']}")
+        except Exception as e:
+            print(f"Error refreshing token: {str(e)}")
+
+    async def start_auto_refresh(self):
+        """
+        启动自动刷新任务
+        """
+        if self.is_running:
+            return
+
+        self.is_running = True
+        while self.is_running:
+            try:
+                await self.refresh_token()
+                # 等待到下次刷新时间
+                await asyncio.sleep(self.refresh_interval)
+            except Exception as e:
+                print(f"Auto refresh error: {str(e)}")
+                # 发生错误时等待短暂时间后重试
+                await asyncio.sleep(60)
+
+    async def stop_auto_refresh(self):
+        """
+        停止自动刷新任务
+        """
+        self.is_running = False
+
+# 使用示例
+# async def main():
+#     # 创建 TokenManager 实例
+#     token_manager = TokenManager()
+#
+#     try:
+#         # 启动自动刷新任务
+#         refresh_task = asyncio.create_task(token_manager.start_auto_refresh())
+#
+#         # 模拟应用运行
+#         while True:
+#             # 获取当前 token
+#             token = await token_manager.get_token()
+#             print(f"Current token: {token[:20]}...")
+#
+#             # 等待一段时间再次获取
+#             await asyncio.sleep(300)  # 每5分钟打印一次当前token
+#
+#     except KeyboardInterrupt:
+#         # 处理 Ctrl+C
+#         await token_manager.stop_auto_refresh()
+#         await refresh_task
+#
+# # 运行示例
+# if __name__ == "__main__":
+#     asyncio.run(main())

core/router.py

@@ -0,0 +1,241 @@
+import asyncio
+import json
+import os
+import traceback
+from typing import Optional
+from uuid import uuid4
+
+import httpx
+from fastapi import File, UploadFile
+from fastapi import APIRouter, Response, Request, Depends, HTTPException
+from fastapi.responses import StreamingResponse
+
+
+from core.auth import verify_app_secret
+from core.config import get_settings
+from core.logger import setup_logger
+from core.models import ChatRequest
+from core.utils import process_streaming_response
+from playsound import playsound  # 用于播放音频
+
+logger = setup_logger(__name__)
+router = APIRouter()
+ALLOWED_MODELS = get_settings().ALLOWED_MODELS
+
+@router.get("/models")
+async def list_models():
+    return {"object": "list", "data": ALLOWED_MODELS, "success": True}
+
+@router.options("/chat/completions")
+async def chat_completions_options():
+    return Response(
+        status_code=200,
+        headers={
+            "Access-Control-Allow-Origin": "*",
+            "Access-Control-Allow-Methods": "POST, OPTIONS",
+            "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        },
+    )
+# 识图
+
+# 识图
+# 文本转语音
+@router.post("/audio/speech")
+async def speech(request: Request):
+    url = 'https://api.thinkbuddy.ai/v1/content/speech/tts'
+    request_headers = {**get_settings().HEADERS,
+                       'authorization': f"Bearer {os.getenv('TOKEN', '')}",
+                       'Accept': 'application/json, text/plain, */*',
+                       }
+    # data = {
+    #     "input": "这是一张插图，显示了一杯饮料，可能是奶昔、冰沙或其他冷饮。杯子上有一个盖子和一根吸管，表明这是一种便于携带和饮用的饮品。这种设计通常用于提供咖啡、冰茶或果汁等饮品。杯子颜色简约，可能用于说明饮品的内容或品牌。",
+    #     "voice": "nova" # alloy echo fable onyx nova shimmer
+    # }
+    body = await request.json()
+    try:
+        async with httpx.AsyncClient(http2=True) as client:
+            response = await client.post(url, headers=request_headers, json=body)
+            response.raise_for_status()
+
+            # 假设响应是音频数据，保存为文件
+            if response.status_code == 200:
+                # 保存音频文件
+                with open('output.mp3', 'wb') as f:
+                    f.write(response.content)
+                print("音频文件已保存为 output.mp3")
+
+                # 异步播放音频
+                # 使用 asyncio.to_thread 来避免阻塞事件循环
+                # await asyncio.to_thread(playsound, 'output.mp3')
+                return True
+            else:
+                print(f"请求失败，状态码: {response.status_code}")
+                print(f"响应内容: {response.text}")
+                return False
+
+    except httpx.RequestError as e:
+        print(f"请求错误: {e}")
+        print("错误堆栈:")
+        traceback.print_exc()
+        return False
+    except httpx.HTTPStatusError as e:
+        print(f"HTTP 错误: {e}")
+        print("错误堆栈:")
+        traceback.print_exc()
+        return False
+    except Exception as e:
+        print(f"发生错误: {e}")
+        print("错误堆栈:")
+        traceback.print_exc()
+        return False
+
+
+# 语音转文本
+@router.post("/audio/transcriptions")
+async def transcriptions(request: Request, file: UploadFile = File(...)):
+    url = 'https://api.thinkbuddy.ai/v1/content/transcribe'
+    params = {'enhance': 'true'}
+    try:
+        # 读取文件内容
+        content = await safe_read_file(file)
+        # 获取原始 content-type
+        content_type = request.headers.get('content-type')
+        # files = {
+        #     'file': (str(uuid4()),
+        #              content,
+        #              file.content_type or 'application/octet-stream')
+        # }
+        files = {
+            'file': ('file.mp4', content, 'audio/mp4'),
+            'model': (None, 'whisper-1')
+        }
+        # 记录请求信息
+        logger.info(f"Received upload request for file: {file.filename}")
+        logger.info(f"Content-Type: {request.headers.get('content-type')}")
+        request_headers = {**get_settings().HEADERS,
+                           'authorization': f"Bearer {os.getenv('TOKEN', '')}",
+                           'Accept': 'application/json, text/plain, */*',
+                           'Content-Type': content_type,
+                           }
+        # 设置较长的超时时间
+        timeout = httpx.Timeout(
+            connect=30.0,  # 连接超时
+            read=300.0,    # 读取超时
+            write=30.0,    # 写入超时
+            pool=30.0      # 连接池超时
+        )
+        # 使用httpx发送异步请求
+        async with httpx.AsyncClient(http2=True, timeout=timeout) as client:
+            response = await client.post(url,
+                                         params=params,
+                                         headers=request_headers,
+                                         files=files)
+            response.raise_for_status()
+            return response.json()
+
+    except httpx.TimeoutException:
+        raise HTTPException(status_code=504, detail="请求目标服务器超时")
+    except httpx.HTTPStatusError as e:
+        raise HTTPException(status_code=e.response.status_code, detail=str(e))
+    except Exception as e:
+        traceback.print_tb(e.__traceback__)
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        # 清理资源
+        await file.close()
+async def safe_read_file(file: UploadFile) -> Optional[bytes]:
+    """安全地读取文件内容"""
+    try:
+        return await file.read()
+    except Exception as e:
+        logger.error(f"Error reading file: {str(e)}")
+        return None
+# 文件上传
+@router.post("/upload")
+async def upload_file(request: Request, file: UploadFile = File(...)):
+    try:
+        # 读取文件内容
+        content = await safe_read_file(file)
+        # 获取原始 content-type
+        content_type = request.headers.get('content-type')
+        files = {
+            'file': (
+                # str(uuid4()),
+                file.filename,  # 使用原始文件名而不是 UUID
+                     content,
+                     file.content_type )
+        }
+        # 记录请求信息
+        logger.info(f"Received upload request for file: {file.filename}")
+        logger.info(f"Content-Type: {request.headers.get('content-type')}")
+        request_headers = {**get_settings().HEADERS,
+                           'authorization': f"Bearer {os.getenv('TOKEN', '')}",
+                           'Accept': 'application/json, text/plain, */*',
+                           'Content-Type': content_type,
+                           }
+        # 使用httpx发送异步请求
+        async with httpx.AsyncClient() as client:
+            response = await client.post(f"https://api.thinkbuddy.ai/v1/uploads/images", headers=request_headers,files=files,  timeout=100)
+            response.raise_for_status()
+            return response.json()
+
+    except httpx.TimeoutException:
+        raise HTTPException(status_code=504, detail="请求目标服务器超时")
+    except httpx.HTTPStatusError as e:
+        # raise HTTPException(status_code=e.response.status_code, detail=str(e))
+        print(f"HTTPStatusError发生错误: {e}")
+        print("错误堆栈:")
+        traceback.print_exc()
+    except Exception as e:
+        # traceback.print_tb(e.__traceback__)
+        # raise HTTPException(status_code=500, detail=str(e))
+        print(f"发生错误: {e}")
+        print("错误堆栈:")
+        traceback.print_exc()
+    finally:
+        # 清理资源
+        await file.close()
+
+@router.post("/chat/completions")
+async def chat_completions(
+        request: ChatRequest, app_secret: str = Depends(verify_app_secret)
+):
+    logger.info("Entering chat_completions route")
+    # logger.info(f"Received request: {request}")
+    logger.info(f"Received request json format: {json.dumps(request.dict(), indent=4)}")
+    logger.info(f"App secret: {app_secret}")
+    logger.info(f"Received chat completion request for model: {request.model}")
+
+    if request.model not in [model["id"] for model in ALLOWED_MODELS]:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Model {request.model} is not allowed. Allowed models are: {', '.join(model['id'] for model in ALLOWED_MODELS)}",
+        )
+
+    if request.stream:
+        logger.info("Streaming response")
+        return StreamingResponse(
+            process_streaming_response(request, app_secret),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+                "Transfer-Encoding": "chunked"
+            }
+        )
+    else:
+        logger.info("Non-streaming response")
+        # return await process_non_streaming_response(request)
+
+@router.route('/')
+@router.route('/healthz')
+@router.route('/ready')
+@router.route('/alive')
+@router.route('/status')
+@router.get("/health")
+async def health_check(request: Request):
+    return Response(content=json.dumps({"status": "ok"}), media_type="application/json")
+
+@router.post("/env")
+async def environment(app_secret: str = Depends(verify_app_secret)):
+    return Response(content=json.dumps({"token": os.getenv("TOKEN", ""), "refresh_token": os.getenv("REFRESH_TOKEN", ""), "key": os.getenv("FIREBASE_API_KEY", "")}), media_type="application/json")

core/utils.py

@@ -0,0 +1,267 @@
+import codecs
+import hashlib
+import json
+import os
+import ssl
+import uuid
+from datetime import datetime
+# from http.client import HTTPException
+from typing import Dict, Any, Optional
+
+import httpx
+from fastapi import HTTPException
+from httpx import ConnectError, TransportError
+from starlette import status
+
+from core.config import get_settings
+from core.logger import setup_logger
+from core.models import ChatRequest
+
+settings = get_settings()
+logger = setup_logger(__name__)
+
+def decode_unicode_escape(s):
+    # 检查输入是否为字典类型
+    if isinstance(s, dict):
+        return s
+    # 如果需要，将输入转换为字符串
+    if not isinstance(s, (str, bytes)):
+        s = str(s)
+    # 如果是字符串，转换为字节
+    if isinstance(s, str):
+        s = s.encode('utf-8')
+    return codecs.decode(s, 'unicode_escape')
+
+FIREBASE_API_KEY = settings.FIREBASE_API_KEY
+async def refresh_token_via_rest(refresh_token):
+    # Firebase Auth REST API endpoint
+    url = f"https://securetoken.googleapis.com/v1/token?key={FIREBASE_API_KEY}"
+
+    payload = {
+        'grant_type': 'refresh_token',
+        'refresh_token': refresh_token
+    }
+
+    try:
+        async with httpx.AsyncClient() as client:
+            response = await client.post(url, json=payload)
+            if response.status_code == 200:
+                data = response.json()
+                print(json.dumps(data, indent=2))
+                # return {
+                #     'id_token': data['id_token'],
+                #     'refresh_token': data.get('refresh_token'),
+                #     'expires_in': data['expires_in']
+                # }
+                return data['id_token']
+            else:
+                print(f"刷新失败: {response.text}")
+                return None
+    except Exception as e:
+        print(f"请求异常: {e}")
+        return None
+
+
+async def sign_in_with_idp():
+    url = "https://identitytoolkit.googleapis.com/v1/accounts:signInWithIdp"
+
+    # 查询参数
+    params = {
+        "key": FIREBASE_API_KEY
+    }
+
+    # 请求头
+    headers = {
+        "X-Client-Version": "Node/JsCore/10.5.2/FirebaseCore-web",
+        "X-Firebase-gmpid": "1:123807869619:web:43b278a622ed6322789ec6",
+        "Content-Type": "application/json",
+        "User-Agent": "node-fetch/1.0 (+https://github.com/bitinn/node-fetch)"
+    }
+
+    # 请求体
+    data = {
+        "requestUri": "http://localhost",
+        "returnSecureToken": True,
+        "postBody": f"&id_token={settings.AUTHORIZATION_TOKEN}&providerId=google.com"
+    }
+    print("Request Headers:", json.dumps(headers, indent=2))  # 格式化打印
+    print("Request Body:", json.dumps(data, indent=2))  # 格式化打印
+    print("Request params:", json.dumps(params, indent=2))  # 格式化打印
+
+    async with httpx.AsyncClient() as client:
+        response = await client.post(
+            url,
+            params=params,
+            headers=headers,
+            json=data
+        )
+        # 检查状态码
+        if response.status_code == 200:
+            return response.json()
+        else:
+            raise Exception(f"Request failed with status code: {response.status_code}")
+
+async def handle_firebase_response(response) -> str:
+    try:
+        # 如果响应是字典（已经解析的 JSON）
+        if isinstance(response, dict):
+            print(json.dumps(response, indent=2))
+            if response.get('error', {}).get('code') == 400:
+                print("Invalid id_token in IdP response")
+            # 保存refresh_token到配置中
+            if 'refreshToken' in response:
+                os.environ["REFRESH_TOKEN"] = response['refreshToken']
+            if 'idToken' in response:
+                return response['idToken']
+            else:
+                raise ValueError("dict case Response does not contain idToken")
+
+        # 如果响应是 Response 对象
+        elif hasattr(response, 'status_code'):
+            if response.status_code == 200:
+                data = response.json()
+                print(data)
+                # 保存refresh_token到配置中
+                if 'refreshToken' in data:
+                    os.environ["REFRESH_TOKEN"] = data['refreshToken']
+                if 'idToken' in data:
+                    return data['idToken']
+                else:
+                    raise ValueError("response case Response does not contain idToken")
+
+            # 处理其他状态码
+            elif response.status_code == 400:
+                error_data = response.json()
+                raise ValueError(f"Bad Request: {error_data.get('error', {}).get('message', 'Unknown error')}")
+            elif response.status_code == 401:
+                raise ValueError("Unauthorized: Invalid credentials")
+            elif response.status_code == 403:
+                raise ValueError("Forbidden: Insufficient permissions")
+            elif response.status_code == 404:
+                raise ValueError("Not Found: Resource doesn't exist")
+            else:
+                raise ValueError(f"Unexpected status code: {response.status_code}")
+
+        else:
+            raise ValueError(f"Unexpected response type: {type(response)}")
+
+    except json.JSONDecodeError:
+        raise ValueError("Invalid JSON response")
+    except Exception as e:
+        raise ValueError(f"Error processing response: {str(e)}")
+
+# SHA-256
+def _sha256_hash(text):
+    sha256 = hashlib.sha256()
+    sha256.update(text.encode('utf-8'))
+    return sha256.hexdigest()
+
+# 处理字典列表
+def sha256_hash_messages(messages):
+    # 只提取 role 为 "user" 的消息的 content 字段
+    message_data = [str(msg['content']) for msg in messages if msg['role'] == "user"]
+    print("Filtered contents:", message_data)  # 调试用
+    json_str = json.dumps(message_data, sort_keys=True)
+    print("JSON string:", json_str)  # 调试用
+    return hashlib.sha256(json_str.encode('utf-8')).hexdigest()
+
+
+def create_chat_completion_data(
+        content: str, model: str, timestamp: int, finish_reason: Optional[str] = None
+) -> Dict[str, Any]:
+    return {
+        "id": f"chatcmpl-{uuid.uuid4()}",
+        "object": "chat.completion.chunk",
+        "created": timestamp,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "delta": {"content": content, "role": "assistant"},
+                "finish_reason": finish_reason,
+            }
+        ],
+        "usage": None,
+    }
+
+async def process_streaming_response(request: ChatRequest, app_secret: str):
+    # 创建自定义 SSL 上下文
+    ssl_context = ssl.create_default_context()
+    ssl_context.check_hostname = True
+    ssl_context.verify_mode = ssl.CERT_REQUIRED
+    async with httpx.AsyncClient(
+            verify=ssl_context,
+            # timeout=30.0,  # 增加超时时间
+            # http2=True    # 启用 HTTP/2
+    ) as client:
+        try:
+            request_headers = {**settings.HEADERS, 'authorization': f"Bearer {os.getenv('TOKEN', '')}"} # 从环境变量中获取新的TOKEN
+
+            # 直接使用 request.model_dump() 或 request.dict() 获取字典格式的数据
+            request_data = request.model_dump()  # 如果使用较新版本的 Pydantic
+            # # 获取请求数据
+            # request_data = {
+            #     "model": request.model,
+            #     "messages": [msg.dict() for msg in request.messages],
+            #     "temperature": request.temperature,
+            #     "top_p": request.top_p,
+            #     "max_tokens": request.max_tokens,
+            #     "stream": request.stream
+            # }
+            print("Request Headers:", json.dumps(request_headers, indent=2))  # 格式化打印
+            print("Request Body:", json.dumps(request.json(), indent=4, ensure_ascii=False))  # 格式化打印
+            async with client.stream(
+                    "POST",
+                    f"https://api.thinkbuddy.ai/v1/chat/completions",
+                    headers=request_headers,
+                    json=request_data,
+                    timeout=100,
+            ) as response:
+                response.raise_for_status()
+                timestamp = int(datetime.now().timestamp())
+                async for line in response.aiter_lines():
+                    print(f"{type(line)}: {line}")
+                    if line and line.startswith("data: "):
+                        try:
+                            if line.strip() == 'data: [DONE]':
+                                await response.aclose()
+                                break
+                            data_str = line[6:]  # 去掉 'data: ' 前缀
+
+                            # 解析JSON
+                            json_data = json.loads(data_str)
+                            if 'choices' in json_data and len(json_data['choices']) > 0:
+                                delta = json_data['choices'][0].get('delta', {})
+                                if 'content' in delta:
+                                    print(delta['content'], end='', flush=True)
+                                    yield f"data: {json.dumps(create_chat_completion_data(delta['content'], request.model, timestamp))}\n\n"
+
+                        except json.JSONDecodeError as e:
+                            print(f"JSON解析错误: {e}")
+                            print(f"原始数据: {line}")
+                            continue
+
+                yield f"data: {json.dumps(create_chat_completion_data('', request.model, timestamp, 'stop'))}\n\n"
+                yield "data: [DONE]\n\n"
+        except ConnectError as e:
+            logger.error(f"Connection error details: {str(e)}")
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
+                detail="Service temporarily unavailable. Please try again later."
+            )
+        except TransportError as e:
+            logger.error(f"Transport error details: {str(e)}")
+            raise HTTPException(
+                status_code=status.HTTP_502_BAD_GATEWAY,
+                detail="Network transport error occurred."
+            )
+        except httpx.HTTPStatusError as e:
+            # 这里需要处理401错误
+            logger.error(f"HTTP error occurred: {e}")
+            raise HTTPException(status_code=e.response.status_code, detail=str(e))
+        except httpx.RequestError as e:
+            logger.error(f"Error occurred during request: {e}")
+            raise HTTPException(status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e))
+        finally:
+            await response.aclose()
+

main.py

@@ -0,0 +1,6 @@
+from core.app import app
+import uvicorn
+
+
+if __name__ == '__main__':
+    uvicorn.run(app, host="0.0.0.0", port=8001, workers=1, loop="asyncio")

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+httpx
+pydantic
+pydantic_settings
+pyinstaller
+python-dotenv
+Requests
+starlette
+uvicorn
+
+playsound