Upload 28 files

.dockerignore

@@ -0,0 +1,7 @@
+.env
+*.pyc
+/.git/
+/.idea/
+/docs/
+/tmp/
+/data/

.env.example

@@ -0,0 +1,14 @@
+API_PREFIX=your_prefix
+CHATGPT_BASE_URL=https://chatgpt.com
+HISTORY_DISABLED=true
+PROXY_URL=your_first_proxy, your_second_proxy
+EXPORT_PROXY_URL=your_export_proxy
+ARK0SE_TOKEN_URL=https://ark0se.example.com/token
+POW_DIFFICULTY=000032
+RETRY_TIMES=3
+ENABLE_GATEWAY=true
+CONVERSATION_ONLY=false
+ENABLE_LIMIT=true
+UPLOAD_BY_URL=false
+SCHEDULED_REFRESH=false
+USER_AGENTS=["ua1", "ua2"]

.github/workflows/build_docker.yml

@@ -0,0 +1,50 @@
+name: Build Docker Image
+
+on:
+  push:
+    branches:
+      - main
+    paths-ignore:
+      - 'README.md'
+      - 'docker-compose.yml'
+      - 'docs/**'
+      - '.github/workflows/build_docker.yml'
+  workflow_dispatch:
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Log in to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: lanqian528/chat2api
+          tags: |
+            type=raw,value=latest,enable={{is_default_branch}}
+            type=raw,value=v1.4.16
+
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          file: Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}

.gitignore

@@ -0,0 +1,6 @@
+.env
+*.pyc
+/.git/
+/.idea/
+/tmp/
+/data/

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY . /app
+
+ENV DEMO_SECRET=123
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+EXPOSE 5005
+
+CMD ["python", "app.py"]

api/files.py

@@ -0,0 +1,144 @@
+import io
+
+import pybase64
+from PIL import Image
+
+from utils.Client import Client
+from utils.config import export_proxy_url, cf_file_url
+
+
+async def get_file_content(url):
+    if url.startswith("data:"):
+        mime_type, base64_data = url.split(';')[0].split(':')[1], url.split(',')[1]
+        file_content = pybase64.b64decode(base64_data)
+        return file_content, mime_type
+    else:
+        client = Client()
+        try:
+            if cf_file_url:
+                body = {"file_url": url}
+                r = await client.post(cf_file_url, timeout=60, json=body)
+            else:
+                r = await client.get(url, proxy=export_proxy_url, timeout=60)
+            if r.status_code != 200:
+                return None, None
+            file_content = r.content
+            mime_type = r.headers.get('Content-Type', '').split(';')[0].strip()
+            return file_content, mime_type
+        finally:
+            await client.close()
+            del client
+
+
+async def determine_file_use_case(mime_type):
+    multimodal_types = ["image/jpeg", "image/webp", "image/png", "image/gif"]
+    my_files_types = ["text/x-php", "application/msword", "text/x-c", "text/html",
+                      "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                      "application/json", "text/javascript", "application/pdf",
+                      "text/x-java", "text/x-tex", "text/x-typescript", "text/x-sh",
+                      "text/x-csharp", "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+                      "text/x-c++", "application/x-latext", "text/markdown", "text/plain",
+                      "text/x-ruby", "text/x-script.python"]
+
+    if mime_type in multimodal_types:
+        return "multimodal"
+    elif mime_type in my_files_types:
+        return "my_files"
+    else:
+        return "ace_upload"
+
+
+async def get_image_size(file_content):
+    with Image.open(io.BytesIO(file_content)) as img:
+        return img.width, img.height
+
+
+async def get_file_extension(mime_type):
+    extension_mapping = {
+        "image/jpeg": ".jpg",
+        "image/png": ".png",
+        "image/gif": ".gif",
+        "image/webp": ".webp",
+        "text/x-php": ".php",
+        "application/msword": ".doc",
+        "text/x-c": ".c",
+        "text/html": ".html",
+        "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+        "application/json": ".json",
+        "text/javascript": ".js",
+        "application/pdf": ".pdf",
+        "text/x-java": ".java",
+        "text/x-tex": ".tex",
+        "text/x-typescript": ".ts",
+        "text/x-sh": ".sh",
+        "text/x-csharp": ".cs",
+        "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+        "text/x-c++": ".cpp",
+        "application/x-latex": ".latex",
+        "text/markdown": ".md",
+        "text/plain": ".txt",
+        "text/x-ruby": ".rb",
+        "text/x-script.python": ".py",
+        "application/zip": ".zip",
+        "application/x-zip-compressed": ".zip",
+        "application/x-tar": ".tar",
+        "application/x-compressed-tar": ".tar.gz",
+        "application/vnd.rar": ".rar",
+        "application/x-rar-compressed": ".rar",
+        "application/x-7z-compressed": ".7z",
+        "application/octet-stream": ".bin",
+        "audio/mpeg": ".mp3",
+        "audio/wav": ".wav",
+        "audio/ogg": ".ogg",
+        "audio/aac": ".aac",
+        "video/mp4": ".mp4",
+        "video/x-msvideo": ".avi",
+        "video/x-matroska": ".mkv",
+        "video/webm": ".webm",
+        "application/rtf": ".rtf",
+        "application/vnd.ms-excel": ".xls",
+        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+        "text/css": ".css",
+        "text/xml": ".xml",
+        "application/xml": ".xml",
+        "application/vnd.android.package-archive": ".apk",
+        "application/vnd.apple.installer+xml": ".mpkg",
+        "application/x-bzip": ".bz",
+        "application/x-bzip2": ".bz2",
+        "application/x-csh": ".csh",
+        "application/x-debian-package": ".deb",
+        "application/x-dvi": ".dvi",
+        "application/java-archive": ".jar",
+        "application/x-java-jnlp-file": ".jnlp",
+        "application/vnd.mozilla.xul+xml": ".xul",
+        "application/vnd.ms-fontobject": ".eot",
+        "application/ogg": ".ogx",
+        "application/x-font-ttf": ".ttf",
+        "application/font-woff": ".woff",
+        "application/x-shockwave-flash": ".swf",
+        "application/vnd.visio": ".vsd",
+        "application/xhtml+xml": ".xhtml",
+        "application/vnd.ms-powerpoint": ".ppt",
+        "application/vnd.oasis.opendocument.text": ".odt",
+        "application/vnd.oasis.opendocument.spreadsheet": ".ods",
+        "application/x-xpinstall": ".xpi",
+        "application/vnd.google-earth.kml+xml": ".kml",
+        "application/vnd.google-earth.kmz": ".kmz",
+        "application/x-font-otf": ".otf",
+        "application/vnd.ms-excel.addin.macroEnabled.12": ".xlam",
+        "application/vnd.ms-excel.sheet.binary.macroEnabled.12": ".xlsb",
+        "application/vnd.ms-excel.template.macroEnabled.12": ".xltm",
+        "application/vnd.ms-powerpoint.addin.macroEnabled.12": ".ppam",
+        "application/vnd.ms-powerpoint.presentation.macroEnabled.12": ".pptm",
+        "application/vnd.ms-powerpoint.slideshow.macroEnabled.12": ".ppsm",
+        "application/vnd.ms-powerpoint.template.macroEnabled.12": ".potm",
+        "application/vnd.ms-word.document.macroEnabled.12": ".docm",
+        "application/vnd.ms-word.template.macroEnabled.12": ".dotm",
+        "application/x-ms-application": ".application",
+        "application/x-ms-wmd": ".wmd",
+        "application/x-ms-wmz": ".wmz",
+        "application/x-ms-xbap": ".xbap",
+        "application/vnd.ms-xpsdocument": ".xps",
+        "application/x-silverlight-app": ".xap"
+    }
+    return extension_mapping.get(mime_type, "")

api/models.py

@@ -0,0 +1,28 @@
+model_proxy = {
+    "gpt-3.5-turbo": "gpt-3.5-turbo-0125",
+    "gpt-3.5-turbo-16k": "gpt-3.5-turbo-16k-0613",
+    "gpt-4": "gpt-4-0613",
+    "gpt-4-32k": "gpt-4-32k-0613",
+    "gpt-4-turbo-preview": "gpt-4-0125-preview",
+    "gpt-4-vision-preview": "gpt-4-1106-vision-preview",
+    "gpt-4-turbo": "gpt-4-turbo-2024-04-09",
+    "gpt-4o": "gpt-4o-2024-05-13",
+    "gpt-4o-mini": "gpt-4o-mini-2024-07-18",
+    "o1-preview": "o1-preview-2024-09-12",
+    "o1-mini": "o1-mini-2024-09-12",
+    "claude-3-opus": "claude-3-opus-20240229",
+    "claude-3-sonnet": "claude-3-sonnet-20240229",
+    "claude-3-haiku": "claude-3-haiku-20240307",
+}
+
+model_system_fingerprint = {
+    "gpt-3.5-turbo-0125": ["fp_b28b39ffa8"],
+    "gpt-3.5-turbo-1106": ["fp_592ef5907d"],
+    "gpt-4-0125-preview": ["fp_f38f4d6482", "fp_2f57f81c11", "fp_a7daf7c51e", "fp_a865e8ede4", "fp_13c70b9f70",
+                           "fp_b77cb481ed"],
+    "gpt-4-1106-preview": ["fp_e467c31c3d", "fp_d986a8d1ba", "fp_99a5a401bb", "fp_123d5a9f90", "fp_0d1affc7a6",
+                           "fp_5c95a4634e"],
+    "gpt-4-turbo-2024-04-09": ["fp_d1bac968b4"],
+    "gpt-4o-2024-05-13": ["fp_3aa7262c27"],
+    "gpt-4o-mini-2024-07-18": ["fp_c9aa9c0491"]
+}

api/tokens.py

@@ -0,0 +1,86 @@
+import math
+
+import tiktoken
+
+
+async def calculate_image_tokens(width, height, detail):
+    if detail == "low":
+        return 85
+    else:
+        max_dimension = max(width, height)
+        if max_dimension > 2048:
+            scale_factor = 2048 / max_dimension
+            new_width = int(width * scale_factor)
+            new_height = int(height * scale_factor)
+        else:
+            new_width = width
+            new_height = height
+
+        width, height = new_width, new_height
+        min_dimension = min(width, height)
+        if min_dimension > 768:
+            scale_factor = 768 / min_dimension
+            new_width = int(width * scale_factor)
+            new_height = int(height * scale_factor)
+        else:
+            new_width = width
+            new_height = height
+
+        width, height = new_width, new_height
+        num_masks_w = math.ceil(width / 512)
+        num_masks_h = math.ceil(height / 512)
+        total_masks = num_masks_w * num_masks_h
+
+        tokens_per_mask = 170
+        total_tokens = total_masks * tokens_per_mask + 85
+
+        return total_tokens
+
+
+async def num_tokens_from_messages(messages, model=''):
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    if model == "gpt-3.5-turbo-0301":
+        tokens_per_message = 4
+    else:
+        tokens_per_message = 3
+    num_tokens = 0
+    for message in messages:
+        num_tokens += tokens_per_message
+        for key, value in message.items():
+            if isinstance(value, list):
+                for item in value:
+                    if item.get("type") == "text":
+                        num_tokens += len(encoding.encode(item.get("text")))
+                    if item.get("type") == "image_url":
+                        pass
+            else:
+                num_tokens += len(encoding.encode(value))
+    num_tokens += 3
+    return num_tokens
+
+
+async def num_tokens_from_content(content, model=None):
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    encoded_content = encoding.encode(content)
+    len_encoded_content = len(encoded_content)
+    return len_encoded_content
+
+
+async def split_tokens_from_content(content, max_tokens, model=None):
+    try:
+        encoding = tiktoken.encoding_for_model(model)
+    except KeyError:
+        encoding = tiktoken.get_encoding("cl100k_base")
+    encoded_content = encoding.encode(content)
+    len_encoded_content = len(encoded_content)
+    if len_encoded_content >= max_tokens:
+        content = encoding.decode(encoded_content[:max_tokens])
+        return content, max_tokens, "length"
+    else:
+        return content, len_encoded_content, "stop"

app.py

@@ -0,0 +1,9 @@
+import uvicorn
+
+log_config = uvicorn.config.LOGGING_CONFIG
+default_format = "%(asctime)s | %(levelname)s | %(message)s"
+access_format = r'%(asctime)s | %(levelname)s | %(client_addr)s: %(request_line)s %(status_code)s'
+log_config["formatters"]["default"]["fmt"] = default_format
+log_config["formatters"]["access"]["fmt"] = access_format
+
+uvicorn.run("chat2api:app", host="0.0.0.0", port=5005)

chat2api.py

@@ -0,0 +1,133 @@
+import asyncio
+import types
+import warnings
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from fastapi import FastAPI, Request, Depends, HTTPException, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import HTMLResponse
+from fastapi.responses import StreamingResponse, JSONResponse
+from fastapi.security import OAuth2PasswordBearer
+from fastapi.templating import Jinja2Templates
+from starlette.background import BackgroundTask
+
+from chatgpt.ChatService import ChatService
+from chatgpt.authorization import refresh_all_tokens
+import chatgpt.globals as globals
+from chatgpt.reverseProxy import chatgpt_reverse_proxy
+from utils.Logger import logger
+from utils.config import api_prefix, scheduled_refresh
+from utils.retry import async_retry
+
+warnings.filterwarnings("ignore")
+
+app = FastAPI()
+scheduler = AsyncIOScheduler()
+templates = Jinja2Templates(directory="templates")
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token", auto_error=False)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.on_event("startup")
+async def app_start():
+    if scheduled_refresh:
+        scheduler.add_job(id='refresh', func=refresh_all_tokens, trigger='cron', hour=3, minute=0, day='*/4', kwargs={'force_refresh': True})
+        scheduler.start()
+        asyncio.get_event_loop().call_later(0, lambda: asyncio.create_task(refresh_all_tokens(force_refresh=False)))
+
+
+async def to_send_conversation(request_data, req_token):
+    chat_service = ChatService(req_token)
+    try:
+        await chat_service.set_dynamic_data(request_data)
+        await chat_service.get_chat_requirements()
+        return chat_service
+    except HTTPException as e:
+        await chat_service.close_client()
+        raise HTTPException(status_code=e.status_code, detail=e.detail)
+    except Exception as e:
+        await chat_service.close_client()
+        logger.error(f"Server error, {str(e)}")
+        raise HTTPException(status_code=500, detail="Server error")
+
+
+async def process(request_data, req_token):
+    chat_service = await to_send_conversation(request_data, req_token)
+    await chat_service.prepare_send_conversation()
+    res = await chat_service.send_conversation()
+    return chat_service, res
+
+
+@app.post(f"/{api_prefix}/v1/chat/completions" if api_prefix else "/v1/chat/completions")
+async def send_conversation(request: Request, req_token: str = Depends(oauth2_scheme)):
+    try:
+        request_data = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail={"error": "Invalid JSON body"})
+    chat_service, res = await async_retry(process, request_data, req_token)
+    try:
+        if isinstance(res, types.AsyncGeneratorType):
+            background = BackgroundTask(chat_service.close_client)
+            return StreamingResponse(res, media_type="text/event-stream", background=background)
+        else:
+            background = BackgroundTask(chat_service.close_client)
+            return JSONResponse(res, media_type="application/json", background=background)
+    except HTTPException as e:
+        await chat_service.close_client()
+        if e.status_code == 500:
+            logger.error(f"Server error, {str(e)}")
+            raise HTTPException(status_code=500, detail="Server error")
+        raise HTTPException(status_code=e.status_code, detail=e.detail)
+    except Exception as e:
+        await chat_service.close_client()
+        logger.error(f"Server error, {str(e)}")
+        raise HTTPException(status_code=500, detail="Server error")
+
+
+@app.get(f"/{api_prefix}/tokens" if api_prefix else "/tokens", response_class=HTMLResponse)
+async def upload_html(request: Request):
+    tokens_count = len(set(globals.token_list) - set(globals.error_token_list))
+    return templates.TemplateResponse("tokens.html",
+                                      {"request": request, "api_prefix": api_prefix, "tokens_count": tokens_count})
+
+
+@app.post(f"/{api_prefix}/tokens/upload" if api_prefix else "/tokens/upload")
+async def upload_post(text: str = Form(...)):
+    lines = text.split("\n")
+    for line in lines:
+        if line.strip() and not line.startswith("#"):
+            globals.token_list.append(line.strip())
+            with open("data/token.txt", "a", encoding="utf-8") as f:
+                f.write(line.strip() + "\n")
+    logger.info(f"Token count: {len(globals.token_list)}, Error token count: {len(globals.error_token_list)}")
+    tokens_count = len(set(globals.token_list) - set(globals.error_token_list))
+    return {"status": "success", "tokens_count": tokens_count}
+
+
+@app.post(f"/{api_prefix}/tokens/clear" if api_prefix else "/tokens/clear")
+async def upload_post():
+    globals.token_list.clear()
+    globals.error_token_list.clear()
+    with open("data/token.txt", "w", encoding="utf-8") as f:
+        pass
+    logger.info(f"Token count: {len(globals.token_list)}, Error token count: {len(globals.error_token_list)}")
+    tokens_count = len(set(globals.token_list) - set(globals.error_token_list))
+    return {"status": "success", "tokens_count": tokens_count}
+
+
+@app.post(f"/{api_prefix}/tokens/error" if api_prefix else "/tokens/error")
+async def error_tokens():
+    error_tokens_list = list(set(globals.error_token_list))
+    return {"status": "success", "error_tokens": error_tokens_list}
+
+
+@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+async def reverse_proxy(request: Request, path: str):
+    return await chatgpt_reverse_proxy(request, path)

chatgpt/ChatService.py

@@ -0,0 +1,490 @@
+import asyncio
+import json
+import random
+import uuid
+
+from fastapi import HTTPException
+from starlette.concurrency import run_in_threadpool
+
+from api.files import get_image_size, get_file_extension, determine_file_use_case
+from api.models import model_proxy
+from chatgpt.authorization import get_req_token, verify_token
+from chatgpt.chatFormat import api_messages_to_chat, stream_response, format_not_stream_response, head_process_response
+from chatgpt.chatLimit import check_is_limit, handle_request_limit
+from chatgpt.proofofWork import get_config, get_dpl, get_answer_token, get_requirements_token
+
+from utils.Client import Client
+from utils.Logger import logger
+from utils.config import proxy_url_list, chatgpt_base_url_list, ark0se_token_url_list, history_disabled, pow_difficulty, \
+    conversation_only, enable_limit, upload_by_url, check_model, auth_key, user_agents_list, turnstile_solver_url
+
+
+class ChatService:
+    def __init__(self, origin_token=None):
+        self.user_agent = random.choice(user_agents_list) if user_agents_list else "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36"
+        self.req_token = get_req_token(origin_token)
+        self.chat_token = "gAAAAAB"
+        self.s = None
+        self.ws = None
+
+    async def set_dynamic_data(self, data):
+        if self.req_token:
+            logger.info(f"Request token: {self.req_token}")
+            req_len = len(self.req_token.split(","))
+            if req_len == 1:
+                self.access_token = await verify_token(self.req_token)
+                self.account_id = None
+            else:
+                self.access_token = await verify_token(self.req_token.split(",")[0])
+                self.account_id = self.req_token.split(",")[1]
+        else:
+            logger.info("Request token is empty, use no-auth 3.5")
+            self.access_token = None
+            self.account_id = None
+
+        self.data = data
+        await self.set_model()
+        if enable_limit and self.req_token:
+            limit_response = await handle_request_limit(self.req_token, self.req_model)
+            if limit_response:
+                raise HTTPException(status_code=429, detail=limit_response)
+
+        self.account_id = self.data.get('Chatgpt-Account-Id', self.account_id)
+        self.parent_message_id = self.data.get('parent_message_id')
+        self.conversation_id = self.data.get('conversation_id')
+        self.history_disabled = self.data.get('history_disabled', history_disabled)
+
+        self.api_messages = self.data.get("messages", [])
+        self.prompt_tokens = 0
+        self.max_tokens = self.data.get("max_tokens", 2147483647)
+        if not isinstance(self.max_tokens, int):
+            self.max_tokens = 2147483647
+
+        self.proxy_url = random.choice(proxy_url_list) if proxy_url_list else None
+        self.host_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        self.ark0se_token_url = random.choice(ark0se_token_url_list) if ark0se_token_url_list else None
+
+        self.s = Client(proxy=self.proxy_url)
+
+        self.oai_device_id = str(uuid.uuid4())
+        self.persona = None
+        self.ark0se_token = None
+        self.proof_token = None
+        self.turnstile_token = None
+
+        self.chat_headers = None
+        self.chat_request = None
+
+        self.base_headers = {
+            'Accept': '*/*',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Content-Type': 'application/json',
+            'Oai-Device-Id': self.oai_device_id,
+            'Oai-Language': 'en-US',
+            'Origin': self.host_url,
+            'Priority': 'u=1, i',
+            'Referer': f'{self.host_url}/',
+            'Sec-Ch-Ua': '"Chromium";v="124", "Microsoft Edge";v="124", "Not-A.Brand";v="99"',
+            'Sec-Ch-Ua-Mobile': '?0',
+            'Sec-Ch-Ua-Platform': '"Windows"',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'User-Agent': self.user_agent
+        }
+        if self.access_token:
+            self.base_url = self.host_url + "/backend-api"
+            self.base_headers['Authorization'] = f'Bearer {self.access_token}'
+            if self.account_id:
+                self.base_headers['Chatgpt-Account-Id'] = self.account_id
+        else:
+            self.base_url = self.host_url + "/backend-anon"
+
+        if auth_key:
+            self.base_headers['authkey'] = auth_key
+
+        await get_dpl(self)
+
+    async def set_model(self):
+        self.origin_model = self.data.get("model", "gpt-3.5-turbo-0125")
+        self.resp_model = model_proxy.get(self.origin_model, self.origin_model)
+        if "o1-preview" in self.origin_model:
+            self.req_model = "o1-preview"
+        elif "o1-mini" in self.origin_model:
+            self.req_model = "o1-mini"
+        elif "o1" in self.origin_model:
+            self.req_model = "o1"
+        elif "gpt-4.5o" in self.origin_model:
+            self.req_model = "gpt-4.5o"
+        elif "gpt-4o-canmore" in self.origin_model:
+            self.req_model = "gpt-4o-canmore"
+        elif "gpt-4o-mini" in self.origin_model:
+            self.req_model = "gpt-4o-mini"
+        elif "gpt-4o" in self.origin_model:
+            self.req_model = "gpt-4o"
+        elif "gpt-4-mobile" in self.origin_model:
+            self.req_model = "gpt-4-mobile"
+        elif "gpt-4-gizmo" in self.origin_model:
+            self.req_model = "gpt-4o"
+        elif "gpt-4" in self.origin_model:
+            self.req_model = "gpt-4"
+        elif "gpt-3.5" in self.origin_model:
+            self.req_model = "text-davinci-002-render-sha"
+        elif "auto" in self.origin_model:
+            self.req_model = "auto"
+        else:
+            self.req_model = "auto"
+
+    async def get_chat_requirements(self):
+        if conversation_only:
+            return None
+        url = f'{self.base_url}/sentinel/chat-requirements'
+        headers = self.base_headers.copy()
+        try:
+            config = get_config(self.user_agent)
+            p = get_requirements_token(config)
+            data = {'p': p}
+            r = await self.s.post(url, headers=headers, json=data, timeout=5)
+            if r.status_code == 200:
+                resp = r.json()
+
+                if check_model:
+                    r = await self.s.get(f'{self.base_url}/models', headers=headers, timeout=5)
+                    if r.status_code == 200:
+                        models = r.json().get('models')
+                        if not any(self.req_model in model.get("slug", "") for model in models):
+                            logger.error(f"Model {self.req_model} not support.")
+                            raise HTTPException(status_code=404, detail={
+                                "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
+                                "type": "invalid_request_error",
+                                "param": None,
+                                "code": "model_not_found"
+                            })
+                    else:
+                        raise HTTPException(status_code=404, detail="Failed to get models")
+                else:
+                    self.persona = resp.get("persona")
+                    if self.persona != "chatgpt-paid":
+                        if self.req_model == "gpt-4":
+                            logger.error(f"Model {self.resp_model} not support for {self.persona}")
+                            raise HTTPException(status_code=404, detail={
+                                "message": f"The model `{self.origin_model}` does not exist or you do not have access to it.",
+                                "type": "invalid_request_error",
+                                "param": None,
+                                "code": "model_not_found"
+                            })
+
+                turnstile = resp.get('turnstile', {})
+                turnstile_required = turnstile.get('required')
+                if turnstile_required:
+                    turnstile_dx = turnstile.get("dx")
+                    try:
+                        if turnstile_solver_url:
+                            res = await self.s.post(turnstile_solver_url, json={"url": "https://chatgpt.com", "p": p, "dx": turnstile_dx})
+                            self.turnstile_token = res.json().get("t")
+                    except Exception as e:
+                        logger.info(f"Turnstile ignored: {e}")
+                    # raise HTTPException(status_code=403, detail="Turnstile required")
+
+                ark0se = resp.get('ark' + 'ose', {})
+                ark0se_required = ark0se.get('required')
+                if ark0se_required:
+                    if self.persona == "chatgpt-freeaccount":
+                        ark0se_method = "chat35"
+                    else:
+                        ark0se_method = "chat4"
+                    if not self.ark0se_token_url:
+                        raise HTTPException(status_code=403, detail="Ark0se service required")
+                    ark0se_dx = ark0se.get("dx")
+                    ark0se_client = Client()
+                    try:
+                        r2 = await ark0se_client.post(
+                            url=self.ark0se_token_url,
+                            json={"blob": ark0se_dx, "method": ark0se_method},
+                            timeout=15
+                        )
+                        r2esp = r2.json()
+                        logger.info(f"ark0se_token: {r2esp}")
+                        if r2esp.get('solved', True):
+                            self.ark0se_token = r2esp.get('token')
+                        else:
+                            raise HTTPException(status_code=403, detail="Failed to get Ark0se token")
+                    except Exception:
+                        raise HTTPException(status_code=403, detail="Failed to get Ark0se token")
+                    finally:
+                        await ark0se_client.close()
+
+                proofofwork = resp.get('proofofwork', {})
+                proofofwork_required = proofofwork.get('required')
+                if proofofwork_required:
+                    proofofwork_diff = proofofwork.get("difficulty")
+                    if proofofwork_diff <= pow_difficulty:
+                        raise HTTPException(status_code=403,
+                                            detail=f"Proof of work difficulty too high: {proofofwork_diff}")
+                    proofofwork_seed = proofofwork.get("seed")
+                    self.proof_token, solved = await run_in_threadpool(get_answer_token, proofofwork_seed,
+                                                                       proofofwork_diff, config)
+                    if not solved:
+                        raise HTTPException(status_code=403, detail="Failed to solve proof of work")
+
+                self.chat_token = resp.get('token')
+                if not self.chat_token:
+                    raise HTTPException(status_code=403, detail=f"Failed to get chat token: {r.text}")
+                return self.chat_token
+            else:
+                if "application/json" == r.headers.get("Content-Type", ""):
+                    detail = r.json().get("detail", r.json())
+                else:
+                    detail = r.text
+                if "cf-spinner-please-wait" in detail:
+                    raise HTTPException(status_code=r.status_code, detail="cf-spinner-please-wait")
+                if r.status_code == 429:
+                    raise HTTPException(status_code=r.status_code, detail="rate-limit")
+                raise HTTPException(status_code=r.status_code, detail=detail)
+        except HTTPException as e:
+            raise HTTPException(status_code=e.status_code, detail=e.detail)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def prepare_send_conversation(self):
+        try:
+            chat_messages, self.prompt_tokens = await api_messages_to_chat(self, self.api_messages, upload_by_url)
+        except Exception as e:
+            logger.error(f"Failed to format messages: {str(e)}")
+            raise HTTPException(status_code=400, detail="Failed to format messages.")
+        self.chat_headers = self.base_headers.copy()
+        self.chat_headers.update({
+            'Accept': 'text/event-stream',
+            'Openai-Sentinel-Chat-Requirements-Token': self.chat_token,
+            'Openai-Sentinel-Proof-Token': self.proof_token,
+        })
+        if self.ark0se_token:
+            self.chat_headers['Openai-Sentinel-Ark' + 'ose-Token'] = self.ark0se_token
+
+        if self.turnstile_token:
+            self.chat_headers['Openai-Sentinel-Turnstile-Token'] = self.turnstile_token
+
+        if conversation_only:
+            self.chat_headers.pop('Openai-Sentinel-Chat-Requirements-Token', None)
+            self.chat_headers.pop('Openai-Sentinel-Proof-Token', None)
+            self.chat_headers.pop('Openai-Sentinel-Ark' + 'ose-Token', None)
+            self.chat_headers.pop('Openai-Sentinel-Turnstile-Token', None)
+
+        if "gpt-4-gizmo" in self.origin_model:
+            gizmo_id = self.origin_model.split("gpt-4-gizmo-")[-1]
+            conversation_mode = {"kind": "gizmo_interaction", "gizmo_id": gizmo_id}
+        else:
+            conversation_mode = {"kind": "primary_assistant"}
+
+        logger.info(f"Model mapping: {self.origin_model} -> {self.req_model}")
+        self.chat_request = {
+            "action": "next",
+            "conversation_mode": conversation_mode,
+            "force_nulligen": False,
+            "force_paragen": False,
+            "force_paragen_model_slug": "",
+            "force_rate_limit": False,
+            "force_use_sse": True,
+            "history_and_training_disabled": self.history_disabled,
+            "messages": chat_messages,
+            "model": self.req_model,
+            "parent_message_id": self.parent_message_id if self.parent_message_id else f"{uuid.uuid4()}",
+            "reset_rate_limits": False,
+            "suggestions": [],
+            "timezone_offset_min": -480,
+            "variant_purpose": "comparison_implicit",
+            "websocket_request_id": f"{uuid.uuid4()}"
+        }
+        if self.conversation_id:
+            self.chat_request['conversation_id'] = self.conversation_id
+        return self.chat_request
+
+    async def send_conversation(self):
+        try:
+            url = f'{self.base_url}/conversation'
+            stream = self.data.get("stream", False)
+            r = await self.s.post_stream(url, headers=self.chat_headers, json=self.chat_request, timeout=10,
+                                         stream=True)
+            if r.status_code != 200:
+                rtext = await r.atext()
+                if "application/json" == r.headers.get("Content-Type", ""):
+                    detail = json.loads(rtext).get("detail", json.loads(rtext))
+                    if r.status_code == 429:
+                        check_is_limit(detail, token=self.req_token, model=self.req_model)
+                else:
+                    if "cf-spinner-please-wait" in rtext:
+                        # logger.error(f"Failed to send conversation: cf-spinner-please-wait")
+                        raise HTTPException(status_code=r.status_code, detail="cf-spinner-please-wait")
+                    if r.status_code == 429:
+                        # logger.error(f"Failed to send conversation: rate-limit")
+                        raise HTTPException(status_code=r.status_code, detail="rate-limit")
+                    detail = r.text[:100]
+                # logger.error(f"Failed to send conversation: {detail}")
+                raise HTTPException(status_code=r.status_code, detail=detail)
+
+            content_type = r.headers.get("Content-Type", "")
+            if "text/event-stream" in content_type:
+                res, start = await head_process_response(r.aiter_lines())
+                if not start:
+                    raise HTTPException(status_code=403, detail="Our systems have detected unusual activity coming from your system. Please try again later.")
+                if stream:
+                    return stream_response(self, res, self.resp_model, self.max_tokens)
+                else:
+                    return await format_not_stream_response(
+                        stream_response(self, res, self.resp_model, self.max_tokens), self.prompt_tokens,
+                        self.max_tokens, self.resp_model)
+            elif "application/json" in content_type:
+                rtext = await r.atext()
+                resp = json.loads(rtext)
+                raise HTTPException(status_code=r.status_code, detail=resp)
+            else:
+                rtext = await r.atext()
+                raise HTTPException(status_code=r.status_code, detail=rtext)
+        except HTTPException as e:
+            raise HTTPException(status_code=e.status_code, detail=e.detail)
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=str(e))
+
+    async def get_download_url(self, file_id):
+        url = f"{self.base_url}/files/{file_id}/download"
+        headers = self.base_headers.copy()
+        try:
+            r = await self.s.get(url, headers=headers, timeout=5)
+            if r.status_code == 200:
+                download_url = r.json().get('download_url')
+                return download_url
+            else:
+                return ""
+        except HTTPException:
+            return ""
+
+    async def get_download_url_from_upload(self, file_id):
+        url = f"{self.base_url}/files/{file_id}/uploaded"
+        headers = self.base_headers.copy()
+        try:
+            r = await self.s.post(url, headers=headers, json={}, timeout=5)
+            if r.status_code == 200:
+                download_url = r.json().get('download_url')
+                return download_url
+            else:
+                return ""
+        except HTTPException:
+            return ""
+
+    async def get_upload_url(self, file_name, file_size, use_case="multimodal"):
+        url = f'{self.base_url}/files'
+        headers = self.base_headers.copy()
+        try:
+            r = await self.s.post(url, headers=headers, json={
+                "file_name": file_name,
+                "file_size": file_size,
+                "timezone_offset_min": -480,
+                "use_case": use_case
+            }, timeout=5)
+            if r.status_code == 200:
+                res = r.json()
+                file_id = res.get('file_id')
+                upload_url = res.get('upload_url')
+                logger.info(f"file_id: {file_id}, upload_url: {upload_url}")
+                return file_id, upload_url
+            else:
+                return "", ""
+        except HTTPException:
+            return "", ""
+
+    async def upload(self, upload_url, file_content, mime_type):
+        headers = self.base_headers.copy()
+        headers.update({
+            'Accept': 'application/json, text/plain, */*',
+            'Content-Type': mime_type,
+            'X-Ms-Blob-Type': 'BlockBlob',
+            'X-Ms-Version': '2020-04-08'
+        })
+        headers.pop('Authorization', None)
+        try:
+            r = await self.s.put(upload_url, headers=headers, data=file_content)
+            if r.status_code == 201:
+                return True
+            return False
+        except Exception:
+            return False
+
+    async def upload_file(self, file_content, mime_type):
+        if not file_content or not mime_type:
+            return None
+
+        width, height = None, None
+        if mime_type.startswith("image/"):
+            try:
+                width, height = await get_image_size(file_content)
+            except Exception as e:
+                logger.error(f"Error image mime_type, change to text/plain: {e}")
+                mime_type = 'text/plain'
+        file_size = len(file_content)
+        file_extension = await get_file_extension(mime_type)
+        file_name = f"{uuid.uuid4()}{file_extension}"
+        use_case = await determine_file_use_case(mime_type)
+
+        file_id, upload_url = await self.get_upload_url(file_name, file_size, use_case)
+        if file_id and upload_url:
+            if await self.upload(upload_url, file_content, mime_type):
+                download_url = await self.get_download_url_from_upload(file_id)
+                if download_url:
+                    file_meta = {
+                        "file_id": file_id,
+                        "file_name": file_name,
+                        "size_bytes": file_size,
+                        "mime_type": mime_type,
+                        "width": width,
+                        "height": height,
+                        "use_case": use_case
+                    }
+                    logger.info(f"File_meta: {file_meta}")
+                    return file_meta
+                else:
+                    logger.error("Failed to get download url")
+            else:
+                logger.error("Failed to upload file")
+        else:
+            logger.error("Failed to get upload url")
+
+    async def check_upload(self, file_id):
+        url = f'{self.base_url}/files/{file_id}'
+        headers = self.base_headers.copy()
+        try:
+            for i in range(30):
+                r = await self.s.get(url, headers=headers, timeout=5)
+                if r.status_code == 200:
+                    res = r.json()
+                    retrieval_index_status = res.get('retrieval_index_status', '')
+                    if retrieval_index_status == "success":
+                        break
+                await asyncio.sleep(1)
+            return True
+        except HTTPException:
+            return False
+
+    async def get_response_file_url(self, conversation_id, message_id, sandbox_path):
+        try:
+            url = f"{self.base_url}/conversation/{conversation_id}/interpreter/download"
+            params = {
+                "message_id": message_id,
+                "sandbox_path": sandbox_path
+            }
+            headers = self.base_headers.copy()
+            r = await self.s.get(url, headers=headers, params=params, timeout=10)
+            if r.status_code == 200:
+                return r.json().get("download_url")
+            else:
+                return None
+        except Exception:
+            logger.info("Failed to get response file url")
+            return None
+
+    async def close_client(self):
+        if self.s:
+            await self.s.close()
+        if self.ws:
+            await self.ws.close()
+            del self.ws

chatgpt/authorization.py

@@ -0,0 +1,55 @@
+import asyncio
+
+from fastapi import HTTPException
+
+from chatgpt.refreshToken import rt2ac
+from utils.Logger import logger
+from utils.config import authorization_list
+import chatgpt.globals as globals
+
+
+def get_req_token(req_token):
+    if req_token in authorization_list:
+        if len(globals.token_list) - len(globals.error_token_list) > 0:
+            globals.count += 1
+            globals.count %= len(globals.token_list)
+            while globals.token_list[globals.count] in globals.error_token_list:
+                globals.count += 1
+                globals.count %= len(globals.token_list)
+            return globals.token_list[globals.count]
+        else:
+            return None
+    else:
+        return req_token
+
+
+async def verify_token(req_token):
+    if not req_token:
+        if authorization_list:
+            logger.error("Unauthorized with empty token.")
+            raise HTTPException(status_code=401)
+        else:
+            return None
+    else:
+        if req_token.startswith("eyJhbGciOi") or req_token.startswith("fk-"):
+            access_token = req_token
+            return access_token
+        elif len(req_token) == 45:
+            try:
+                access_token = await rt2ac(req_token, force_refresh=False)
+                return access_token
+            except HTTPException as e:
+                raise HTTPException(status_code=e.status_code, detail=e.detail)
+        else:
+            return req_token
+
+
+async def refresh_all_tokens(force_refresh=False):
+    for token in globals.token_list:
+        if len(token) == 45:
+            try:
+                await asyncio.sleep(2)
+                await rt2ac(token, force_refresh=force_refresh)
+            except HTTPException:
+                pass
+    logger.info("All tokens refreshed.")

chatgpt/chatFormat.py

@@ -0,0 +1,436 @@
+import asyncio
+import json
+import random
+import re
+import string
+import time
+import uuid
+
+import pybase64
+import websockets
+from fastapi import HTTPException
+
+from api.files import get_file_content
+from api.models import model_system_fingerprint
+from api.tokens import split_tokens_from_content, calculate_image_tokens, num_tokens_from_messages
+from utils.Logger import logger
+
+moderation_message = "I'm sorry, I cannot provide or engage in any content related to pornography, violence, or any unethical material. If you have any other questions or need assistance, please feel free to let me know. I'll do my best to provide support and assistance."
+
+
+async def format_not_stream_response(response, prompt_tokens, max_tokens, model):
+    chat_id = f"chatcmpl-{''.join(random.choice(string.ascii_letters + string.digits) for _ in range(29))}"
+    system_fingerprint_list = model_system_fingerprint.get(model, None)
+    system_fingerprint = random.choice(system_fingerprint_list) if system_fingerprint_list else None
+    created_time = int(time.time())
+    all_text = ""
+    async for chunk in response:
+        try:
+            if chunk.startswith("data: [DONE]"):
+                break
+            elif not chunk.startswith("data: "):
+                continue
+            else:
+                chunk = json.loads(chunk[6:])
+                if not chunk["choices"][0].get("delta"):
+                    continue
+                all_text += chunk["choices"][0]["delta"]["content"]
+        except Exception as e:
+            logger.error(f"Error: {chunk}, error: {str(e)}")
+            continue
+    content, completion_tokens, finish_reason = await split_tokens_from_content(all_text, max_tokens, model)
+    message = {
+        "role": "assistant",
+        "content": content,
+    }
+    usage = {
+        "prompt_tokens": prompt_tokens,
+        "completion_tokens": completion_tokens,
+        "total_tokens": prompt_tokens + completion_tokens
+    }
+    if not message.get("content"):
+        raise HTTPException(status_code=403, detail="No content in the message.")
+
+    data = {
+        "id": chat_id,
+        "object": "chat.completion",
+        "created": created_time,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "message": message,
+                "logprobs": None,
+                "finish_reason": finish_reason
+            }
+        ],
+        "usage": usage
+    }
+    if system_fingerprint:
+        data["system_fingerprint"] = system_fingerprint
+    return data
+
+
+async def wss_stream_response(websocket, conversation_id):
+    while not websocket.closed:
+        try:
+            message = await asyncio.wait_for(websocket.recv(), timeout=10)
+            if message:
+                resultObj = json.loads(message)
+                sequenceId = resultObj.get("sequenceId", None)
+                if not sequenceId:
+                    continue
+                data = resultObj.get("data", {})
+                if conversation_id != data.get("conversation_id", ""):
+                    continue
+                sequenceId = resultObj.get('sequenceId')
+                if sequenceId and sequenceId % 80 == 0:
+                    await websocket.send(
+                        json.dumps(
+                            {"type": "sequenceAck", "sequenceId": sequenceId}
+                        )
+                    )
+                decoded_bytes = pybase64.b64decode(data.get("body", None))
+                yield decoded_bytes
+            else:
+                print("No message received within the specified time.")
+        except asyncio.TimeoutError:
+            logger.error("Timeout! No message received within the specified time.")
+            break
+        except websockets.ConnectionClosed as e:
+            if e.code == 1000:
+                logger.error("WebSocket closed normally with code 1000 (OK)")
+                yield b"data: [DONE]\n\n"
+            else:
+                logger.error(f"WebSocket closed with error code {e.code}")
+        except Exception as e:
+            logger.error(f"Error: {str(e)}")
+            continue
+
+
+async def head_process_response(response):
+    async for chunk in response:
+        chunk = chunk.decode("utf-8")
+        if chunk.startswith("data: {"):
+            chunk_old_data = json.loads(chunk[6:])
+            message = chunk_old_data.get("message", {})
+            if not message and "error" in chunk_old_data:
+                return response, False
+            role = message.get('author', {}).get('role')
+            if role == 'user' or role == 'system':
+                continue
+
+            status = message.get("status")
+            if status == "in_progress":
+                return response, True
+    return response, False
+
+
+async def stream_response(service, response, model, max_tokens):
+    chat_id = f"chatcmpl-{''.join(random.choice(string.ascii_letters + string.digits) for _ in range(29))}"
+    system_fingerprint_list = model_system_fingerprint.get(model, None)
+    system_fingerprint = random.choice(system_fingerprint_list) if system_fingerprint_list else None
+    created_time = int(time.time())
+    completion_tokens = 0
+    len_last_content = 0
+    len_last_citation = 0
+    last_message_id = None
+    last_role = None
+    last_content_type = None
+    model_slug = None
+    end = False
+
+    chunk_new_data = {
+        "id": chat_id,
+        "object": "chat.completion.chunk",
+        "created": created_time,
+        "model": model,
+        "choices": [
+            {
+                "index": 0,
+                "delta": {"role": "assistant", "content": ""},
+                "logprobs": None,
+                "finish_reason": None
+            }
+        ]
+    }
+    if system_fingerprint:
+        chunk_new_data["system_fingerprint"] = system_fingerprint
+    yield f"data: {json.dumps(chunk_new_data)}\n\n"
+
+    async for chunk in response:
+        chunk = chunk.decode("utf-8")
+        if end:
+            logger.info(f"Response Model: {model_slug}")
+            yield "data: [DONE]\n\n"
+            break
+        try:
+            if chunk.startswith("data: {"):
+                chunk_old_data = json.loads(chunk[6:])
+                finish_reason = None
+                message = chunk_old_data.get("message", {})
+                conversation_id = chunk_old_data.get("conversation_id")
+                role = message.get('author', {}).get('role')
+                if role == 'user' or role == 'system':
+                    continue
+
+                status = message.get("status")
+                message_id = message.get("id")
+                content = message.get("content", {})
+                recipient = message.get("recipient", "")
+                meta_data = message.get("metadata", {})
+                initial_text = meta_data.get("initial_text", "")
+                model_slug = meta_data.get("model_slug", model_slug)
+
+                if not message and chunk_old_data.get("type") == "moderation":
+                    delta = {"role": "assistant", "content": moderation_message}
+                    finish_reason = "stop"
+                    end = True
+                elif status == "in_progress":
+                    outer_content_type = content.get("content_type")
+                    if outer_content_type == "text":
+                        part = content.get("parts", [])[0]
+                        if not part:
+                            if role == 'assistant' and last_role != 'assistant':
+                                if last_role == None:
+                                    new_text = ""
+                                else:
+                                    new_text = f"\n"
+                            elif role == 'tool' and last_role != 'tool':
+                                new_text = f">{initial_text}\n"
+                            else:
+                                new_text = ""
+                        else:
+                            if last_message_id and last_message_id != message_id:
+                                continue
+                            citation = message.get("metadata", {}).get("citations", [])
+                            if len(citation) > len_last_citation:
+                                inside_metadata = citation[-1].get("metadata", {})
+                                citation_title = inside_metadata.get("title", "")
+                                citation_url = inside_metadata.get("url", "")
+                                new_text = f' **[[""]]({citation_url} "{citation_title}")** '
+                                len_last_citation = len(citation)
+                            else:
+                                if role == 'assistant' and last_role != 'assistant':
+                                    if recipient == 'dalle.text2im':
+                                        new_text = f"\n```{recipient}\n{part[len_last_content:]}"
+                                    elif last_role == None:
+                                        new_text = part[len_last_content:]
+                                    else:
+                                        new_text = f"\n\n{part[len_last_content:]}"
+                                elif role == 'tool' and last_role != 'tool':
+                                    new_text = f">{initial_text}\n{part[len_last_content:]}"
+                                elif role == 'tool':
+                                    new_text = part[len_last_content:].replace("\n\n", "\n")
+                                else:
+                                    new_text = part[len_last_content:]
+                            len_last_content = len(part)
+                    else:
+                        text = content.get("text", "")
+                        if outer_content_type == "code" and last_content_type != "code":
+                            language = content.get("language", "")
+                            if not language or language == "unknown":
+                                language = recipient
+                            new_text = "\n```" + language + "\n" + text[len_last_content:]
+                        elif outer_content_type == "execution_output" and last_content_type != "execution_output":
+                            new_text = "\n```" + "Output" + "\n" + text[len_last_content:]
+                        else:
+                            new_text = text[len_last_content:]
+                        len_last_content = len(text)
+                    if last_content_type == "code" and outer_content_type != "code":
+                        new_text = "\n```\n" + new_text
+                    elif last_content_type == "execution_output" and outer_content_type != "execution_output":
+                        new_text = "\n```\n" + new_text
+
+                    delta = {"content": new_text}
+                    last_content_type = outer_content_type
+                    if completion_tokens >= max_tokens:
+                        delta = {}
+                        finish_reason = "length"
+                        end = True
+                elif status == "finished_successfully":
+                    if content.get("content_type") == "multimodal_text":
+                        parts = content.get("parts", [])
+                        delta = {}
+                        for part in parts:
+                            if isinstance(part, str):
+                                continue
+                            inner_content_type = part.get('content_type')
+                            if inner_content_type == "image_asset_pointer":
+                                last_content_type = "image_asset_pointer"
+                                file_id = part.get('asset_pointer').replace('file-service://', '')
+                                logger.debug(f"file_id: {file_id}")
+                                image_download_url = await service.get_download_url(file_id)
+                                logger.debug(f"image_download_url: {image_download_url}")
+                                if image_download_url:
+                                    delta = {"content": f"\n```\n![image]({image_download_url})\n"}
+                                else:
+                                    delta = {"content": f"\n```\nFailed to load the image.\n"}
+                    elif message.get("end_turn"):
+                        part = content.get("parts", [])[0]
+                        new_text = part[len_last_content:]
+                        if not new_text:
+                            matches = re.findall(r'\(sandbox:(.*?)\)', part)
+                            if matches:
+                                file_url_content = ""
+                                for i, sandbox_path in enumerate(matches):
+                                    file_download_url = await service.get_response_file_url(conversation_id, message_id, sandbox_path)
+                                    if file_download_url:
+                                        file_url_content += f"\n```\n\n![File {i+1}]({file_download_url})\n"
+                                delta = {"content": file_url_content}
+                            else:
+                                delta = {}
+                        else:
+                            delta = {"content": new_text}
+                        finish_reason = "stop"
+                        end = True
+                    else:
+                        len_last_content = 0
+                        if meta_data.get("finished_text"):
+                            delta = {"content": f"\n{meta_data.get('finished_text')}\n"}
+                        else:
+                            continue
+                else:
+                    continue
+                last_message_id = message_id
+                last_role = role
+                if not end and not delta.get("content"):
+                    delta = {"role": "assistant", "content": ""}
+                chunk_new_data["choices"][0]["delta"] = delta
+                chunk_new_data["choices"][0]["finish_reason"] = finish_reason
+                if not service.history_disabled:
+                    chunk_new_data.update({
+                        "message_id": message_id,
+                        "conversation_id": conversation_id,
+                    })
+                completion_tokens += 1
+                yield f"data: {json.dumps(chunk_new_data)}\n\n"
+            elif chunk.startswith("data: [DONE]"):
+                logger.info(f"Response Model: {model_slug}")
+                yield "data: [DONE]\n\n"
+            else:
+                continue
+        except Exception as e:
+            if chunk.startswith("data: "):
+                chunk_data = json.loads(chunk[6:])
+                if chunk_data.get("error"):
+                    logger.error(f"Error: {chunk_data.get('error')}")
+                    yield "data: [DONE]\n\n"
+                    break
+            logger.error(f"Error: {chunk}, details: {str(e)}")
+            continue
+
+
+def get_url_from_content(content):
+    if isinstance(content, str) and content.startswith('http'):
+        try:
+            url = re.match(
+                r'(?i)\b((?:[a-z][\w-]+:(?:/{1,3}|[a-z0-9%])|www\d{0,3}[.]|[a-z0-9.\-]+[.][a-z]{2,4}/)(?:[^\s()<>]+|\(([^\s()<>]+|(\([^\s()<>]+\)))*\))+(?:\(([^\s()<>]+|(\([^\s()<>]+\)))*\)|[^\s`!()\[\]{};:\'".,<>?«»“”‘’]))',
+                content.split(' ')[0])[0]
+            content = content.replace(url, '').strip()
+            return url, content
+        except Exception:
+            return None, content
+    return None, content
+
+
+def format_messages_with_url(content):
+    url_list = []
+    while True:
+        url, content = get_url_from_content(content)
+        if url:
+            url_list.append(url)
+            logger.info(f"Found a file_url from messages: {url}")
+        else:
+            break
+    if not url_list:
+        return content
+    new_content = [
+        {
+            "type": "text",
+            "text": content
+        }
+    ]
+    for url in url_list:
+        new_content.append({
+            "type": "image_url",
+            "image_url": {
+                "url": url
+            }
+        })
+    return new_content
+
+
+async def api_messages_to_chat(service, api_messages, upload_by_url=False):
+    file_tokens = 0
+    chat_messages = []
+    for api_message in api_messages:
+        role = api_message.get('role')
+        content = api_message.get('content')
+        if upload_by_url:
+            if isinstance(content, str):
+                content = format_messages_with_url(content)
+        if isinstance(content, list):
+            parts = []
+            attachments = []
+            content_type = "multimodal_text"
+            for i in content:
+                if i.get("type") == "text":
+                    parts.append(i.get("text"))
+                elif i.get("type") == "image_url":
+                    image_url = i.get("image_url")
+                    url = image_url.get("url")
+                    detail = image_url.get("detail", "auto")
+                    file_content, mime_type = await get_file_content(url)
+                    file_meta = await service.upload_file(file_content, mime_type)
+                    if file_meta:
+                        file_id = file_meta["file_id"]
+                        file_size = file_meta["size_bytes"]
+                        file_name = file_meta["file_name"]
+                        mime_type = file_meta["mime_type"]
+                        use_case = file_meta["use_case"]
+                        if mime_type.startswith("image/"):
+                            width, height = file_meta["width"], file_meta["height"]
+                            file_tokens += await calculate_image_tokens(width, height, detail)
+                            parts.append({
+                                "content_type": "image_asset_pointer",
+                                "asset_pointer": f"file-service://{file_id}",
+                                "size_bytes": file_size,
+                                "width": width,
+                                "height": height
+                            })
+                            attachments.append({
+                                "id": file_id,
+                                "size": file_size,
+                                "name": file_name,
+                                "mime_type": mime_type,
+                                "width": width,
+                                "height": height
+                            })
+                        else:
+                            if not use_case == "ace_upload":
+                                await service.check_upload(file_id)
+                            file_tokens += file_size // 1000
+                            attachments.append({
+                                "id": file_id,
+                                "size": file_size,
+                                "name": file_name,
+                                "mime_type": mime_type,
+                            })
+            metadata = {
+                "attachments": attachments
+            }
+        else:
+            content_type = "text"
+            parts = [content]
+            metadata = {}
+        chat_message = {
+            "id": f"{uuid.uuid4()}",
+            "author": {"role": role},
+            "content": {"content_type": content_type, "parts": parts},
+            "metadata": metadata
+        }
+        chat_messages.append(chat_message)
+    text_tokens = await num_tokens_from_messages(api_messages, service.resp_model)
+    prompt_tokens = text_tokens + file_tokens
+    return chat_messages, prompt_tokens

chatgpt/chatLimit.py

@@ -0,0 +1,35 @@
+import threading
+import time
+from datetime import datetime
+
+from utils.Logger import logger
+
+limit_details = {}
+
+
+def check_is_limit(detail, token, model):
+    if token and isinstance(detail, dict) and detail.get('clears_in'):
+        clear_time = int(time.time()) + detail.get('clears_in')
+        limit_details.setdefault(token, {})[model] = clear_time
+        logger.info(f"{token[:40]}: Reached {model} limit, will be cleared at {datetime.fromtimestamp(clear_time).replace(microsecond=0)}")
+
+
+async def handle_request_limit(token, model):
+    try:
+        if limit_details.get(token) and model in limit_details[token]:
+            limit_time = limit_details[token][model]
+            is_limit = limit_time > int(time.time())
+            if is_limit:
+                clear_date = datetime.fromtimestamp(limit_time).replace(microsecond=0)
+                result = f"Request limit exceeded. You can continue with the default model now, or try again after {clear_date}"
+                logger.info(result)
+                return result
+            else:
+                del limit_details[token][model]
+                return None
+    except KeyError as e:
+        logger.error(f"Key error: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+        return None

chatgpt/globals.py

@@ -0,0 +1,54 @@
+import json
+import os
+
+from utils.Logger import logger
+
+DATA_FOLDER = "data"
+TOKENS_FILE = os.path.join(DATA_FOLDER, "token.txt")
+REFRESH_MAP_FILE = os.path.join(DATA_FOLDER, "refresh_map.json")
+ERROR_TOKENS_FILE = os.path.join(DATA_FOLDER, "error_token.txt")
+WSS_MAP_FILE = os.path.join(DATA_FOLDER, "wss_map.json")
+
+count = 0
+token_list = []
+error_token_list = []
+refresh_map = {}
+wss_map = {}
+
+
+if not os.path.exists(DATA_FOLDER):
+    os.makedirs(DATA_FOLDER)
+
+if os.path.exists(REFRESH_MAP_FILE):
+    with open(REFRESH_MAP_FILE, "r") as file:
+        refresh_map = json.load(file)
+else:
+    refresh_map = {}
+
+if os.path.exists(WSS_MAP_FILE):
+    with open(WSS_MAP_FILE, "r") as file:
+        wss_map = json.load(file)
+else:
+    wss_map = {}
+    
+    
+if os.path.exists(TOKENS_FILE):
+    with open(TOKENS_FILE, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip() and not line.startswith("#"):
+                token_list.append(line.strip())
+else:
+    with open(TOKENS_FILE, "w", encoding="utf-8") as f:
+        pass
+
+if os.path.exists(ERROR_TOKENS_FILE):
+    with open(ERROR_TOKENS_FILE, "r", encoding="utf-8") as f:
+        for line in f:
+            if line.strip() and not line.startswith("#"):
+                error_token_list.append(line.strip())
+else:
+    with open(ERROR_TOKENS_FILE, "w", encoding="utf-8") as f:
+        pass
+
+if token_list:
+    logger.info(f"Token list count: {len(token_list)}, Error token list count: {len(error_token_list)}")

chatgpt/proofofWork.py

@@ -0,0 +1,512 @@
+import hashlib
+import json
+import random
+import re
+import time
+import uuid
+from datetime import datetime, timedelta, timezone
+from html.parser import HTMLParser
+
+import pybase64
+
+from utils.Logger import logger
+from utils.config import conversation_only
+
+cores = [16, 24, 32]
+screens = [3000, 4000, 6000]
+timeLayout = "%a %b %d %Y %H:%M:%S"
+
+cached_scripts = []
+cached_dpl = ""
+cached_time = 0
+cached_require_proof = ""
+
+navigator_key = [
+    "registerProtocolHandler−function registerProtocolHandler() { [native code] }",
+    "storage−[object StorageManager]",
+    "locks−[object LockManager]",
+    "appCodeName−Mozilla",
+    "permissions−[object Permissions]",
+    "appVersion−5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "share−function share() { [native code] }",
+    "webdriver−false",
+    "managed−[object NavigatorManagedData]",
+    "canShare−function canShare() { [native code] }",
+    "vendor−Google Inc.",
+    "vendor−Google Inc.",
+    "mediaDevices−[object MediaDevices]",
+    "vibrate−function vibrate() { [native code] }",
+    "storageBuckets−[object StorageBucketManager]",
+    "mediaCapabilities−[object MediaCapabilities]",
+    "getGamepads−function getGamepads() { [native code] }",
+    "bluetooth−[object Bluetooth]",
+    "share−function share() { [native code] }",
+    "cookieEnabled−true",
+    "virtualKeyboard−[object VirtualKeyboard]",
+    "product−Gecko",
+    "mediaDevices−[object MediaDevices]",
+    "canShare−function canShare() { [native code] }",
+    "getGamepads−function getGamepads() { [native code] }",
+    "product−Gecko",
+    "xr−[object XRSystem]",
+    "clipboard−[object Clipboard]",
+    "storageBuckets−[object StorageBucketManager]",
+    "unregisterProtocolHandler−function unregisterProtocolHandler() { [native code] }",
+    "productSub−20030107",
+    "login−[object NavigatorLogin]",
+    "vendorSub−",
+    "login−[object NavigatorLogin]",
+    "userAgent−Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "getInstalledRelatedApps−function getInstalledRelatedApps() { [native code] }",
+    "userAgent−Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "mediaDevices−[object MediaDevices]",
+    "locks−[object LockManager]",
+    "webkitGetUserMedia−function webkitGetUserMedia() { [native code] }",
+    "vendor−Google Inc.",
+    "xr−[object XRSystem]",
+    "mediaDevices−[object MediaDevices]",
+    "virtualKeyboard−[object VirtualKeyboard]",
+    "userAgent−Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "virtualKeyboard−[object VirtualKeyboard]",
+    "appName−Netscape",
+    "storageBuckets−[object StorageBucketManager]",
+    "presentation−[object Presentation]",
+    "onLine−true",
+    "mimeTypes−[object MimeTypeArray]",
+    "credentials−[object CredentialsContainer]",
+    "presentation−[object Presentation]",
+    "getGamepads−function getGamepads() { [native code] }",
+    "vendorSub−",
+    "virtualKeyboard−[object VirtualKeyboard]",
+    "serviceWorker−[object ServiceWorkerContainer]",
+    "xr−[object XRSystem]",
+    "product−Gecko",
+    "keyboard−[object Keyboard]",
+    "gpu−[object GPU]",
+    "getInstalledRelatedApps−function getInstalledRelatedApps() { [native code] }",
+    "webkitPersistentStorage−[object DeprecatedStorageQuota]",
+    "doNotTrack",
+    "clearAppBadge−function clearAppBadge() { [native code] }",
+    "presentation−[object Presentation]",
+    "serial−[object Serial]",
+    "locks−[object LockManager]",
+    "requestMIDIAccess−function requestMIDIAccess() { [native code] }",
+    "locks−[object LockManager]",
+    "requestMediaKeySystemAccess−function requestMediaKeySystemAccess() { [native code] }",
+    "vendor−Google Inc.",
+    "pdfViewerEnabled−true",
+    "language−zh-CN",
+    "setAppBadge−function setAppBadge() { [native code] }",
+    "geolocation−[object Geolocation]",
+    "userAgentData−[object NavigatorUAData]",
+    "mediaCapabilities−[object MediaCapabilities]",
+    "requestMIDIAccess−function requestMIDIAccess() { [native code] }",
+    "getUserMedia−function getUserMedia() { [native code] }",
+    "mediaDevices−[object MediaDevices]",
+    "webkitPersistentStorage−[object DeprecatedStorageQuota]",
+    "userAgent−Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "sendBeacon−function sendBeacon() { [native code] }",
+    "hardwareConcurrency−32",
+    "appVersion−5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "credentials−[object CredentialsContainer]",
+    "storage−[object StorageManager]",
+    "cookieEnabled−true",
+    "pdfViewerEnabled−true",
+    "windowControlsOverlay−[object WindowControlsOverlay]",
+    "scheduling−[object Scheduling]",
+    "pdfViewerEnabled−true",
+    "hardwareConcurrency−32",
+    "xr−[object XRSystem]",
+    "userAgent−Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36 Edg/125.0.0.0",
+    "webdriver−false",
+    "getInstalledRelatedApps−function getInstalledRelatedApps() { [native code] }",
+    "getInstalledRelatedApps−function getInstalledRelatedApps() { [native code] }",
+    "bluetooth−[object Bluetooth]"
+]
+document_key = ['_reactListeningo743lnnpvdg', 'location']
+window_key = [
+    "0",
+    "window",
+    "self",
+    "document",
+    "name",
+    "location",
+    "customElements",
+    "history",
+    "navigation",
+    "locationbar",
+    "menubar",
+    "personalbar",
+    "scrollbars",
+    "statusbar",
+    "toolbar",
+    "status",
+    "closed",
+    "frames",
+    "length",
+    "top",
+    "opener",
+    "parent",
+    "frameElement",
+    "navigator",
+    "origin",
+    "external",
+    "screen",
+    "innerWidth",
+    "innerHeight",
+    "scrollX",
+    "pageXOffset",
+    "scrollY",
+    "pageYOffset",
+    "visualViewport",
+    "screenX",
+    "screenY",
+    "outerWidth",
+    "outerHeight",
+    "devicePixelRatio",
+    "clientInformation",
+    "screenLeft",
+    "screenTop",
+    "styleMedia",
+    "onsearch",
+    "isSecureContext",
+    "trustedTypes",
+    "performance",
+    "onappinstalled",
+    "onbeforeinstallprompt",
+    "crypto",
+    "indexedDB",
+    "sessionStorage",
+    "localStorage",
+    "onbeforexrselect",
+    "onabort",
+    "onbeforeinput",
+    "onbeforematch",
+    "onbeforetoggle",
+    "onblur",
+    "oncancel",
+    "oncanplay",
+    "oncanplaythrough",
+    "onchange",
+    "onclick",
+    "onclose",
+    "oncontentvisibilityautostatechange",
+    "oncontextlost",
+    "oncontextmenu",
+    "oncontextrestored",
+    "oncuechange",
+    "ondblclick",
+    "ondrag",
+    "ondragend",
+    "ondragenter",
+    "ondragleave",
+    "ondragover",
+    "ondragstart",
+    "ondrop",
+    "ondurationchange",
+    "onemptied",
+    "onended",
+    "onerror",
+    "onfocus",
+    "onformdata",
+    "oninput",
+    "oninvalid",
+    "onkeydown",
+    "onkeypress",
+    "onkeyup",
+    "onload",
+    "onloadeddata",
+    "onloadedmetadata",
+    "onloadstart",
+    "onmousedown",
+    "onmouseenter",
+    "onmouseleave",
+    "onmousemove",
+    "onmouseout",
+    "onmouseover",
+    "onmouseup",
+    "onmousewheel",
+    "onpause",
+    "onplay",
+    "onplaying",
+    "onprogress",
+    "onratechange",
+    "onreset",
+    "onresize",
+    "onscroll",
+    "onsecuritypolicyviolation",
+    "onseeked",
+    "onseeking",
+    "onselect",
+    "onslotchange",
+    "onstalled",
+    "onsubmit",
+    "onsuspend",
+    "ontimeupdate",
+    "ontoggle",
+    "onvolumechange",
+    "onwaiting",
+    "onwebkitanimationend",
+    "onwebkitanimationiteration",
+    "onwebkitanimationstart",
+    "onwebkittransitionend",
+    "onwheel",
+    "onauxclick",
+    "ongotpointercapture",
+    "onlostpointercapture",
+    "onpointerdown",
+    "onpointermove",
+    "onpointerrawupdate",
+    "onpointerup",
+    "onpointercancel",
+    "onpointerover",
+    "onpointerout",
+    "onpointerenter",
+    "onpointerleave",
+    "onselectstart",
+    "onselectionchange",
+    "onanimationend",
+    "onanimationiteration",
+    "onanimationstart",
+    "ontransitionrun",
+    "ontransitionstart",
+    "ontransitionend",
+    "ontransitioncancel",
+    "onafterprint",
+    "onbeforeprint",
+    "onbeforeunload",
+    "onhashchange",
+    "onlanguagechange",
+    "onmessage",
+    "onmessageerror",
+    "onoffline",
+    "ononline",
+    "onpagehide",
+    "onpageshow",
+    "onpopstate",
+    "onrejectionhandled",
+    "onstorage",
+    "onunhandledrejection",
+    "onunload",
+    "crossOriginIsolated",
+    "scheduler",
+    "alert",
+    "atob",
+    "blur",
+    "btoa",
+    "cancelAnimationFrame",
+    "cancelIdleCallback",
+    "captureEvents",
+    "clearInterval",
+    "clearTimeout",
+    "close",
+    "confirm",
+    "createImageBitmap",
+    "fetch",
+    "find",
+    "focus",
+    "getComputedStyle",
+    "getSelection",
+    "matchMedia",
+    "moveBy",
+    "moveTo",
+    "open",
+    "postMessage",
+    "print",
+    "prompt",
+    "queueMicrotask",
+    "releaseEvents",
+    "reportError",
+    "requestAnimationFrame",
+    "requestIdleCallback",
+    "resizeBy",
+    "resizeTo",
+    "scroll",
+    "scrollBy",
+    "scrollTo",
+    "setInterval",
+    "setTimeout",
+    "stop",
+    "structuredClone",
+    "webkitCancelAnimationFrame",
+    "webkitRequestAnimationFrame",
+    "chrome",
+    "caches",
+    "cookieStore",
+    "ondevicemotion",
+    "ondeviceorientation",
+    "ondeviceorientationabsolute",
+    "launchQueue",
+    "documentPictureInPicture",
+    "getScreenDetails",
+    "queryLocalFonts",
+    "showDirectoryPicker",
+    "showOpenFilePicker",
+    "showSaveFilePicker",
+    "originAgentCluster",
+    "onpageswap",
+    "onpagereveal",
+    "credentialless",
+    "speechSynthesis",
+    "onscrollend",
+    "webkitRequestFileSystem",
+    "webkitResolveLocalFileSystemURL",
+    "sendMsgToSolverCS",
+    "webpackChunk_N_E",
+    "__next_set_public_path__",
+    "next",
+    "__NEXT_DATA__",
+    "__SSG_MANIFEST_CB",
+    "__NEXT_P",
+    "_N_E",
+    "regeneratorRuntime",
+    "__REACT_INTL_CONTEXT__",
+    "DD_RUM",
+    "_",
+    "filterCSS",
+    "filterXSS",
+    "__SEGMENT_INSPECTOR__",
+    "__NEXT_PRELOADREADY",
+    "Intercom",
+    "__MIDDLEWARE_MATCHERS",
+    "__STATSIG_SDK__",
+    "__STATSIG_JS_SDK__",
+    "__STATSIG_RERENDER_OVERRIDE__",
+    "_oaiHandleSessionExpired",
+    "__BUILD_MANIFEST",
+    "__SSG_MANIFEST",
+    "__intercomAssignLocation",
+    "__intercomReloadLocation"
+]
+
+
+class ScriptSrcParser(HTMLParser):
+    def handle_starttag(self, tag, attrs):
+        global cached_scripts, cached_dpl, cached_time
+        if tag == "script":
+            attrs_dict = dict(attrs)
+            if "src" in attrs_dict:
+                src = attrs_dict["src"]
+                cached_scripts.append(src)
+                match = re.search(r"c/[^/]*/_", src)
+                if match:
+                    cached_dpl = match.group(0)
+                    cached_time = int(time.time())
+
+
+def get_data_build_from_html(html_content):
+    global cached_scripts, cached_dpl, cached_time
+    parser = ScriptSrcParser()
+    parser.feed(html_content)
+    if not cached_scripts:
+        cached_scripts.append("https://chatgpt.com/backend-api/sentinel/sdk.js")
+    if not cached_dpl:
+        match = re.search(r'<html[^>]*data-build="([^"]*)"', html_content)
+        if match:
+            data_build = match.group(1)
+            cached_dpl = data_build
+            cached_time = int(time.time())
+            logger.info(f"Found dpl: {cached_dpl}")
+
+
+async def get_dpl(service):
+    global cached_scripts, cached_dpl, cached_time
+    if int(time.time()) - cached_time < 15 * 60:
+        return True
+    headers = service.base_headers.copy()
+    cached_scripts = []
+    cached_dpl = ""
+    try:
+        if conversation_only:
+            return True
+        r = await service.s.get(f"{service.host_url}/", headers=headers, timeout=5)
+        r.raise_for_status()
+        get_data_build_from_html(r.text)
+        if not cached_dpl:
+            raise Exception("No Cached DPL")
+        else:
+            return True
+    except Exception as e:
+        logger.info(f"Failed to get dpl: {e}")
+        cached_dpl = None
+        cached_time = int(time.time())
+        return False
+
+
+def get_parse_time():
+    now = datetime.now(timezone(timedelta(hours=-5)))
+    return now.strftime(timeLayout) + " GMT-0500 (Eastern Standard Time)"
+
+
+def get_config(user_agent):
+    core = random.choice(cores)
+    screen = random.choice(screens)
+    config = [
+        core + screen,
+        get_parse_time(),
+        4294705152,
+        0,
+        user_agent,
+        random.choice(cached_scripts) if cached_scripts else None,
+        cached_dpl,
+        "en-US",
+        "en-US,es-US,en,es",
+        0,
+        random.choice(navigator_key),
+        random.choice(document_key),
+        random.choice(window_key),
+        time.perf_counter(),
+        str(uuid.uuid4()),
+    ]
+    return config
+
+
+def get_answer_token(seed, diff, config):
+    start = time.time()
+    answer, solved = generate_answer(seed, diff, config)
+    end = time.time()
+    logger.info(f'diff: {diff}, time: {int((end - start) * 1e6) / 1e3}ms, solved: {solved}')
+    return "gAAAAAB" + answer, solved
+
+
+def generate_answer(seed, diff, config):
+    diff_len = len(diff)
+    seed_encoded = seed.encode()
+    static_config_part1 = (json.dumps(config[:3], separators=(',', ':'), ensure_ascii=False)[:-1] + ',').encode()
+    static_config_part2 = (',' + json.dumps(config[4:9], separators=(',', ':'), ensure_ascii=False)[1:-1] + ',').encode()
+    static_config_part3 = (',' + json.dumps(config[10:], separators=(',', ':'), ensure_ascii=False)[1:]).encode()
+
+    target_diff = bytes.fromhex(diff)
+
+    for i in range(500000):
+        dynamic_json_i = str(i).encode()
+        dynamic_json_j = str(i >> 1).encode()
+        final_json_bytes = static_config_part1 + dynamic_json_i + static_config_part2 + dynamic_json_j + static_config_part3
+        base_encode = pybase64.b64encode(final_json_bytes)
+        hash_value = hashlib.sha3_512(seed_encoded + base_encode).digest()
+        if hash_value[:diff_len] <= target_diff:
+            return base_encode.decode(), True
+
+    return "wQ8Lk5FbGpA2NcR9dShT6gYjU7VxZ4D" + pybase64.b64encode(f'"{seed}"'.encode()).decode(), False
+
+
+def get_requirements_token(config):
+    require, solved = generate_answer(format(random.random()), "0fffff", config)
+    return 'gAAAAAC' + require
+
+
+if __name__ == "__main__":
+    # cached_scripts.append(
+    #     "https://cdn.oaistatic.com/_next/static/cXh69klOLzS0Gy2joLDRS/_ssgManifest.js?dpl=453ebaec0d44c2decab71692e1bfe39be35a24b3")
+    # cached_dpl = "453ebaec0d44c2decab71692e1bfe39be35a24b3"
+    # cached_time = int(time.time())
+    # for i in range(10):
+    #     seed = format(random.random())
+    #     diff = "000032"
+    #     config = get_config("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome")
+    #     answer = get_answer_token(seed, diff, config)
+    cached_scripts.append(
+        "https://cdn.oaistatic.com/_next/static/cXh69klOLzS0Gy2joLDRS/_ssgManifest.js?dpl=453ebaec0d44c2decab71692e1bfe39be35a24b3")
+    cached_dpl = "dpl=453ebaec0d44c2decab71692e1bfe39be35a24b3"
+    config = get_config("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36")
+    get_requirements_token(config)

chatgpt/refreshToken.py

@@ -0,0 +1,58 @@
+import json
+import random
+import time
+
+from fastapi import HTTPException
+
+from utils.Client import Client
+from utils.Logger import logger
+from utils.config import proxy_url_list
+import chatgpt.globals as globals
+
+
+def save_refresh_map(refresh_map):
+    with open(globals.REFRESH_MAP_FILE, "w") as file:
+        json.dump(refresh_map, file)
+
+
+async def rt2ac(refresh_token, force_refresh=False):
+    if not force_refresh and (refresh_token in globals.refresh_map and int(time.time()) - globals.refresh_map.get(refresh_token, {}).get("timestamp", 0) < 5 * 24 * 60 * 60):
+        access_token = globals.refresh_map[refresh_token]["token"]
+        logger.info(f"refresh_token -> access_token from cache")
+        return access_token
+    else:
+        try:
+            access_token = await chat_refresh(refresh_token)
+            globals.refresh_map[refresh_token] = {"token": access_token, "timestamp": int(time.time())}
+            save_refresh_map(globals.refresh_map)
+            logger.info(f"refresh_token -> access_token with openai: {access_token}")
+            return access_token
+        except HTTPException as e:
+            raise HTTPException(status_code=e.status_code, detail=e.detail)
+
+
+async def chat_refresh(refresh_token):
+    data = {
+        "client_id": "pdlLIX2Y72MIl2rhLhTE9VV9bN905kBh",
+        "grant_type": "refresh_token",
+        "redirect_uri": "com.openai.chat://auth0.openai.com/ios/com.openai.chat/callback",
+        "refresh_token": refresh_token
+    }
+    client = Client(proxy=random.choice(proxy_url_list) if proxy_url_list else None)
+    try:
+        r = await client.post("https://auth0.openai.com/oauth/token", json=data, timeout=5)
+        if r.status_code == 200:
+            access_token = r.json()['access_token']
+            return access_token
+        else:
+            with open(globals.ERROR_TOKENS_FILE, "a", encoding="utf-8") as f:
+                f.write(refresh_token + "\n")
+            if refresh_token not in globals.error_token_list:
+                globals.error_token_list.append(refresh_token)
+            raise Exception(r.text[:100])
+    except Exception as e:
+        logger.error(f"Failed to refresh access_token `{refresh_token}`: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to refresh access_token.")
+    finally:
+        await client.close()
+        del client

chatgpt/reverseProxy.py

@@ -0,0 +1,167 @@
+import random
+
+from fastapi import Request, HTTPException
+from fastapi.responses import StreamingResponse, Response
+from starlette.background import BackgroundTask
+
+from utils.Client import Client
+from utils.config import chatgpt_base_url_list, proxy_url_list, enable_gateway
+
+headers_reject_list = [
+    "x-real-ip",
+    "x-forwarded-for",
+    "x-forwarded-proto",
+    "x-forwarded-port",
+    "x-forwarded-host",
+    "x-forwarded-server",
+    "cf-warp-tag-id",
+    "cf-visitor",
+    "cf-ray",
+    "cf-connecting-ip",
+    "cf-ipcountry",
+    "cdn-loop",
+    "remote-host",
+    "x-frame-options",
+    "x-xss-protection",
+    "x-content-type-options",
+    "content-security-policy",
+    "host",
+    "cookie",
+    "connection",
+    "content-length",
+    "content-encoding",
+    "x-middleware-prefetch",
+    "x-nextjs-data",
+    "purpose",
+    "x-forwarded-uri",
+    "x-forwarded-path",
+    "x-forwarded-method",
+    "x-forwarded-protocol",
+    "x-forwarded-scheme",
+    "cf-request-id",
+    "cf-worker",
+    "cf-access-client-id",
+    "cf-access-client-device-type",
+    "cf-access-client-device-model",
+    "cf-access-client-device-name",
+    "cf-access-client-device-brand",
+    "x-middleware-prefetch",
+    "x-forwarded-for",
+    "x-forwarded-host",
+    "x-forwarded-proto",
+    "x-forwarded-server",
+    "x-real-ip",
+    "x-forwarded-port",
+    "cf-connecting-ip",
+    "cf-ipcountry",
+    "cf-ray",
+    "cf-visitor",
+]
+
+
+async def chatgpt_reverse_proxy(request: Request, path: str):
+    if not enable_gateway:
+        raise HTTPException(status_code=404, detail="Gateway is disabled")
+    try:
+        origin_host = request.url.netloc
+        if ":" in origin_host:
+            petrol = "http"
+        else:
+            petrol = "https"
+        if path.startswith("v1/"):
+            base_url = "https://ab.chatgpt.com"
+        else:
+            base_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        if "/assets" in path:
+            base_url = "https://cdn.oaistatic.com"
+
+        params = dict(request.query_params)
+        headers = {
+            key: value for key, value in request.headers.items()
+            if (key.lower() not in ["host", "origin", "referer", "user-agent",
+                                    "authorization"] and key.lower() not in headers_reject_list)
+        }
+        request_cookies = dict(request.cookies)
+
+        headers.update({
+            "accept-Language": "en-US,en;q=0.9",
+            "host": base_url.replace("https://", "").replace("http://", ""),
+            "origin": base_url,
+            "referer": f"{base_url}/",
+            "sec-ch-ua": '"Chromium";v="128", "Not;A=Brand";v="24", "Microsoft Edge";v="128"',
+            "sec-ch-ua-mobile": "?0",
+            "sec-ch-ua-platform": "\"Windows\"",
+            "sec-fetch-dest": "empty",
+            "sec-fetch-mode": "cors",
+            "sec-fetch-site": "same-origin",
+            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 Edg/128.0.0.0"
+        })
+
+        if request.headers.get('Authorization'):
+            headers['Authorization'] = request.headers['Authorization']
+
+        if headers.get("Content-Type") == "application/json":
+            data = await request.json()
+        else:
+            data = await request.body()
+
+        client = Client(proxy=random.choice(proxy_url_list) if proxy_url_list else None)
+        try:
+            background = BackgroundTask(client.close)
+            r = await client.request(request.method, f"{base_url}/{path}", params=params, headers=headers,
+                                     cookies=request_cookies, data=data, stream=True, allow_redirects=False)
+            if r.status_code == 304:
+                return Response(status_code=304, background=background)
+            elif r.status_code == 307:
+                if "oai-dm=1" not in r.headers.get("Location"):
+                    return Response(status_code=307, headers={
+                        "Location": r.headers.get("Location").replace("chat.openai.com", origin_host)
+                                    .replace("chatgpt.com", origin_host)
+                                    .replace("https", petrol)}, background=background)
+                else:
+                    return Response(status_code=307, headers={"Location": r.headers.get("Location")},
+                                    background=background)
+            elif r.status_code == 302:
+                return Response(status_code=302,
+                                headers={"Location": r.headers.get("Location").replace("chatgpt.com", origin_host)
+                                .replace("chat.openai.com", origin_host)
+                                .replace("ab.chatgpt.com", origin_host)
+                                .replace("cdn.oaistatic.com", origin_host)
+                                .replace("https", petrol)}, background=background)
+            elif 'stream' in r.headers.get("content-type", ""):
+                return StreamingResponse(r.aiter_content(), media_type=r.headers.get("content-type", ""),
+                                         background=background)
+            else:
+                if "/conversation" in path or "/register-websocket" in path:
+                    response = Response(content=(await r.atext()), media_type=r.headers.get("content-type"),
+                                        status_code=r.status_code, background=background)
+                else:
+                    content = ((await r.atext()).replace("chatgpt.com", origin_host)
+                               .replace("chat.openai.com", origin_host)
+                               .replace("ab.chatgpt.com", origin_host)
+                               .replace("cdn.oaistatic.com", origin_host)
+                               .replace("https", petrol))
+                    rheaders = dict(r.headers)
+                    cache_control = rheaders.get("cache-control", "")
+                    content_type = rheaders.get("content-type", "")
+                    rheaders = {
+                        "cache-control": cache_control,
+                        "content-type": content_type
+                    }
+                    response = Response(content=content, headers=rheaders,
+                                        status_code=r.status_code, background=background)
+                for cookie_name in r.cookies:
+                    if cookie_name in request_cookies:
+                        continue
+                    for cookie_domain in [".chatgpt.com"]:
+                        cookie_value = r.cookies.get(name=cookie_name, domain=cookie_domain)
+                        if cookie_name.startswith("__"):
+                            response.set_cookie(key=cookie_name, value=cookie_value, secure=True, httponly=True)
+                        else:
+                            response.set_cookie(key=cookie_name, value=cookie_value)
+                return response
+        except Exception:
+            await client.close()
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

chatgpt/turnstile.py

@@ -0,0 +1,268 @@
+import pybase64
+import json
+import random
+import time
+from typing import Any, Callable, Dict, List, Union
+
+
+class OrderedMap:
+    def __init__(self):
+        self.keys = []
+        self.values = {}
+
+    def add(self, key: str, value: Any):
+        if key not in self.values:
+            self.keys.append(key)
+        self.values[key] = value
+
+    def to_json(self):
+        return json.dumps({k: self.values[k] for k in self.keys})
+
+
+TurnTokenList = List[List[Any]]
+FloatMap = Dict[float, Any]
+StringMap = Dict[str, Any]
+FuncType = Callable[..., Any]
+
+
+def get_turnstile_token(dx: str, p: str) -> Union[str, None]:
+    try:
+        decoded_bytes = pybase64.b64decode(dx)
+        return process_turnstile_token(decoded_bytes.decode(), p)
+    except Exception as e:
+        print(f"Error in get_turnstile_token: {e}")
+        return None
+
+
+def process_turnstile_token(dx: str, p: str) -> str:
+    result = []
+    p_length = len(p)
+    if p_length != 0:
+        for i, r in enumerate(dx):
+            result.append(chr(ord(r) ^ ord(p[i % p_length])))
+    else:
+        result = list(dx)
+    return ''.join(result)
+
+
+def is_slice(input_val: Any) -> bool:
+    return isinstance(input_val, (list, tuple))
+
+
+def is_float(input_val: Any) -> bool:
+    return isinstance(input_val, float)
+
+
+def is_string(input_val: Any) -> bool:
+    return isinstance(input_val, str)
+
+
+def to_str(input_val: Any) -> str:
+    if input_val is None:
+        return "undefined"
+    elif is_float(input_val):
+        return str(input_val)
+    elif is_string(input_val):
+        special_cases = {
+            "window.Math": "[object Math]",
+            "window.Reflect": "[object Reflect]",
+            "window.performance": "[object Performance]",
+            "window.localStorage": "[object Storage]",
+            "window.Object": "function Object() { [native code] }",
+            "window.Reflect.set": "function set() { [native code] }",
+            "window.performance.now": "function () { [native code] }",
+            "window.Object.create": "function create() { [native code] }",
+            "window.Object.keys": "function keys() { [native code] }",
+            "window.Math.random": "function random() { [native code] }"
+        }
+        return special_cases.get(input_val, input_val)
+    elif isinstance(input_val, list) and all(isinstance(item, str) for item in input_val):
+        return ','.join(input_val)
+    else:
+        return str(input_val)
+
+
+def get_func_map() -> FloatMap:
+    process_map: FloatMap = {}
+
+    def func_1(e: float, t: float):
+        e_str = to_str(process_map[e])
+        t_str = to_str(process_map[t])
+        res = process_turnstile_token(e_str, t_str)
+        process_map[e] = res
+
+    def func_2(e: float, t: Any):
+        process_map[e] = t
+
+    def func_5(e: float, t: float):
+        n = process_map[e]
+        tres = process_map[t]
+        if is_slice(n):
+            nt = n + [tres]
+            process_map[e] = nt
+        else:
+            if is_string(n) or is_string(tres):
+                res = to_str(n) + to_str(tres)
+            elif is_float(n) and is_float(tres):
+                res = n + tres
+            else:
+                res = "NaN"
+            process_map[e] = res
+
+    def func_6(e: float, t: float, n: float):
+        tv = process_map[t]
+        nv = process_map[n]
+        if is_string(tv) and is_string(nv):
+            res = f"{tv}.{nv}"
+            if res == "window.document.location":
+                process_map[e] = "https://chatgpt.com/"
+            else:
+                process_map[e] = res
+        else:
+            print("func type 6 error")
+
+    def func_24(e: float, t: float, n: float):
+        tv = process_map[t]
+        nv = process_map[n]
+        if is_string(tv) and is_string(nv):
+            process_map[e] = f"{tv}.{nv}"
+        else:
+            print("func type 24 error")
+
+    def func_7(e: float, *args):
+        n = [process_map[arg] for arg in args]
+        ev = process_map[e]
+        if isinstance(ev, str):
+            if ev == "window.Reflect.set":
+                obj = n[0]
+                key_str = str(n[1])
+                val = n[2]
+                obj.add(key_str, val)
+        elif callable(ev):
+            ev(*n)
+
+    def func_17(e: float, t: float, *args):
+        i = [process_map[arg] for arg in args]
+        tv = process_map[t]
+        res = None
+        if isinstance(tv, str):
+            if tv == "window.performance.now":
+                current_time = time.time_ns()
+                elapsed_ns = current_time - int(start_time * 1e9)
+                res = (elapsed_ns + random.random()) / 1e6
+            elif tv == "window.Object.create":
+                res = OrderedMap()
+            elif tv == "window.Object.keys":
+                if isinstance(i[0], str) and i[0] == "window.localStorage":
+                    res = ["STATSIG_LOCAL_STORAGE_INTERNAL_STORE_V4", "STATSIG_LOCAL_STORAGE_STABLE_ID",
+                           "client-correlated-secret", "oai/apps/capExpiresAt", "oai-did",
+                           "STATSIG_LOCAL_STORAGE_LOGGING_REQUEST", "UiState.isNavigationCollapsed.1"]
+            elif tv == "window.Math.random":
+                res = random.random()
+        elif callable(tv):
+            res = tv(*i)
+        process_map[e] = res
+
+    def func_8(e: float, t: float):
+        process_map[e] = process_map[t]
+
+    def func_14(e: float, t: float):
+        tv = process_map[t]
+        if is_string(tv):
+            token_list = json.loads(tv)
+            process_map[e] = token_list
+        else:
+            print("func type 14 error")
+
+    def func_15(e: float, t: float):
+        tv = process_map[t]
+        process_map[e] = json.dumps(tv)
+
+    def func_18(e: float):
+        ev = process_map[e]
+        e_str = to_str(ev)
+        decoded = pybase64.b64decode(e_str).decode()
+        process_map[e] = decoded
+
+    def func_19(e: float):
+        ev = process_map[e]
+        e_str = to_str(ev)
+        encoded = pybase64.b64encode(e_str.encode()).decode()
+        process_map[e] = encoded
+
+    def func_20(e: float, t: float, n: float, *args):
+        o = [process_map[arg] for arg in args]
+        ev = process_map[e]
+        tv = process_map[t]
+        if ev == tv:
+            nv = process_map[n]
+            if callable(nv):
+                nv(*o)
+            else:
+                print("func type 20 error")
+
+    def func_21(*args):
+        pass
+
+    def func_23(e: float, t: float, *args):
+        i = list(args)
+        ev = process_map[e]
+        tv = process_map[t]
+        if ev is not None:
+            if callable(tv):
+                tv(*i)
+
+    process_map.update({
+        1: func_1, 2: func_2, 5: func_5, 6: func_6, 24: func_24, 7: func_7,
+        17: func_17, 8: func_8, 10: "window", 14: func_14, 15: func_15,
+        18: func_18, 19: func_19, 20: func_20, 21: func_21, 23: func_23
+    })
+
+    return process_map
+
+start_time = 0
+
+
+def process_turnstile(dx: str, p: str) -> str:
+    global start_time
+    start_time = time.time()
+    tokens = get_turnstile_token(dx, p)
+    if tokens is None:
+        return ""
+
+    token_list = json.loads(tokens)
+    # print(token_list)
+    res = ""
+    process_map = get_func_map()
+
+    def func_3(e: str):
+        nonlocal res
+        res = pybase64.b64encode(e.encode()).decode()
+
+    process_map[3] = func_3
+    process_map[9] = token_list
+    process_map[16] = p
+
+    for token in token_list:
+        try:
+            e = token[0]
+            t = token[1:]
+            f = process_map.get(e)
+            if callable(f):
+                f(*t)
+            else:
+                pass
+                # print(f"Warning: No function found for key {e}")
+        except Exception as exc:
+            pass
+            # print(f"Error processing token {token}: {exc}")
+
+    return res
+
+
+if __name__ == "__main__":
+    result = process_turnstile(
+        "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",
+        "gAAAAACWzMwMzIsIlRodSBKdWwgMTEgMjAyNCAwMzoxMDo0NiBHTVQrMDgwMCAo5Lit5Zu95qCH5YeG5pe26Ze0KSIsNDI5NDcwNTE1MiwxLCJNb3ppbGxhLzUuMCAoV2luZG93cyBOVCAxMC4wOyBXaW42NDsgeDY0KSBBcHBsZVdlYktpdC81MzcuMzYgKEtIVE1MLCBsaWtlIEdlY2tvKSBDaHJvbWUvMTI2LjAuMC4wIFNhZmFyaS81MzcuMzYgRWRnLzEyNi4wLjAuMCIsImh0dHBzOi8vY2RuLm9haXN0YXRpYy5jb20vX25leHQvc3RhdGljL2NodW5rcy9wYWdlcy9fYXBwLWMwOWZmNWY0MjQwMjcwZjguanMiLCJjL1pGWGkxeTNpMnpaS0EzSVQwNzRzMy9fIiwiemgtQ04iLCJ6aC1DTixlbixlbi1HQixlbi1VUyIsMTM1LCJ3ZWJraXRUZW1wb3JhcnlTdG9yYWdl4oiSW29iamVjdCBEZXByZWNhdGVkU3RvcmFnZVF1b3RhXSIsIl9yZWFjdExpc3RlbmluZ3NxZjF0ejFzNmsiLCJmZXRjaCIsMzY1NCwiNWU1NDUzNzItMzcyNy00ZDAyLTkwMDYtMzMwMDRjMWJmYTQ2Il0="
+    )
+    print(result)

chatgpt/wssClient.py

@@ -0,0 +1,36 @@
+import json
+import time
+
+from utils.Logger import logger
+import chatgpt.globals as globals
+
+
+def save_wss_map(wss_map):
+    with open(globals.WSS_MAP_FILE, "w") as file:
+        json.dump(wss_map, file)
+
+
+async def token2wss(token):
+    if not token:
+        return False, None
+    if token in globals.wss_map:
+        wss_mode = globals.wss_map[token]["wss_mode"]
+        if wss_mode:
+            if int(time.time()) - globals.wss_map.get(token, {}).get("timestamp", 0) < 60 * 60:
+                wss_url = globals.wss_map[token]["wss_url"]
+                logger.info(f"token -> wss_url from cache")
+                return wss_mode, wss_url
+            else:
+                logger.info(f"token -> wss_url expired")
+                return wss_mode, None
+        else:
+            return False, None
+    return False, None
+
+
+async def set_wss(token, wss_mode, wss_url=None):
+    if not token:
+        return True
+    globals.wss_map[token] = {"timestamp": int(time.time()), "wss_url": wss_url, "wss_mode": wss_mode}
+    save_wss_map(globals.wss_map)
+    return True

requirements.txt

@@ -0,0 +1,11 @@
+fastapi
+python-multipart
+curl_cffi==0.7.3
+uvicorn
+tiktoken
+python-dotenv
+websockets
+pillow
+pybase64
+jinja2
+APScheduler

templates/tokens.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta content="width=device-width, initial-scale=1.0" name="viewport">
+    <title>Tokens 管理</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <script>
+        document.addEventListener('DOMContentLoaded', () => {
+            const apiPrefix = "{{ api_prefix }}";
+            const uploadForm = document.getElementById('uploadForm');
+            const clearForm = document.getElementById('clearForm');
+            const errorButton = document.getElementById('errorButton');
+
+            if (apiPrefix === "None") {
+                uploadForm.action = "/tokens/upload";
+                clearForm.action = "/tokens/clear";
+                errorButton.dataset.api = "/tokens/error";
+            } else {
+                uploadForm.action = `/${apiPrefix}/tokens/upload`;
+                clearForm.action = `/${apiPrefix}/tokens/clear`;
+                errorButton.dataset.api = `/${apiPrefix}/tokens/error`;
+            }
+
+            errorButton.addEventListener('click', async () => {
+                const response = await fetch(errorButton.dataset.api, {
+                    method: 'POST',
+                });
+                const result = await response.json();
+                const errorTokens = result.error_tokens;
+
+                const errorModal = document.getElementById('errorModal');
+                const errorModalContent = document.getElementById('errorModalContent');
+
+                errorModalContent.innerHTML = errorTokens.map(token => `<p>${token}</p>`).join('');
+                errorModal.classList.remove('hidden');
+            });
+
+            document.getElementById('errorModalClose').addEventListener('click', () => {
+                document.getElementById('errorModal').classList.add('hidden');
+            });
+
+            document.getElementById('errorModalCopy').addEventListener('click', () => {
+                const errorModalContent = document.getElementById('errorModalContent');
+                const textToCopy = errorModalContent.innerText.replace(/\n\n/g, '\n');
+                navigator.clipboard.writeText(textToCopy).then(() => {
+                    alert('错误 Tokens 已复制到剪贴板');
+                }).catch(err => {
+                    alert('复制失败，请手动复制');
+                });
+            });
+        });
+    </script>
+</head>
+<body class="bg-gradient-to-r from-blue-200 via-purple-200 to-pink-200 flex justify-center items-center min-h-screen">
+    <div class="bg-white p-10 rounded-lg shadow-2xl w-128 text-center">
+        <h1 class="text-4xl font-extrabold text-gray-900 mb-6">Tokens 管理</h1>
+        <p class="text-gray-600 mb-4">当前可用 Tokens 数量：<span class="text-blue-600">{{ tokens_count }}</span></p>
+        <form class="mb-2" id="uploadForm" method="post">
+            <textarea class="w-full p-4 mb-4 border border-gray-300 rounded-md focus:outline-none focus:ring-2 focus:ring-blue-400 resize-none" name="text" placeholder="一行一个Token，可以是 AccessToken 或 RefreshToken" rows="10"></textarea>
+            <p class="text-gray-600 mb-2">注：使用docker时如果挂载了data文件夹则重启后不需要再次上传</p>
+            <button class="w-full bg-blue-600 text-white py-3 rounded-md hover:bg-blue-700 transition duration-300 mb-2" type="submit">上传</button>
+        </form>
+        <button id="errorButton" class="w-full bg-yellow-600 text-white py-3 rounded-md hover:bg-yellow-700 transition duration-200 mt-2">查看错误Tokens</button>
+        <p class="text-gray-600 mt-2">点击清空，将会清空上传和错误的 Tokens</p>
+        <form id="clearForm" method="post">
+            <button class="w-full bg-red-600 text-white py-3 rounded-md hover:bg-red-700 transition duration-300" type="submit">清空Tokens</button>
+        </form>
+    </div>
+    
+    <div id="errorModal" class="fixed inset-0 bg-gray-800 bg-opacity-75 flex justify-center items-center hidden">
+        <div class="bg-white p-6 rounded-lg shadow-lg w-150">
+            <h2 class="text-2xl font-bold mb-4">错误 Tokens</h2>
+            <div id="errorModalContent" class="list-disc list-inside text-left mb-4"></div>
+            <div class="flex justify-end space-x-4">
+                <button id="errorModalCopy" class="bg-green-600 text-white py-2 px-4 rounded-md hover:bg-green-700 transition duration-300">复制</button>
+                <button id="errorModalClose" class="bg-red-600 text-white py-2 px-4 rounded-md hover:bg-red-700 transition duration-300">关闭</button>
+            </div>
+        </div>
+    </div>
+</body>
+</html>

utils/Client.py

@@ -0,0 +1,59 @@
+import random
+
+from curl_cffi.requests import AsyncSession
+
+
+class Client:
+    def __init__(self, proxy=None, timeout=15, verify=True):
+        self.proxies = {
+            "http": proxy,
+            "https": proxy,
+        }
+        self.timeout = timeout
+        self.verify = verify
+
+        self.impersonate = random.choice(['safari15_3'])
+        # impersonate=self.impersonate
+
+        # self.ja3 = ""
+        # self.akamai = ""
+        # ja3=self.ja3, akamai=self.akamai
+        self.session = AsyncSession(proxies=self.proxies, timeout=self.timeout, verify=self.verify)
+        self.session2 = AsyncSession(proxies=self.proxies, timeout=self.timeout, verify=self.verify)
+
+    async def post(self, *args, **kwargs):
+        r = await self.session.post(*args, impersonate=self.impersonate, **kwargs)
+        return r
+
+    async def post_stream(self, *args, headers=None, cookies=None, **kwargs):
+        if self.session:
+            headers = headers or self.session.headers
+            cookies = cookies or self.session.cookies
+        r = await self.session2.post(*args, headers=headers, cookies=cookies, impersonate=self.impersonate, **kwargs)
+        return r
+
+    async def get(self, *args, **kwargs):
+        r = await self.session.get(*args, impersonate=self.impersonate, **kwargs)
+        return r
+
+    async def request(self, *args, **kwargs):
+        r = await self.session.request(*args, impersonate=self.impersonate, **kwargs)
+        return r
+
+    async def put(self, *args, **kwargs):
+        r = await self.session.put(*args, impersonate=self.impersonate, **kwargs)
+        return r
+
+    async def close(self):
+        if self.session:
+            try:
+                await self.session.close()
+                del self.session
+            except Exception:
+                pass
+        if self.session2:
+            try:
+                await self.session2.close()
+                del self.session2
+            except Exception:
+                pass

utils/Logger.py

@@ -0,0 +1,24 @@
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(asctime)s | %(levelname)s | %(message)s')
+
+
+class Logger:
+    @staticmethod
+    def info(message):
+        logging.info(str(message))
+
+    @staticmethod
+    def warning(message):
+        logging.warning("\033[0;33m" + str(message) + "\033[0m")
+
+    @staticmethod
+    def error(message):
+        logging.error("\033[0;31m" + "-" * 50 + '\n| ' + str(message) + "\033[0m" + "\n" + "└" + "-" * 80)
+
+    @staticmethod
+    def debug(message):
+        logging.debug("\033[0;37m" + str(message) + "\033[0m")
+
+
+logger = Logger()

utils/config.py

@@ -0,0 +1,74 @@
+import ast
+import os
+
+from dotenv import load_dotenv
+
+from utils.Logger import logger
+
+load_dotenv(encoding="ascii")
+
+
+def is_true(x):
+    if isinstance(x, bool):
+        return x
+    if isinstance(x, str):
+        return x.lower() in ['true', '1', 't', 'y', 'yes']
+    elif isinstance(x, int):
+        return x == 1
+    else:
+        return False
+
+
+api_prefix = os.getenv('API_PREFIX', None)
+authorization = os.getenv('AUTHORIZATION', '').replace(' ', '')
+chatgpt_base_url = os.getenv('CHATGPT_BASE_URL', 'https://chatgpt.com').replace(' ', '')
+auth_key = os.getenv('AUTH_KEY', None)
+user_agents = os.getenv('USER_AGENTS', '[]')
+
+ark0se_token_url = os.getenv('ARK' + 'OSE_TOKEN_URL', '').replace(' ', '')
+if not ark0se_token_url:
+    ark0se_token_url = os.getenv('ARK0SE_TOKEN_URL', None)
+proxy_url = os.getenv('PROXY_URL', '').replace(' ', '')
+export_proxy_url = os.getenv('EXPORT_PROXY_URL', None)
+
+cf_file_url = os.getenv('CF_FILE_URL', None)
+turnstile_solver_url = os.getenv('TURNSTILE_SOLVER_URL', None)
+
+history_disabled = is_true(os.getenv('HISTORY_DISABLED', True))
+pow_difficulty = os.getenv('POW_DIFFICULTY', '000032')
+retry_times = int(os.getenv('RETRY_TIMES', 3))
+enable_gateway = is_true(os.getenv('ENABLE_GATEWAY', True))
+conversation_only = is_true(os.getenv('CONVERSATION_ONLY', False))
+enable_limit = is_true(os.getenv('ENABLE_LIMIT', True))
+upload_by_url = is_true(os.getenv('UPLOAD_BY_URL', False))
+check_model = is_true(os.getenv('CHECK_MODEL', False))
+scheduled_refresh = is_true(os.getenv('SCHEDULED_REFRESH', False))
+
+authorization_list = authorization.split(',') if authorization else []
+chatgpt_base_url_list = chatgpt_base_url.split(',') if chatgpt_base_url else []
+ark0se_token_url_list = ark0se_token_url.split(',') if ark0se_token_url else []
+proxy_url_list = proxy_url.split(',') if proxy_url else []
+user_agents_list = ast.literal_eval(user_agents)
+
+logger.info("-" * 60)
+logger.info("Chat2Api 1.4.16 | https://github.com/lanqian528/chat2api")
+logger.info("-" * 60)
+logger.info("Environment variables:")
+logger.info("API_PREFIX:        " + str(api_prefix))
+logger.info("AUTHORIZATION:     " + str(authorization_list))
+logger.info("CHATGPT_BASE_URL:  " + str(chatgpt_base_url_list))
+logger.info("AUTH_KEY:          " + str(auth_key))
+logger.info("ARK0SE_TOKEN_URL:  " + str(ark0se_token_url_list))
+logger.info("PROXY_URL:         " + str(proxy_url_list))
+logger.info("EXPORT_PROXY_URL:  " + str(export_proxy_url))
+logger.info("HISTORY_DISABLED:  " + str(history_disabled))
+logger.info("POW_DIFFICULTY:    " + str(pow_difficulty))
+logger.info("RETRY_TIMES:       " + str(retry_times))
+logger.info("ENABLE_GATEWAY:    " + str(enable_gateway))
+logger.info("CONVERSATION_ONLY: " + str(conversation_only))
+logger.info("ENABLE_LIMIT:      " + str(enable_limit))
+logger.info("UPLOAD_BY_URL:     " + str(upload_by_url))
+logger.info("CHECK_MODEL:       " + str(check_model))
+logger.info("SCHEDULED_REFRESH: " + str(scheduled_refresh))
+logger.info("USER_AGENTS:       " + str(user_agents_list))
+logger.info("-" * 60)

utils/retry.py

@@ -0,0 +1,32 @@
+from fastapi import HTTPException
+
+from utils.Logger import logger
+from utils.config import retry_times
+
+
+async def async_retry(func, *args, max_retries=retry_times, **kwargs):
+    for attempt in range(max_retries + 1):
+        try:
+            result = await func(*args, **kwargs)
+            return result
+        except HTTPException as e:
+            if attempt == max_retries:
+                logger.error(f"Throw an exception {e.status_code}, {e.detail}")
+                if e.status_code == 500:
+                    raise HTTPException(status_code=500, detail="Server error")
+                raise HTTPException(status_code=e.status_code, detail=e.detail)
+            logger.info(f"Retry {attempt + 1} status code {e.status_code}, {e.detail}. Retrying...")
+
+
+def retry(func, *args, max_retries=retry_times, **kwargs):
+    for attempt in range(max_retries + 1):
+        try:
+            result = func(*args, **kwargs)
+            return result
+        except HTTPException as e:
+            if attempt == max_retries:
+                logger.error(f"Throw an exception {e.status_code}, {e.detail}")
+                if e.status_code == 500:
+                    raise HTTPException(status_code=500, detail="Server error")
+                raise HTTPException(status_code=e.status_code, detail=e.detail)
+            logger.error(f"Retry {attempt + 1} status code {e.status_code}, {e.detail}. Retrying...")