Upload 39 files

.env

@@ -0,0 +1,4 @@
+UPLOAD_BY_URL=true
+TZ=Asia/Shanghai
+ENABLE_GATEWAY=true
+AUTO_SEED=false

Dockerfile

@@ -1,8 +1,11 @@
-FROM lanqian528/chat2api:latest
+FROM python:3.11-slim
 
-# 创建应用程序所需的目录，并赋予必要权限
-RUN mkdir -p /app/data && chmod -R 777 /app/data
+WORKDIR /app
+COPY . /app
+RUN pip install --no-cache-dir -r requirements.txt
+EXPOSE 5005
 
-ENV TZ=Asia/Shanghai
-ENV UPLOAD_BY_URL=true
-ENV ENABLE_GATEWAY=false
+RUN mkdir /app/data
+RUN chmod -R 777 /app/data
+
+CMD ["python", "app.py"]

api/chat2api.py

@@ -0,0 +1,136 @@
+import asyncio
+import types
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from fastapi import Request, HTTPException, Form, Security
+from fastapi.responses import HTMLResponse, StreamingResponse, JSONResponse
+from fastapi.security import HTTPAuthorizationCredentials
+from starlette.background import BackgroundTask
+
+import utils.globals as globals
+from app import app, templates, security_scheme
+from chatgpt.ChatService import ChatService
+from chatgpt.authorization import refresh_all_tokens
+from utils.Logger import logger
+from utils.configs import api_prefix, scheduled_refresh
+from utils.retry import async_retry
+
+scheduler = AsyncIOScheduler()
+
+
+@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='*/2',
+                          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, credentials: HTTPAuthorizationCredentials = Security(security_scheme)):
+    req_token = credentials.credentials
+    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(globals.TOKENS_FILE, "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 clear_tokens():
+    globals.token_list.clear()
+    globals.error_token_list.clear()
+    with open(globals.TOKENS_FILE, "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.get(f"/{api_prefix}/tokens/add/{{token}}" if api_prefix else "/tokens/add/{token}")
+async def add_token(token: str):
+    if token.strip() and not token.startswith("#"):
+        globals.token_list.append(token.strip())
+        with open(globals.TOKENS_FILE, "a", encoding="utf-8") as f:
+            f.write(token.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}/seed_tokens/clear" if api_prefix else "/seed_tokens/clear")
+async def clear_seed_tokens():
+    globals.seed_map.clear()
+    globals.conversation_map.clear()
+    with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+        f.write("{}")
+    with open(globals.CONVERSATION_MAP_FILE, "w", encoding="utf-8") as f:
+        f.write("{}")
+    logger.info(f"Seed token count: {len(globals.seed_map)}")
+    return {"status": "success", "seed_tokens_count": len(globals.seed_map)}

api/files.py

@@ -0,0 +1,144 @@
+import io
+
+import pybase64
+from PIL import Image
+
+from utils.Client import Client
+from utils.configs 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,31 @@
+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-08-06",
+    "gpt-4o-mini": "gpt-4o-mini-2024-07-18",
+    "o1-preview": "o1-preview-2024-09-12",
+    "o1-mini": "o1-mini-2024-09-12",
+    "o1": "o1-2024-12-18",
+    "o3-mini": "o3-mini-2025-01-31",
+    "o3-mini-high": "o3-mini-high-2025-01-31",
+    "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,57 @@
+import warnings
+
+import uvicorn
+from fastapi import FastAPI, HTTPException
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.templating import Jinja2Templates
+
+from utils.configs import enable_gateway, api_prefix
+
+warnings.filterwarnings("ignore")
+
+
+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
+
+app = FastAPI(
+    docs_url=f"/{api_prefix}/docs",    # 设置 Swagger UI 文档路径
+    redoc_url=f"/{api_prefix}/redoc",  # 设置 Redoc 文档路径
+    openapi_url=f"/{api_prefix}/openapi.json"  # 设置 OpenAPI JSON 路径
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+templates = Jinja2Templates(directory="templates")
+security_scheme = HTTPBearer()
+
+from app import app
+
+import api.chat2api
+
+if enable_gateway:
+    import gateway.share
+    import gateway.login
+    import gateway.chatgpt
+    import gateway.gpts
+    import gateway.admin
+    import gateway.v1
+    import gateway.backend
+else:
+    @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+    async def reverse_proxy():
+        raise HTTPException(status_code=404, detail="Gateway is disabled")
+
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", host="0.0.0.0", port=5005)
+    # uvicorn.run("app:app", host="0.0.0.0", port=5005, ssl_keyfile="key.pem", ssl_certfile="cert.pem")

chatgpt/ChatService.py

@@ -0,0 +1,540 @@
+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.fp import get_fp
+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.configs import (
+    chatgpt_base_url_list,
+    ark0se_token_url_list,
+    sentinel_proxy_url_list,
+    history_disabled,
+    pow_difficulty,
+    conversation_only,
+    enable_limit,
+    upload_by_url,
+    auth_key,
+    turnstile_solver_url,
+    oai_language,
+)
+
+
+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.ss = None
+        self.ws = None
+
+    async def set_dynamic_data(self, data):
+        if 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.fp = get_fp(self.req_token).copy()
+        self.proxy_url = self.fp.pop("proxy_url", None)
+        self.impersonate = self.fp.pop("impersonate", "safari15_3")
+        self.user_agent = self.fp.get("user-agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0")
+        logger.info(f"Request token: {self.req_token}")
+        logger.info(f"Request proxy: {self.proxy_url}")
+        logger.info(f"Request UA: {self.user_agent}")
+        logger.info(f"Request impersonate: {self.impersonate}")
+
+        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, impersonate=self.impersonate)
+        if sentinel_proxy_url_list:
+            self.ss = Client(proxy=random.choice(sentinel_proxy_url_list), impersonate=self.impersonate)
+        else:
+            self.ss = self.s
+
+        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-language': oai_language,
+            'origin': self.host_url,
+            'priority': 'u=1, i',
+            'referer': f'{self.host_url}/',
+            'sec-fetch-dest': 'empty',
+            'sec-fetch-mode': 'cors',
+            'sec-fetch-site': 'same-origin'
+        }
+        self.base_headers.update(self.fp)
+
+        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 "gizmo" in self.origin_model or "g-" in self.origin_model:
+            self.gizmo_id = "g-" + self.origin_model.split("g-")[-1]
+        else:
+            self.gizmo_id = None
+
+        if "o3-mini-high" in self.origin_model:
+            self.req_model = "o3-mini-high"
+        elif "o3-mini-medium" in self.origin_model:
+            self.req_model = "o3-mini-medium"
+        elif "o3-mini-low" in self.origin_model:
+            self.req_model = "o3-mini-low"
+        elif "o3-mini" in self.origin_model:
+            self.req_model = "o3-mini"
+        elif "o3" in self.origin_model:
+            self.req_model = "o3"
+        elif "o1-preview" in self.origin_model:
+            self.req_model = "o1-preview"
+        elif "o1-pro" in self.origin_model:
+            self.req_model = "o1-pro"
+        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" 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 = "gpt-4o"
+
+    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.ss.post(url, headers=headers, json=data, timeout=5)
+            if r.status_code == 200:
+                resp = r.json()
+
+                self.persona = resp.get("persona")
+                if self.persona != "chatgpt-paid":
+                    if self.req_model == "gpt-4" or self.req_model == "o1-preview":
+                        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(impersonate=self.impersonate)
+                    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_chl_opt" in detail:
+                    raise HTTPException(status_code=r.status_code, detail="cf_chl_opt")
+                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 self.gizmo_id:
+            conversation_mode = {"kind": "gizmo_interaction", "gizmo_id": self.gizmo_id}
+            logger.info(f"Gizmo id: {self.gizmo_id}")
+        else:
+            conversation_mode = {"kind": "primary_assistant"}
+
+        logger.info(f"Model mapping: {self.origin_model} -> {self.req_model}")
+        self.chat_request = {
+            "action": "next",
+            "client_contextual_info": {
+                "is_dark_mode": False,
+                "time_since_loaded": random.randint(50, 500),
+                "page_height": random.randint(500, 1000),
+                "page_width": random.randint(1000, 2000),
+                "pixel_ratio": 1.5,
+                "screen_height": random.randint(800, 1200),
+                "screen_width": random.randint(1200, 2200),
+            },
+            "conversation_mode": conversation_mode,
+            "conversation_origin": None,
+            "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,
+            "paragen_cot_summary_display_override": "allow",
+            "paragen_stream_type_override": None,
+            "parent_message_id": self.parent_message_id if self.parent_message_id else f"{uuid.uuid4()}",
+            "reset_rate_limits": False,
+            "suggestions": [],
+            "supported_encodings": [],
+            "system_hints": [],
+            "timezone": "America/Los_Angeles",
+            "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_chl_opt" in rtext:
+                        # logger.error(f"Failed to send conversation: cf_chl_opt")
+                        raise HTTPException(status_code=r.status_code, detail="cf_chl_opt")
+                    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=10)
+            if r.status_code == 200:
+                download_url = r.json().get('download_url')
+                return download_url
+            else:
+                raise HTTPException(status_code=r.status_code, detail=r.text)
+        except Exception as e:
+            logger.error(f"Failed to get download url: {e}")
+            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=10)
+            if r.status_code == 200:
+                download_url = r.json().get('download_url')
+                return download_url
+            else:
+                raise HTTPException(status_code=r.status_code, detail=r.text)
+        except Exception as e:
+            logger.error(f"Failed to get download url from upload: {e}")
+            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, "reset_rate_limits": False, "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:
+                raise HTTPException(status_code=r.status_code, detail=r.text)
+        except Exception as e:
+            logger.error(f"Failed to get upload url: {e}")
+            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)
+        headers.pop('oai-device-id', None)
+        headers.pop('oai-language', None)
+        try:
+            r = await self.s.put(upload_url, headers=headers, data=file_content, timeout=60)
+            if r.status_code == 201:
+                return True
+            else:
+                raise HTTPException(status_code=r.status_code, detail=r.text)
+        except Exception as e:
+            logger.error(f"Failed to upload file: {e}")
+            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
+
+    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()
+            del self.s
+        if self.ss:
+            await self.ss.close()
+            del self.ss
+        if self.ws:
+            await self.ws.close()
+            del self.ws

chatgpt/authorization.py

@@ -0,0 +1,78 @@
+import asyncio
+import json
+import random
+
+from fastapi import HTTPException
+
+import utils.configs as configs
+import utils.globals as globals
+from chatgpt.refreshToken import rt2ac
+from utils.Logger import logger
+
+
+def get_req_token(req_token, seed=None):
+    if configs.auto_seed:
+        available_token_list = list(set(globals.token_list) - set(globals.error_token_list))
+        length = len(available_token_list)
+        if seed and length > 0:
+            if seed not in globals.seed_map.keys():
+                globals.seed_map[seed] = {"token": random.choice(available_token_list), "conversations": []}
+                with open(globals.SEED_MAP_FILE, "w") as f:
+                    json.dump(globals.seed_map, f, indent=4)
+            else:
+                req_token = globals.seed_map[seed]["token"]
+            return req_token
+
+        if req_token in configs.authorization_list:
+            if len(available_token_list) > 0:
+                if configs.random_token:
+                    req_token = random.choice(available_token_list)
+                    return req_token
+                else:
+                    globals.count += 1
+                    globals.count %= length
+                    return available_token_list[globals.count]
+            else:
+                return ""
+        else:
+            return req_token
+    else:
+        seed = req_token
+        if seed not in globals.seed_map.keys():
+            raise HTTPException(status_code=401, detail={"error": "Invalid Seed"})
+        return globals.seed_map[seed]["token"]
+
+
+async def verify_token(req_token):
+    if not req_token:
+        if configs.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:
+                if req_token in globals.error_token_list:
+                    raise HTTPException(status_code=401, detail="Error RefreshToken")
+
+                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 list(set(globals.token_list) - set(globals.error_token_list)):
+        if len(token) == 45:
+            try:
+                await asyncio.sleep(0.5)
+                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,34 @@
+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/fp.py

@@ -0,0 +1,61 @@
+import json
+import random
+import uuid
+
+import ua_generator
+from ua_generator.data.version import VersionRange
+from ua_generator.options import Options
+
+import utils.globals as globals
+from utils import configs
+
+
+def get_fp(req_token):
+    fp = globals.fp_map.get(req_token, {})
+    if fp and fp.get("user-agent") and fp.get("impersonate"):
+        if "proxy_url" in fp.keys() and (fp["proxy_url"] is None or fp["proxy_url"] not in configs.proxy_url_list):
+            fp["proxy_url"] = random.choice(configs.proxy_url_list) if configs.proxy_url_list else None
+            globals.fp_map[req_token] = fp
+            with open(globals.FP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.fp_map, f, indent=4)
+        if globals.impersonate_list and "impersonate" in fp.keys() and fp["impersonate"] not in globals.impersonate_list:
+            fp["impersonate"] = random.choice(globals.impersonate_list)
+            globals.fp_map[req_token] = fp
+            with open(globals.FP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.fp_map, f, indent=4)
+        if configs.user_agents_list and "user-agent" in fp.keys() and fp["user-agent"] not in configs.user_agents_list:
+            fp["user-agent"] = random.choice(configs.user_agents_list)
+            globals.fp_map[req_token] = fp
+            with open(globals.FP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.fp_map, f, indent=4)
+        fp = {k.lower(): v for k, v in fp.items()}
+        return fp
+    else:
+        options = Options(version_ranges={
+            'chrome': VersionRange(min_version=124),
+            'edge': VersionRange(min_version=124),
+        })
+        ua = ua_generator.generate(
+            device=configs.device_tuple if configs.device_tuple else ('desktop'),
+            browser=configs.browser_tuple if configs.browser_tuple else ('chrome', 'edge', 'firefox', 'safari'),
+            platform=configs.platform_tuple if configs.platform_tuple else ('windows', 'macos'),
+            options=options
+        )
+        fp = {
+            "user-agent": ua.text if not configs.user_agents_list else random.choice(configs.user_agents_list),
+            "impersonate": random.choice(globals.impersonate_list),
+            "proxy_url": random.choice(configs.proxy_url_list) if configs.proxy_url_list else None,
+            "oai-device-id": str(uuid.uuid4())
+        }
+        if ua.device == "desktop" and ua.browser in ("chrome", "edge"):
+            fp["sec-ch-ua-platform"] = ua.ch.platform
+            fp["sec-ch-ua"] = ua.ch.brands
+            fp["sec-ch-ua-mobile"] = ua.ch.mobile
+
+        if not req_token:
+            return fp
+        else:
+            globals.fp_map[req_token] = fp
+            with open(globals.FP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.fp_map, f, indent=4)
+            return fp

chatgpt/proofofWork.py

@@ -0,0 +1,505 @@
+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.configs import conversation_only
+
+cores = [8, 16, 24, 32]
+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]",
+    "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]",
+    "getInstalledRelatedApps−function getInstalledRelatedApps() { [native code] }",
+    "mediaDevices−[object MediaDevices]",
+    "locks−[object LockManager]",
+    "webkitGetUserMedia−function webkitGetUserMedia() { [native code] }",
+    "vendor−Google Inc.",
+    "xr−[object XRSystem]",
+    "mediaDevices−[object MediaDevices]",
+    "virtualKeyboard−[object VirtualKeyboard]",
+    "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]",
+    "sendBeacon−function sendBeacon() { [native code] }",
+    "hardwareConcurrency−32",
+    "credentials−[object CredentialsContainer]",
+    "storage−[object StorageManager]",
+    "cookieEnabled−true",
+    "pdfViewerEnabled−true",
+    "windowControlsOverlay−[object WindowControlsOverlay]",
+    "scheduling−[object Scheduling]",
+    "pdfViewerEnabled−true",
+    "hardwareConcurrency−32",
+    "xr−[object XRSystem]",
+    "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):
+    config = [
+        random.randint(1080, 1440+1080),
+        get_parse_time(),
+        4294705152,
+        0,
+        user_agent,
+        random.choice(cached_scripts) if cached_scripts else "",
+        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() * 1000,
+        str(uuid.uuid4()),
+        "",
+        random.choice(cores),
+        time.time() * 1000 - (time.perf_counter() * 1000),
+    ]
+    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 = "prod-f501fe933b3edf57aea882da888e1a544df99840"
+    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,57 @@
+import json
+import random
+import time
+
+from fastapi import HTTPException
+
+from utils.Client import Client
+from utils.Logger import logger
+from utils.configs import proxy_url_list
+import utils.globals as globals
+
+
+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())}
+            with open(globals.REFRESH_MAP_FILE, "w") as f:
+                json.dump(globals.refresh_map, f, indent=4)
+            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:
+            if "invalid_grant" in r.text or "access_denied" in r.text:
+                if refresh_token not in globals.error_token_list:
+                    globals.error_token_list.append(refresh_token)
+                    with open(globals.ERROR_TOKENS_FILE, "a", encoding="utf-8") as f:
+                        f.write(refresh_token + "\n")
+                raise Exception(r.text)
+            else:
+                raise Exception(r.text[:300])
+    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/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 utils.globals as globals
+
+
+def save_wss_map(wss_map):
+    with open(globals.WSS_MAP_FILE, "w") as f:
+        json.dump(wss_map, f, indent=4)
+
+
+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

gateway/backend.py

@@ -0,0 +1,491 @@
+import json
+import random
+import re
+import time
+import uuid
+
+from fastapi import Request, HTTPException
+from fastapi.responses import RedirectResponse, StreamingResponse, Response
+from starlette.background import BackgroundTask
+from starlette.concurrency import run_in_threadpool
+
+import utils.globals as globals
+from app import app
+from chatgpt.authorization import verify_token
+from chatgpt.fp import get_fp
+from chatgpt.proofofWork import get_answer_token, get_config, get_requirements_token
+from gateway.chatgpt import chatgpt_html
+from gateway.reverseProxy import chatgpt_reverse_proxy, content_generator, get_real_req_token, headers_reject_list, \
+    headers_accept_list
+from utils.Client import Client
+from utils.Logger import logger
+from utils.configs import x_sign, turnstile_solver_url, chatgpt_base_url_list, no_sentinel, sentinel_proxy_url_list, \
+    force_no_history
+
+banned_paths = [
+    "backend-api/accounts/logout_all",
+    "backend-api/accounts/deactivate",
+    "backend-api/payments",
+    "backend-api/subscriptions",
+    "backend-api/user_system_messages",
+    "backend-api/memories",
+    "backend-api/settings/clear_account_user_memory",
+    "backend-api/conversations/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}",
+    "backend-api/accounts/mfa_info",
+    "backend-api/accounts/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/invites",
+    "admin",
+]
+redirect_paths = ["auth/logout"]
+chatgpt_paths = ["c/[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}"]
+
+
+@app.get("/backend-api/accounts/check/v4-2023-04-27")
+async def check_account(request: Request):
+    token = request.headers.get("Authorization").replace("Bearer ", "")
+    check_account_response = await chatgpt_reverse_proxy(request, "backend-api/accounts/check/v4-2023-04-27")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return check_account_response
+    else:
+        check_account_str = check_account_response.body.decode('utf-8')
+        check_account_info = json.loads(check_account_str)
+        for key in check_account_info.get("accounts", {}).keys():
+            account_id = check_account_info["accounts"][key]["account"]["account_id"]
+            globals.seed_map[token]["user_id"] = \
+                check_account_info["accounts"][key]["account"]["account_user_id"].split("__")[0]
+            check_account_info["accounts"][key]["account"]["account_user_id"] = f"user-chatgpt__{account_id}"
+        with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+            json.dump(globals.seed_map, f, indent=4)
+        return check_account_info
+
+
+@app.get("/backend-api/gizmos/bootstrap")
+async def get_gizmos_bootstrap(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return await chatgpt_reverse_proxy(request, "backend-api/gizmos/bootstrap")
+    else:
+        return {"gizmos": []}
+
+
+@app.get("/backend-api/gizmos/pinned")
+async def get_gizmos_pinned(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return await chatgpt_reverse_proxy(request, "backend-api/gizmos/pinned")
+    else:
+        return {"items": [], "cursor": None}
+
+
+@app.get("/public-api/gizmos/discovery/recent")
+async def get_gizmos_discovery_recent(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return await chatgpt_reverse_proxy(request, "public-api/gizmos/discovery/recent")
+    else:
+        return {
+            "info": {
+                "id": "recent",
+                "title": "Recently Used",
+            },
+            "list": {
+                "items": [],
+                "cursor": None
+            }
+        }
+
+
+@app.get("/backend-api/gizmos/snorlax/sidebar")
+async def get_gizmos_snorlax_sidebar(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith:
+        return await chatgpt_reverse_proxy(request, "backend-api/gizmos/snorlax/sidebar")
+    else:
+        return {"items": [], "cursor": None}
+
+
+@app.post("/backend-api/gizmos/snorlax/upsert")
+async def get_gizmos_snorlax_upsert(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith:
+        return await chatgpt_reverse_proxy(request, "backend-api/gizmos/snorlax/upsert")
+    else:
+        raise HTTPException(status_code=403, detail="Forbidden")
+
+
+@app.api_route("/backend-api/conversations", methods=["GET", "PATCH"])
+async def get_conversations(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return await chatgpt_reverse_proxy(request, "backend-api/conversations")
+    if request.method == "GET":
+        limit = int(request.query_params.get("limit", 28))
+        offset = int(request.query_params.get("offset", 0))
+        is_archived = request.query_params.get("is_archived", None)
+        items = []
+        for conversation_id in globals.seed_map.get(token, {}).get("conversations", []):
+            conversation = globals.conversation_map.get(conversation_id, None)
+            if conversation:
+                if is_archived == "true":
+                    if conversation.get("is_archived", False):
+                        items.append(conversation)
+                else:
+                    if not conversation.get("is_archived", False):
+                        items.append(conversation)
+        items = items[int(offset):int(offset) + int(limit)]
+        conversations = {
+            "items": items,
+            "total": len(items),
+            "limit": limit,
+            "offset": offset,
+            "has_missing_conversations": False
+        }
+        return Response(content=json.dumps(conversations, indent=4), media_type="application/json")
+    else:
+        raise HTTPException(status_code=403, detail="Forbidden")
+
+
+@app.get("/backend-api/conversation/{conversation_id}")
+async def update_conversation(request: Request, conversation_id: str):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    conversation_details_response = await chatgpt_reverse_proxy(request,
+                                                                f"backend-api/conversation/{conversation_id}")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return conversation_details_response
+    else:
+        conversation_details_str = conversation_details_response.body.decode('utf-8')
+        conversation_details = json.loads(conversation_details_str)
+        if conversation_id in globals.seed_map[token][
+            "conversations"] and conversation_id in globals.conversation_map:
+            globals.conversation_map[conversation_id]["title"] = conversation_details.get("title", None)
+            globals.conversation_map[conversation_id]["is_archived"] = conversation_details.get("is_archived",
+                                                                                                False)
+            globals.conversation_map[conversation_id]["conversation_template_id"] = conversation_details.get(
+                "conversation_template_id", None)
+            globals.conversation_map[conversation_id]["gizmo_id"] = conversation_details.get("gizmo_id", None)
+            globals.conversation_map[conversation_id]["async_status"] = conversation_details.get("async_status",
+                                                                                                 None)
+            with open(globals.CONVERSATION_MAP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.conversation_map, f, indent=4)
+        return conversation_details_response
+
+
+@app.patch("/backend-api/conversation/{conversation_id}")
+async def patch_conversation(request: Request, conversation_id: str):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    patch_response = (await chatgpt_reverse_proxy(request, f"backend-api/conversation/{conversation_id}"))
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return patch_response
+    else:
+        data = await request.json()
+        if conversation_id in globals.seed_map[token][
+            "conversations"] and conversation_id in globals.conversation_map:
+            if not data.get("is_visible", True):
+                globals.conversation_map.pop(conversation_id)
+                globals.seed_map[token]["conversations"].remove(conversation_id)
+                with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+                    json.dump(globals.seed_map, f, indent=4)
+            else:
+                globals.conversation_map[conversation_id].update(data)
+            with open(globals.CONVERSATION_MAP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.conversation_map, f, indent=4)
+        return patch_response
+
+
+@app.get("/backend-api/me")
+async def get_me(request: Request):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) == 45 or token.startswith("eyJhbGciOi"):
+        return await chatgpt_reverse_proxy(request, "backend-api/me")
+    else:
+        me = {
+            "object": "user",
+            "id": "org-chatgpt",
+            "email": "chatgpt@openai.com",
+            "name": "ChatGPT",
+            "picture": "https://cdn.auth0.com/avatars/ai.png",
+            "created": int(time.time()),
+            "phone_number": None,
+            "mfa_flag_enabled": False,
+            "amr": [],
+            "groups": [],
+            "orgs": {
+                "object": "list",
+                "data": [
+                    {
+                        "object": "organization",
+                        "id": "org-chatgpt",
+                        "created": 1715641300,
+                        "title": "Personal",
+                        "name": "user-chatgpt",
+                        "description": "Personal org for chatgpt@openai.com",
+                        "personal": True,
+                        "settings": {
+                            "threads_ui_visibility": "NONE",
+                            "usage_dashboard_visibility": "ANY_ROLE",
+                            "disable_user_api_keys": False
+                        },
+                        "parent_org_id": None,
+                        "is_default": True,
+                        "role": "owner",
+                        "is_scale_tier_authorized_purchaser": None,
+                        "is_scim_managed": False,
+                        "projects": {
+                            "object": "list",
+                            "data": []
+                        },
+                        "groups": [],
+                        "geography": None
+                    }
+                ]
+            },
+            "has_payg_project_spend_limit": True
+        }
+    return Response(content=json.dumps(me, indent=4), media_type="application/json")
+
+
+@app.post("/backend-api/edge")
+async def edge():
+    return Response(status_code=204)
+
+
+if no_sentinel:
+    openai_sentinel_tokens_cache = {}
+
+    @app.post("/backend-api/sentinel/chat-requirements")
+    async def sentinel_chat_conversations(request: Request):
+        token = request.headers.get("Authorization", "").replace("Bearer ", "")
+        req_token = await get_real_req_token(token)
+        access_token = await verify_token(req_token)
+        fp = get_fp(req_token).copy()
+        proxy_url = fp.pop("proxy_url", None)
+        impersonate = fp.pop("impersonate", "safari15_3")
+        user_agent = fp.get("user-agent",
+                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0")
+
+        host_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        proof_token = None
+        turnstile_token = None
+
+        # headers = {
+        #     key: value for key, value in request.headers.items()
+        #     if (key.lower() not in ["host", "origin", "referer", "priority", "sec-ch-ua-platform", "sec-ch-ua",
+        #                             "sec-ch-ua-mobile", "oai-device-id"] and key.lower() not in headers_reject_list)
+        # }
+        headers = {
+            key: value for key, value in request.headers.items()
+            if (key.lower() in headers_accept_list)
+        }
+        headers.update(fp)
+        headers.update({"authorization": f"Bearer {access_token}"})
+        client = Client(proxy=proxy_url, impersonate=impersonate)
+        if sentinel_proxy_url_list:
+            clients = Client(proxy=random.choice(sentinel_proxy_url_list), impersonate=impersonate)
+        else:
+            clients = client
+
+        try:
+            config = get_config(user_agent)
+            p = get_requirements_token(config)
+            data = {'p': p}
+            r = await clients.post(f'{host_url}/backend-api/sentinel/chat-requirements', headers=headers, json=data,
+                                   timeout=10)
+            if r.status_code != 200:
+                raise HTTPException(status_code=r.status_code, detail="Failed to get chat requirements")
+            resp = r.json()
+            turnstile = resp.get('turnstile', {})
+            turnstile_required = turnstile.get('required')
+            if turnstile_required:
+                turnstile_dx = turnstile.get("dx")
+                try:
+                    if turnstile_solver_url:
+                        res = await client.post(turnstile_solver_url,
+                                                json={"url": "https://chatgpt.com", "p": p, "dx": turnstile_dx})
+                        turnstile_token = res.json().get("t")
+                except Exception as e:
+                    logger.info(f"Turnstile ignored: {e}")
+
+            proofofwork = resp.get('proofofwork', {})
+            proofofwork_required = proofofwork.get('required')
+            if proofofwork_required:
+                proofofwork_diff = proofofwork.get("difficulty")
+                proofofwork_seed = proofofwork.get("seed")
+                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")
+            chat_token = resp.get('token')
+
+            openai_sentinel_tokens_cache[req_token] = {
+                "chat_token": chat_token,
+                "proof_token": proof_token,
+                "turnstile_token": turnstile_token
+            }
+        except Exception as e:
+            logger.error(f"Sentinel failed: {e}")
+
+        return {
+            "arkose": {
+                "dx": None,
+                "required": False
+            },
+            "persona": "chatgpt-paid",
+            "proofofwork": {
+                "difficulty": None,
+                "required": False,
+                "seed": None
+            },
+            "token": str(uuid.uuid4()),
+            "turnstile": {
+                "dx": None,
+                "required": False
+            }
+        }
+
+
+    @app.post("/backend-alt/conversation")
+    @app.post("/backend-api/conversation")
+    async def chat_conversations(request: Request):
+        token = request.headers.get("Authorization", "").replace("Bearer ", "")
+        req_token = await get_real_req_token(token)
+        access_token = await verify_token(req_token)
+        fp = get_fp(req_token).copy()
+        proxy_url = fp.pop("proxy_url", None)
+        impersonate = fp.pop("impersonate", "safari15_3")
+        user_agent = fp.get("user-agent",
+                            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/130.0.0.0 Safari/537.36 Edg/130.0.0.0")
+
+        host_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        proof_token = None
+        turnstile_token = None
+
+        # headers = {
+        #     key: value for key, value in request.headers.items()
+        #     if (key.lower() not in ["host", "origin", "referer", "priority", "sec-ch-ua-platform", "sec-ch-ua",
+        #                             "sec-ch-ua-mobile", "oai-device-id"] and key.lower() not in headers_reject_list)
+        # }
+        headers = {
+            key: value for key, value in request.headers.items()
+            if (key.lower() in headers_accept_list)
+        }
+        headers.update(fp)
+        headers.update({"authorization": f"Bearer {access_token}"})
+
+        try:
+            client = Client(proxy=proxy_url, impersonate=impersonate)
+            if sentinel_proxy_url_list:
+                clients = Client(proxy=random.choice(sentinel_proxy_url_list), impersonate=impersonate)
+            else:
+                clients = client
+
+            sentinel_tokens = openai_sentinel_tokens_cache.get(req_token, {})
+            openai_sentinel_tokens_cache.pop(req_token, None)
+            if not sentinel_tokens:
+                config = get_config(user_agent)
+                p = get_requirements_token(config)
+                data = {'p': p}
+                r = await clients.post(f'{host_url}/backend-api/sentinel/chat-requirements', headers=headers, json=data,
+                                       timeout=10)
+                resp = r.json()
+                turnstile = resp.get('turnstile', {})
+                turnstile_required = turnstile.get('required')
+                if turnstile_required:
+                    turnstile_dx = turnstile.get("dx")
+                    try:
+                        if turnstile_solver_url:
+                            res = await client.post(turnstile_solver_url,
+                                                    json={"url": "https://chatgpt.com", "p": p, "dx": turnstile_dx})
+                            turnstile_token = res.json().get("t")
+                    except Exception as e:
+                        logger.info(f"Turnstile ignored: {e}")
+
+                proofofwork = resp.get('proofofwork', {})
+                proofofwork_required = proofofwork.get('required')
+                if proofofwork_required:
+                    proofofwork_diff = proofofwork.get("difficulty")
+                    proofofwork_seed = proofofwork.get("seed")
+                    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")
+                chat_token = resp.get('token')
+                headers.update({
+                    "openai-sentinel-chat-requirements-token": chat_token,
+                    "openai-sentinel-proof-token": proof_token,
+                    "openai-sentinel-turnstile-token": turnstile_token,
+                })
+            else:
+                headers.update({
+                    "openai-sentinel-chat-requirements-token": sentinel_tokens.get("chat_token", ""),
+                    "openai-sentinel-proof-token": sentinel_tokens.get("proof_token", ""),
+                    "openai-sentinel-turnstile-token": sentinel_tokens.get("turnstile_token", "")
+                })
+        except Exception as e:
+            logger.error(f"Sentinel failed: {e}")
+            return Response(status_code=403, content="Sentinel failed")
+
+        params = dict(request.query_params)
+        data = await request.body()
+        request_cookies = dict(request.cookies)
+
+        async def c_close(client, clients):
+            if client:
+                await client.close()
+                del client
+            if clients:
+                await clients.close()
+                del clients
+
+        history = True
+        try:
+            req_json = json.loads(data)
+            history = not req_json.get("history_and_training_disabled", False)
+        except Exception:
+            pass
+        if force_no_history:
+            history = False
+            req_json = json.loads(data)
+            req_json["history_and_training_disabled"] = True
+            data = json.dumps(req_json).encode("utf-8")
+
+        background = BackgroundTask(c_close, client, clients)
+        r = await client.post_stream(f"{host_url}{request.url.path}", params=params, headers=headers,
+                                     cookies=request_cookies, data=data, stream=True, allow_redirects=False)
+        rheaders = r.headers
+        logger.info(f"Request token: {req_token}")
+        logger.info(f"Request proxy: {proxy_url}")
+        logger.info(f"Request UA: {user_agent}")
+        logger.info(f"Request impersonate: {impersonate}")
+        if x_sign:
+            rheaders.update({"x-sign": x_sign})
+        if 'stream' in rheaders.get("content-type", ""):
+            conv_key = r.cookies.get("conv_key", "")
+            response = StreamingResponse(content_generator(r, token, history), headers=rheaders,
+                                         media_type=r.headers.get("content-type", ""), background=background)
+            response.set_cookie("conv_key", value=conv_key)
+            return response
+        else:
+            return Response(content=(await r.atext()), headers=rheaders, media_type=rheaders.get("content-type"),
+                            status_code=r.status_code, background=background)
+
+
+@app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "OPTIONS", "HEAD", "PATCH", "TRACE"])
+async def reverse_proxy(request: Request, path: str):
+    token = request.headers.get("Authorization", "").replace("Bearer ", "")
+    if len(token) != 45 and not token.startswith("eyJhbGciOi"):
+        for banned_path in banned_paths:
+            if re.match(banned_path, path):
+                raise HTTPException(status_code=403, detail="Forbidden")
+
+    for chatgpt_path in chatgpt_paths:
+        if re.match(chatgpt_path, path):
+            return await chatgpt_html(request)
+
+    for redirect_path in redirect_paths:
+        if re.match(redirect_path, path):
+            redirect_url = str(request.base_url)
+            response = RedirectResponse(url=f"{redirect_url}login", status_code=302)
+            return response
+
+    return await chatgpt_reverse_proxy(request, path)

gateway/chatgpt.py

@@ -0,0 +1,32 @@
+import json
+from urllib.parse import quote
+
+from fastapi import Request
+from fastapi.responses import HTMLResponse
+
+from app import app, templates
+from gateway.login import login_html
+from utils.kv_utils import set_value_for_key
+
+with open("templates/chatgpt_context.json", "r", encoding="utf-8") as f:
+    chatgpt_context = json.load(f)
+
+
+@app.get("/", response_class=HTMLResponse)
+async def chatgpt_html(request: Request):
+    token = request.query_params.get("token")
+    if not token:
+        token = request.cookies.get("token")
+    if not token:
+        return await login_html(request)
+
+    if len(token) != 45 and not token.startswith("eyJhbGciOi"):
+        token = quote(token)
+
+    user_remix_context = chatgpt_context.copy()
+    set_value_for_key(user_remix_context, "user", {"id": "user-chatgpt"})
+    set_value_for_key(user_remix_context, "accessToken", token)
+
+    response = templates.TemplateResponse("chatgpt.html", {"request": request, "remix_context": user_remix_context})
+    response.set_cookie("token", value=token, expires="Thu, 01 Jan 2099 00:00:00 GMT")
+    return response

gateway/gpts.py

@@ -0,0 +1,24 @@
+import json
+
+from fastapi import Request
+from fastapi.responses import Response
+
+from app import app
+from gateway.chatgpt import chatgpt_html
+
+with open("templates/gpts_context.json", "r", encoding="utf-8") as f:
+    gpts_context = json.load(f)
+
+
+@app.get("/gpts")
+async def get_gpts():
+    return {"kind": "store"}
+
+
+@app.get("/g/g-{gizmo_id}")
+async def get_gizmo_json(request: Request, gizmo_id: str):
+    params = request.query_params
+    if params.get("_data") == "routes/g.$gizmoId._index":
+        return Response(content=json.dumps(gpts_context, indent=4), media_type="application/json")
+    else:
+        return await chatgpt_html(request)

gateway/login.py

@@ -0,0 +1,10 @@
+from fastapi import Request
+from fastapi.responses import HTMLResponse
+
+from app import app, templates
+
+
+@app.get("/login", response_class=HTMLResponse)
+async def login_html(request: Request):
+    response = templates.TemplateResponse("login.html", {"request": request})
+    return response

gateway/reverseProxy.py

@@ -0,0 +1,326 @@
+import json
+import random
+import time
+from datetime import datetime, timezone
+
+from fastapi import Request, HTTPException
+from fastapi.responses import StreamingResponse, Response
+from starlette.background import BackgroundTask
+
+import utils.globals as globals
+from chatgpt.authorization import verify_token, get_req_token
+from chatgpt.fp import get_fp
+from utils.Client import Client
+from utils.Logger import logger
+from utils.configs import chatgpt_base_url_list, sentinel_proxy_url_list, force_no_history, file_host, voice_host
+
+
+def generate_current_time():
+    current_time = datetime.now(timezone.utc)
+    formatted_time = current_time.isoformat(timespec='microseconds').replace('+00:00', 'Z')
+    return formatted_time
+
+
+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",
+]
+
+headers_accept_list = [
+    "openai-sentinel-chat-requirements-token",
+    "openai-sentinel-proof-token",
+    "openai-sentinel-turnstile-token",
+    "accept",
+    "authorization",
+    "accept-encoding",
+    "accept-language",
+    "content-type",
+    "oai-device-id",
+    "oai-echo-logs",
+    "oai-language",
+    "sec-fetch-dest",
+    "sec-fetch-mode",
+    "sec-fetch-site",
+]
+
+
+async def get_real_req_token(token):
+    req_token = get_req_token(token)
+    if len(req_token) == 45 or req_token.startswith("eyJhbGciOi"):
+        return req_token
+    else:
+        req_token = get_req_token("", token)
+        return req_token
+
+
+def save_conversation(token, conversation_id, title=None):
+    if conversation_id not in globals.conversation_map:
+        conversation_detail = {
+            "id": conversation_id,
+            "title": title,
+            "create_time": generate_current_time(),
+            "update_time": generate_current_time()
+        }
+        globals.conversation_map[conversation_id] = conversation_detail
+    else:
+        globals.conversation_map[conversation_id]["update_time"] = generate_current_time()
+        if title:
+            globals.conversation_map[conversation_id]["title"] = title
+    if conversation_id not in globals.seed_map[token]["conversations"]:
+        globals.seed_map[token]["conversations"].insert(0, conversation_id)
+    else:
+        globals.seed_map[token]["conversations"].remove(conversation_id)
+        globals.seed_map[token]["conversations"].insert(0, conversation_id)
+    with open(globals.CONVERSATION_MAP_FILE, "w", encoding="utf-8") as f:
+        json.dump(globals.conversation_map, f, indent=4)
+    with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+        json.dump(globals.seed_map, f, indent=4)
+    if title:
+        logger.info(f"Conversation ID: {conversation_id}, Title: {title}")
+
+
+async def content_generator(r, token, history=True):
+    conversation_id = None
+    title = None
+    async for chunk in r.aiter_content():
+        try:
+            if history and (len(token) != 45 and not token.startswith("eyJhbGciOi")) and (not conversation_id or not title):
+                chat_chunk = chunk.decode('utf-8')
+                if not conversation_id or not title and chat_chunk.startswith("event: delta\n\ndata: {"):
+                    chunk_data = chat_chunk[19:]
+                    conversation_id = json.loads(chunk_data).get("v").get("conversation_id")
+                    if conversation_id:
+                        save_conversation(token, conversation_id)
+                        title = globals.conversation_map[conversation_id].get("title")
+                if chat_chunk.startswith("data: {"):
+                    if "\n\nevent: delta" in chat_chunk:
+                        index = chat_chunk.find("\n\nevent: delta")
+                        chunk_data = chat_chunk[6:index]
+                    elif "\n\ndata: {" in chat_chunk:
+                        index = chat_chunk.find("\n\ndata: {")
+                        chunk_data = chat_chunk[6:index]
+                    else:
+                        chunk_data = chat_chunk[6:]
+                    chunk_data = chunk_data.strip()
+                    if conversation_id is None:
+                        conversation_id = json.loads(chunk_data).get("conversation_id")
+                        if conversation_id:
+                            save_conversation(token, conversation_id)
+                            title = globals.conversation_map[conversation_id].get("title")
+                    if title is None:
+                        title = json.loads(chunk_data).get("title")
+                        if title:
+                            save_conversation(token, conversation_id, title)
+        except Exception as e:
+            # logger.error(e)
+            # logger.error(chunk.decode('utf-8'))
+            pass
+        yield chunk
+
+
+async def chatgpt_reverse_proxy(request: Request, path: str):
+    try:
+        origin_host = request.url.netloc
+        if request.url.is_secure:
+            petrol = "https"
+        else:
+            petrol = "http"
+        if "x-forwarded-proto" in request.headers:
+            petrol = request.headers["x-forwarded-proto"]
+        if "cf-visitor" in request.headers:
+            cf_visitor = json.loads(request.headers["cf-visitor"])
+            petrol = cf_visitor.get("scheme", petrol)
+
+        params = dict(request.query_params)
+        request_cookies = dict(request.cookies)
+
+        # headers = {
+        #     key: value for key, value in request.headers.items()
+        #     if (key.lower() not in ["host", "origin", "referer", "priority",
+        #                             "oai-device-id"] and key.lower() not in headers_reject_list)
+        # }
+        headers = {
+            key: value for key, value in request.headers.items()
+            if (key.lower() in headers_accept_list)
+        }
+
+        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"
+        if "file-" in path and "backend-api" not in path:
+            base_url = "https://files.oaiusercontent.com"
+        if "v1/" in path:
+            base_url = "https://ab.chatgpt.com"
+        if "sandbox" in path:
+            base_url = "https://web-sandbox.oaiusercontent.com"
+            path = path.replace("sandbox/", "")
+
+        token = headers.get("authorization", "").replace("Bearer ", "").strip()
+        if token:
+            req_token = await get_real_req_token(token)
+            access_token = await verify_token(req_token)
+            headers.update({"authorization": f"Bearer {access_token}"})
+
+        cookie_token = request.cookies.get("token", "")
+        req_token = await get_real_req_token(cookie_token)
+        fp = get_fp(req_token).copy()
+
+        proxy_url = fp.pop("proxy_url", None)
+        impersonate = fp.pop("impersonate", "safari15_3")
+        user_agent = fp.get("user-agent")
+        headers.update(fp)
+
+        headers.update({
+            "accept-language": "en-US,en;q=0.9",
+            "host": base_url.replace("https://", "").replace("http://", ""),
+            "origin": base_url,
+            "referer": f"{base_url}/"
+        })
+        if "v1/initialize" in path:
+            headers.update({"user-agent": request.headers.get("user-agent")})
+            if "statsig-api-key" not in headers:
+                headers.update({
+                    "statsig-sdk-type": "js-client",
+                    "statsig-api-key": "client-tnE5GCU2F2cTxRiMbvTczMDT1jpwIigZHsZSdqiy4u",
+                    "statsig-sdk-version": "5.1.0",
+                    "statsig-client-time": int(time.time() * 1000),
+                })
+
+        data = await request.body()
+
+        history = True
+        if path.endswith("backend-api/conversation") or path.endswith("backend-alt/conversation"):
+            try:
+                req_json = json.loads(data)
+                history = not req_json.get("history_and_training_disabled", False)
+            except Exception:
+                pass
+            if force_no_history:
+                history = False
+                req_json = json.loads(data)
+                req_json["history_and_training_disabled"] = True
+                data = json.dumps(req_json).encode("utf-8")
+
+
+        if sentinel_proxy_url_list and "backend-api/sentinel/chat-requirements" in path:
+            client = Client(proxy=random.choice(sentinel_proxy_url_list))
+        else:
+            client = Client(proxy=proxy_url, impersonate=impersonate)
+        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 == 307 or r.status_code == 302 or r.status_code == 301:
+                return Response(status_code=307,
+                                headers={"Location": r.headers.get("Location")
+                                .replace("ab.chatgpt.com", origin_host)
+                                .replace("chatgpt.com", origin_host)
+                                .replace("cdn.oaistatic.com", origin_host)
+                                .replace("https", petrol)}, background=background)
+            elif 'stream' in r.headers.get("content-type", ""):
+                logger.info(f"Request token: {req_token}")
+                logger.info(f"Request proxy: {proxy_url}")
+                logger.info(f"Request UA: {user_agent}")
+                logger.info(f"Request impersonate: {impersonate}")
+                conv_key = r.cookies.get("conv_key", "")
+                response = StreamingResponse(content_generator(r, token, history), media_type=r.headers.get("content-type", ""),
+                                  background=background)
+                response.set_cookie("conv_key", value=conv_key)
+                return response
+            elif 'image' in r.headers.get("content-type", "") or "audio" in r.headers.get("content-type", "") or "video" in r.headers.get("content-type", ""):
+                rheaders = dict(r.headers)
+                response = Response(content=await r.acontent(), headers=rheaders,
+                                        status_code=r.status_code, background=background)
+                return response
+            else:
+                if path.endswith("backend-api/conversation") or path.endswith("backend-alt/conversation") or "/register-websocket" in path:
+                    response = Response(content=(await r.acontent()), media_type=r.headers.get("content-type"),
+                                        status_code=r.status_code, background=background)
+                else:
+                    content = await r.atext()
+                    if "public-api/" in path:
+                        content = (content
+                                   .replace("https://ab.chatgpt.com", f"{petrol}://{origin_host}")
+                                   .replace("https://cdn.oaistatic.com", f"{petrol}://{origin_host}")
+                                   .replace("webrtc.chatgpt.com", voice_host if voice_host else "webrtc.chatgpt.com")
+                                   .replace("files.oaiusercontent.com", file_host if file_host else "files.oaiusercontent.com")
+                                   .replace("chatgpt.com/ces", f"{origin_host}/ces")
+                                   )
+                    else:
+                        content = (content
+                                   .replace("https://ab.chatgpt.com", f"{petrol}://{origin_host}")
+                                   .replace("https://cdn.oaistatic.com", f"{petrol}://{origin_host}")
+                                   .replace("webrtc.chatgpt.com", voice_host if voice_host else "webrtc.chatgpt.com")
+                                   .replace("files.oaiusercontent.com", file_host if file_host else "files.oaiusercontent.com")
+                                   .replace("web-sandbox.oaiusercontent.com", f"{origin_host}/sandbox")
+                                   .replace("https://chatgpt.com", f"{petrol}://{origin_host}")
+                                   .replace("chatgpt.com/ces", f"{origin_host}/ces")
+                                   )
+                    if base_url == "https://web-sandbox.oaiusercontent.com":
+                        content = content.replace("/assets", "/sandbox/assets")
+                    rheaders = dict(r.headers)
+                    content_type = rheaders.get("content-type", "")
+                    cache_control = rheaders.get("cache-control", "")
+                    expires = rheaders.get("expires", "")
+                    content_disposition = rheaders.get("content-disposition", "")
+                    rheaders = {
+                        "cache-control": cache_control,
+                        "content-type": content_type,
+                        "expires": expires,
+                        "content-disposition": content_disposition
+                    }
+                    response = Response(content=content, headers=rheaders,
+                                        status_code=r.status_code, background=background)
+                return response
+        except Exception:
+            await client.close()
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

gateway/share.py

@@ -0,0 +1,251 @@
+import json
+import random
+import time
+
+import jwt
+from fastapi import Request, HTTPException, Security
+from fastapi.responses import Response
+from fastapi.security import HTTPAuthorizationCredentials
+
+import utils.globals as globals
+from app import app, security_scheme
+from chatgpt.authorization import verify_token
+from chatgpt.fp import get_fp
+from gateway.reverseProxy import get_real_req_token
+from utils.Client import Client
+from utils.Logger import logger
+from utils.configs import proxy_url_list, chatgpt_base_url_list, authorization_list
+
+base_headers = {
+    'accept': '*/*',
+    'accept-encoding': 'gzip, deflate, br, zstd',
+    'accept-language': 'en-US,en;q=0.9',
+    'content-type': 'application/json',
+    'oai-language': 'en-US',
+    'priority': 'u=1, i',
+    'sec-fetch-dest': 'empty',
+    'sec-fetch-mode': 'cors',
+    'sec-fetch-site': 'same-origin',
+}
+
+
+def verify_authorization(bearer_token):
+    if not bearer_token:
+        raise HTTPException(status_code=401, detail="Authorization header is missing")
+    if bearer_token not in authorization_list:
+        raise HTTPException(status_code=401, detail="Invalid authorization")
+
+
+@app.get("/seedtoken")
+async def get_seedtoken(request: Request, credentials: HTTPAuthorizationCredentials = Security(security_scheme)):
+    verify_authorization(credentials.credentials)
+    try:
+        params = request.query_params
+        seed = params.get("seed")
+
+        if seed:
+            if seed not in globals.seed_map:
+                raise HTTPException(status_code=404, detail=f"Seed '{seed}' not found")
+            return {
+                "status": "success",
+                "data": {
+                    "seed": seed,
+                    "token": globals.seed_map[seed]["token"]
+                }
+            }
+
+        token_map = {
+            seed: data["token"]
+            for seed, data in globals.seed_map.items()
+        }
+        return {"status": "success", "data": token_map}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+@app.post("/seedtoken")
+async def set_seedtoken(request: Request, credentials: HTTPAuthorizationCredentials = Security(security_scheme)):
+    verify_authorization(credentials.credentials)
+    data = await request.json()
+
+    seed = data.get("seed")
+    token = data.get("token")
+
+    if seed not in globals.seed_map:
+        globals.seed_map[seed] = {
+            "token": token,
+            "conversations": []
+        }
+    else:
+        globals.seed_map[seed]["token"] = token
+
+    with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+        json.dump(globals.seed_map, f, indent=4)
+
+    return {"status": "success", "message": "Token updated successfully"}
+
+
+@app.delete("/seedtoken")
+async def delete_seedtoken(request: Request, credentials: HTTPAuthorizationCredentials = Security(security_scheme)):
+    verify_authorization(credentials.credentials)
+
+    try:
+        data = await request.json()
+        seed = data.get("seed")
+
+        if seed == "clear":
+            globals.seed_map.clear()
+            with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+                json.dump(globals.seed_map, f, indent=4)
+            return {"status": "success", "message": "All seeds deleted successfully"}
+
+        if not seed:
+            raise HTTPException(status_code=400, detail="Missing required field: seed")
+
+        if seed not in globals.seed_map:
+            raise HTTPException(status_code=404, detail=f"Seed '{seed}' not found")
+        del globals.seed_map[seed]
+
+        with open(globals.SEED_MAP_FILE, "w", encoding="utf-8") as f:
+            json.dump(globals.seed_map, f, indent=4)
+
+        return {
+            "status": "success",
+            "message": f"Seed '{seed}' deleted successfully"
+        }
+
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON data")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
+
+
+async def chatgpt_account_check(access_token):
+    auth_info = {}
+    client = Client(proxy=random.choice(proxy_url_list) if proxy_url_list else None)
+    try:
+        host_url = random.choice(chatgpt_base_url_list) if chatgpt_base_url_list else "https://chatgpt.com"
+        req_token = await get_real_req_token(access_token)
+        access_token = await verify_token(req_token)
+        fp = get_fp(req_token).copy()
+        proxy_url = fp.pop("proxy_url", None)
+        impersonate = fp.pop("impersonate", "safari15_3")
+
+        headers = base_headers.copy()
+        headers.update(fp)
+        headers.update({"authorization": f"Bearer {access_token}"})
+
+        client = Client(proxy=proxy_url, impersonate=impersonate)
+        r = await client.get(f"{host_url}/backend-api/models?history_and_training_disabled=false", headers=headers,
+                             timeout=10)
+        if r.status_code != 200:
+            raise HTTPException(status_code=r.status_code, detail=r.text)
+        models = r.json()
+        r = await client.get(f"{host_url}/backend-api/accounts/check/v4-2023-04-27", headers=headers, timeout=10)
+        if r.status_code != 200:
+            raise HTTPException(status_code=r.status_code, detail=r.text)
+        accounts_info = r.json()
+
+        auth_info.update({"models": models["models"]})
+        auth_info.update({"accounts_info": accounts_info})
+
+        account_ordering = accounts_info.get("account_ordering", [])
+        is_deactivated = True
+        plan_type = None
+        team_ids = []
+        for account in account_ordering:
+            this_is_deactivated = accounts_info['accounts'].get(account, {}).get("account", {}).get("is_deactivated", False)
+            this_plan_type = accounts_info['accounts'].get(account, {}).get("account", {}).get("plan_type", "free")
+
+            if not this_is_deactivated:
+                is_deactivated = False
+
+            if "team" in this_plan_type and not this_is_deactivated:
+                plan_type = this_plan_type
+                team_ids.append(account)
+            elif plan_type is None:
+                plan_type = this_plan_type
+
+        auth_info.update({"accountCheckInfo": {
+            "is_deactivated": is_deactivated,
+            "plan_type": plan_type,
+            "team_ids": team_ids
+        }})
+
+        return auth_info
+    except Exception as e:
+        logger.error(f"chatgpt_account_check: {e}")
+        return {}
+    finally:
+        await client.close()
+
+
+async def chatgpt_refresh(refresh_token):
+    client = Client(proxy=random.choice(proxy_url_list) if proxy_url_list else None)
+    try:
+        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
+        }
+        r = await client.post("https://auth0.openai.com/oauth/token", json=data, timeout=10)
+        if r.status_code != 200:
+            raise HTTPException(status_code=r.status_code, detail=r.text)
+        res = r.json()
+        auth_info = {}
+        auth_info.update(res)
+        auth_info.update({"refresh_token": refresh_token})
+        auth_info.update({"accessToken": res.get("access_token", "")})
+        return auth_info
+    except Exception as e:
+        logger.error(f"chatgpt_refresh: {e}")
+        return {}
+    finally:
+        await client.close()
+
+
+@app.post("/auth/refresh")
+async def refresh(request: Request):
+    auth_info = {}
+    form_data = await request.form()
+
+    auth_info.update(form_data)
+
+    access_token = auth_info.get("access_token", auth_info.get("accessToken", ""))
+    refresh_token = auth_info.get("refresh_token", "")
+
+    if not refresh_token and not access_token:
+        raise HTTPException(status_code=401, detail="refresh_token or access_token is required")
+
+    need_refresh = True
+    if access_token:
+        try:
+            access_token_info = jwt.decode(access_token, options={"verify_signature": False})
+            exp = access_token_info.get("exp", 0)
+            if exp > int(time.time()) + 60 * 60 * 24 * 5:
+                need_refresh = False
+        except Exception as e:
+            logger.error(f"access_token: {e}")
+
+    if refresh_token and need_refresh:
+        chatgpt_refresh_info = await chatgpt_refresh(refresh_token)
+        if chatgpt_refresh_info:
+            auth_info.update(chatgpt_refresh_info)
+            access_token = auth_info.get("accessToken", "")
+            account_check_info = await chatgpt_account_check(access_token)
+            if account_check_info:
+                auth_info.update(account_check_info)
+                auth_info.update({"accessToken": access_token})
+                return Response(content=json.dumps(auth_info), media_type="application/json")
+    elif access_token:
+        account_check_info = await chatgpt_account_check(access_token)
+        if account_check_info:
+            auth_info.update(account_check_info)
+            auth_info.update({"accessToken": access_token})
+            return Response(content=json.dumps(auth_info), media_type="application/json")
+
+    raise HTTPException(status_code=401, detail="Unauthorized")
+
+

gateway/v1.py

@@ -0,0 +1,33 @@
+import json
+
+from fastapi import Request
+from fastapi.responses import Response
+
+from app import app
+from gateway.reverseProxy import chatgpt_reverse_proxy
+from utils.kv_utils import set_value_for_key
+
+
+@app.post("/v1/initialize")
+async def initialize(request: Request):
+    initialize_response = (await chatgpt_reverse_proxy(request, f"v1/initialize"))
+    initialize_str = initialize_response.body.decode('utf-8')
+    initialize_json = json.loads(initialize_str)
+    set_value_for_key(initialize_json, "ip", "8.8.8.8")
+    set_value_for_key(initialize_json, "country", "US")
+    return Response(content=json.dumps(initialize_json, indent=4), media_type="application/json")
+
+
+@app.post("/v1/rgstr")
+async def rgstr():
+    return Response(status_code=202, content=json.dumps({"success": True}, indent=4), media_type="application/json")
+
+
+@app.get("/ces/v1/projects/oai/settings")
+async def ces_v1_projects_oai_settings():
+    return Response(status_code=200, content=json.dumps({"integrations":{"Segment.io":{"apiHost":"chatgpt.com/ces/v1","apiKey":"oai"}}}, indent=4), media_type="application/json")
+
+
+@app.post("/ces/v1/{path:path}")
+async def ces_v1():
+    return Response(status_code=202, content=json.dumps({"success": True}, indent=4), media_type="application/json")

requirements.txt

@@ -0,0 +1,13 @@
+fastapi==0.115.3
+python-multipart==0.0.13
+curl_cffi==0.7.3
+uvicorn
+tiktoken
+python-dotenv
+websockets
+pillow
+pybase64
+jinja2
+APScheduler
+ua-generator
+pyjwt

templates/chatgpt.html

@@ -0,0 +1,427 @@
+<!DOCTYPE html>
+<html data-build="prod-0749372c57dc2f5a1c6aa5f4f9802a682aebf139" dir="ltr" class="">
+    <head>
+        <meta charSet="UTF-8"/>
+        <meta name="viewport" content="width=device-width, initial-scale=1"/>
+        <link rel="preconnect" href=""/>
+        <meta name="robots" content="index, follow"/>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+        <meta name="apple-itunes-app" content="app-id=6448311069"/>
+        <link rel="apple-touch-icon" sizes="180x180" href="/assets/apple-touch-icon-mz9nytnj.webp"/>
+        <link rel="icon" type="image/png" sizes="32x32" href="/assets/favicon-32x32-p4ktpm1x.webp" media="(prefers-color-scheme: light)"/>
+        <link rel="icon" type="image/png" sizes="32x32" href="/assets/favicon-dark-32x32-gt5kfzyp.webp" media="(prefers-color-scheme: dark)"/>
+        <link rel="icon" type="image/svg+xml" sizes="32x32" href="/assets/favicon-o20kmmos.svg"/>
+        <title>ChatGPT</title>
+        <meta name="description" content="ChatGPT helps you get answers, find inspiration and be more productive. It is free to use and easy to try. Just ask and ChatGPT can help with writing, learning, brainstorming and more."/>
+        <meta name="keyword" content="ai chat,ai,chap gpt,chat gbt,chat gpt 3,chat gpt login,chat gpt website,chat gpt,chat gtp,chat openai,chat,chatai,chatbot gpt,chatg,chatgpt login,chatgpt,gpt chat,open ai,openai chat,openai chatgpt,openai"/>
+        <meta property="og:description" content="A conversational AI system that listens, learns, and challenges"/>
+        <meta property="og:title" content="ChatGPT"/>
+        <meta property="og:image" content="/assets/chatgpt-share-og-u7j5uyao.webp"/>
+        <meta property="og:url" content="https://chatgpt.com"/>
+        <link rel="modulepreload" href="/assets/manifest-de1f64fe.js"/>
+        <link rel="modulepreload" href="/assets/dpwaaxblirg4r8ba.js"/>
+        <link rel="modulepreload" href="/assets/lklglvrzltpv3f05.js"/>
+        <link rel="modulepreload" href="/assets/cvnnwrmw3zqz8rlo.js"/>
+        <link rel="modulepreload" href="/assets/ltrr4mhf6s4m7a72.js"/>
+        <link rel="modulepreload" href="/assets/olbhxi7cvw9yat6w.js"/>
+        <link rel="modulepreload" href="/assets/myjrgpm0gs628bnj.js"/>
+        <link rel="modulepreload" href="/assets/ntw4l0fkgqdiln85.js"/>
+        <link rel="modulepreload" href="/assets/kqs0d9q6go77jiiq.js"/>
+        <link rel="modulepreload" href="/assets/gruuolgwd1up46vp.js"/>
+        <link rel="modulepreload" href="/assets/hzzlkn5ny7a6v61q.js"/>
+        <link rel="modulepreload" href="/assets/jebvbwlsp750x4d4.js"/>
+        <link rel="modulepreload" href="/assets/m9aklkujr89s52e5.js"/>
+        <link rel="modulepreload" href="/assets/p8eg3euad9gvin3k.js"/>
+        <link rel="modulepreload" href="/assets/emuaj61pmpol8zzg.js"/>
+        <link rel="modulepreload" href="/assets/m5cd4p680vhusvsg.js"/>
+        <link rel="modulepreload" href="/assets/dz00r7qlzgek59uu.js"/>
+        <link rel="modulepreload" href="/assets/bwsmtgh34vk8igjb.js"/>
+        <link rel="modulepreload" href="/assets/vyarha3ckzwu9yf1.js"/>
+        <link rel="modulepreload" href="/assets/lnovrxcizvfadwta.js"/>
+        <link rel="modulepreload" href="/assets/n7xaphlc0h5m9xjk.js"/>
+        <link rel="modulepreload" href="/assets/lweu58rz02vpanvm.js"/>
+        <link rel="modulepreload" href="/assets/hags0lzrfk4kk50a.js"/>
+        <link rel="modulepreload" href="/assets/i9ntb1zjwbcuz2uj.js"/>
+        <link rel="modulepreload" href="/assets/c84k0nbcah46qpzd.js"/>
+        <link rel="modulepreload" href="/assets/jor8b61nis2ex9lk.js"/>
+        <link rel="modulepreload" href="/assets/jjr9on9cxlrbskjq.js"/>
+        <link rel="stylesheet" href="/assets/root-bh5spu2n.css"/>
+        <link rel="stylesheet" href="/assets/conversation-small-iybhw0ps.css"/>
+    </head>
+    <body class="">
+        <script>
+            !function() {
+                try {
+                    var d = document.documentElement
+                      , c = d.classList;
+                    c.remove('light', 'dark');
+                    var e = localStorage.getItem('theme');
+                    if ('system' === e || (!e && true)) {
+                        var t = '(prefers-color-scheme: dark)'
+                          , m = window.matchMedia(t);
+                        if (m.media !== t || m.matches) {
+                            d.style.colorScheme = 'dark';
+                            c.add('dark')
+                        } else {
+                            d.style.colorScheme = 'light';
+                            c.add('light')
+                        }
+                    } else if (e) {
+                        c.add(e || '')
+                    }
+                    if (e === 'light' || e === 'dark')
+                        d.style.colorScheme = e
+                } catch (e) {}
+            }()
+        </script>
+        <div class="relative flex h-full w-full overflow-hidden transition-colors z-0">
+            <div class="z-[21] flex-shrink-0 overflow-x-hidden bg-token-sidebar-surface-primary max-md:!w-0" style="width:260px">
+                <div class="h-full w-[260px]">
+                    <div class="flex h-full min-h-0 flex-col">
+                        <div class="draggable relative h-full w-full flex-1 items-start border-white/20">
+                            <h2 style="position:absolute;border:0;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0, 0, 0, 0);white-space:nowrap;word-wrap:normal">Chat history</h2>
+                            <nav class="flex h-full w-full flex-col px-3" aria-label="Chat history">
+                                <div class="flex justify-between flex h-[60px] items-center md:h-header-height">
+                                    <span class="hidden"></span>
+                                    <span class="flex" data-state="closed">
+                                        <button aria-label="Close sidebar" data-testid="close-sidebar-button" class="h-10 rounded-lg px-2 text-token-text-secondary focus-visible:outline-0 disabled:text-token-text-quaternary focus-visible:bg-token-sidebar-surface-secondary enabled:hover:bg-token-sidebar-surface-secondary no-draggable">
+                                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" class="icon-xl-heavy max-md:hidden">
+                                                <path fill-rule="evenodd" clip-rule="evenodd" d="M8.85719 3H15.1428C16.2266 2.99999 17.1007 2.99998 17.8086 3.05782C18.5375 3.11737 19.1777 3.24318 19.77 3.54497C20.7108 4.02433 21.4757 4.78924 21.955 5.73005C22.2568 6.32234 22.3826 6.96253 22.4422 7.69138C22.5 8.39925 22.5 9.27339 22.5 10.3572V13.6428C22.5 14.7266 22.5 15.6008 22.4422 16.3086C22.3826 17.0375 22.2568 17.6777 21.955 18.27C21.4757 19.2108 20.7108 19.9757 19.77 20.455C19.1777 20.7568 18.5375 20.8826 17.8086 20.9422C17.1008 21 16.2266 21 15.1428 21H8.85717C7.77339 21 6.89925 21 6.19138 20.9422C5.46253 20.8826 4.82234 20.7568 4.23005 20.455C3.28924 19.9757 2.52433 19.2108 2.04497 18.27C1.74318 17.6777 1.61737 17.0375 1.55782 16.3086C1.49998 15.6007 1.49999 14.7266 1.5 13.6428V10.3572C1.49999 9.27341 1.49998 8.39926 1.55782 7.69138C1.61737 6.96253 1.74318 6.32234 2.04497 5.73005C2.52433 4.78924 3.28924 4.02433 4.23005 3.54497C4.82234 3.24318 5.46253 3.11737 6.19138 3.05782C6.89926 2.99998 7.77341 2.99999 8.85719 3ZM6.35424 5.05118C5.74907 5.10062 5.40138 5.19279 5.13803 5.32698C4.57354 5.6146 4.1146 6.07354 3.82698 6.63803C3.69279 6.90138 3.60062 7.24907 3.55118 7.85424C3.50078 8.47108 3.5 9.26339 3.5 10.4V13.6C3.5 14.7366 3.50078 15.5289 3.55118 16.1458C3.60062 16.7509 3.69279 17.0986 3.82698 17.362C4.1146 17.9265 4.57354 18.3854 5.13803 18.673C5.40138 18.8072 5.74907 18.8994 6.35424 18.9488C6.97108 18.9992 7.76339 19 8.9 19H9.5V5H8.9C7.76339 5 6.97108 5.00078 6.35424 5.05118ZM11.5 5V19H15.1C16.2366 19 17.0289 18.9992 17.6458 18.9488C18.2509 18.8994 18.5986 18.8072 18.862 18.673C19.4265 18.3854 19.8854 17.9265 20.173 17.362C20.3072 17.0986 20.3994 16.7509 20.4488 16.1458C20.4992 15.5289 20.5 14.7366 20.5 13.6V10.4C20.5 9.26339 20.4992 8.47108 20.4488 7.85424C20.3994 7.24907 20.3072 6.90138 20.173 6.63803C19.8854 6.07354 19.4265 5.6146 18.862 5.32698C18.5986 5.19279 18.2509 5.10062 17.6458 5.05118C17.0289 5.00078 16.2366 5 15.1 5H11.5ZM5 8.5C5 7.94772 5.44772 7.5 6 7.5H7C7.55229 7.5 8 7.94772 8 8.5C8 9.05229 7.55229 9.5 7 9.5H6C5.44772 9.5 5 9.05229 5 8.5ZM5 12C5 11.4477 5.44772 11 6 11H7C7.55229 11 8 11.4477 8 12C8 12.5523 7.55229 13 7 13H6C5.44772 13 5 12.5523 5 12Z" fill="currentColor"></path>
+                                            </svg>
+                                            <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg" class="icon-xl-heavy md:hidden">
+                                                <path fill-rule="evenodd" clip-rule="evenodd" d="M3 8C3 7.44772 3.44772 7 4 7H20C20.5523 7 21 7.44772 21 8C21 8.55228 20.5523 9 20 9H4C3.44772 9 3 8.55228 3 8ZM3 16C3 15.4477 3.44772 15 4 15H14C14.5523 15 15 15.4477 15 16C15 16.5523 14.5523 17 14 17H4C3.44772 17 3 16.5523 3 16Z" fill="currentColor"></path>
+                                            </svg>
+                                        </button>
+                                    </span>
+                                    <div class="flex">
+                                        <span class="hidden"></span>
+                                        <span class="flex" data-state="closed">
+                                            <button aria-label="New chat" data-testid="create-new-chat-button" class="h-10 rounded-lg px-2 text-token-text-secondary focus-visible:outline-0 disabled:text-token-text-quaternary focus-visible:bg-token-sidebar-surface-secondary enabled:hover:bg-token-sidebar-surface-secondary">
+                                                <svg width="24" height="24" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg" class="icon-xl-heavy">
+                                                    <path d="M15.6729 3.91287C16.8918 2.69392 18.8682 2.69392 20.0871 3.91287C21.3061 5.13182 21.3061 7.10813 20.0871 8.32708L14.1499 14.2643C13.3849 15.0293 12.3925 15.5255 11.3215 15.6785L9.14142 15.9899C8.82983 16.0344 8.51546 15.9297 8.29289 15.7071C8.07033 15.4845 7.96554 15.1701 8.01005 14.8586L8.32149 12.6785C8.47449 11.6075 8.97072 10.615 9.7357 9.85006L15.6729 3.91287ZM18.6729 5.32708C18.235 4.88918 17.525 4.88918 17.0871 5.32708L11.1499 11.2643C10.6909 11.7233 10.3932 12.3187 10.3014 12.9613L10.1785 13.8215L11.0386 13.6986C11.6812 13.6068 12.2767 13.3091 12.7357 12.8501L18.6729 6.91287C19.1108 6.47497 19.1108 5.76499 18.6729 5.32708ZM11 3.99929C11.0004 4.55157 10.5531 4.99963 10.0008 5.00007C9.00227 5.00084 8.29769 5.00827 7.74651 5.06064C7.20685 5.11191 6.88488 5.20117 6.63803 5.32695C6.07354 5.61457 5.6146 6.07351 5.32698 6.63799C5.19279 6.90135 5.10062 7.24904 5.05118 7.8542C5.00078 8.47105 5 9.26336 5 10.4V13.6C5 14.7366 5.00078 15.5289 5.05118 16.1457C5.10062 16.7509 5.19279 17.0986 5.32698 17.3619C5.6146 17.9264 6.07354 18.3854 6.63803 18.673C6.90138 18.8072 7.24907 18.8993 7.85424 18.9488C8.47108 18.9992 9.26339 19 10.4 19H13.6C14.7366 19 15.5289 18.9992 16.1458 18.9488C16.7509 18.8993 17.0986 18.8072 17.362 18.673C17.9265 18.3854 18.3854 17.9264 18.673 17.3619C18.7988 17.1151 18.8881 16.7931 18.9393 16.2535C18.9917 15.7023 18.9991 14.9977 18.9999 13.9992C19.0003 13.4469 19.4484 12.9995 20.0007 13C20.553 13.0004 21.0003 13.4485 20.9999 14.0007C20.9991 14.9789 20.9932 15.7808 20.9304 16.4426C20.8664 17.116 20.7385 17.7136 20.455 18.2699C19.9757 19.2107 19.2108 19.9756 18.27 20.455C17.6777 20.7568 17.0375 20.8826 16.3086 20.9421C15.6008 21 14.7266 21 13.6428 21H10.3572C9.27339 21 8.39925 21 7.69138 20.9421C6.96253 20.8826 6.32234 20.7568 5.73005 20.455C4.78924 19.9756 4.02433 19.2107 3.54497 18.2699C3.24318 17.6776 3.11737 17.0374 3.05782 16.3086C2.99998 15.6007 2.99999 14.7266 3 13.6428V10.3572C2.99999 9.27337 2.99998 8.39922 3.05782 7.69134C3.11737 6.96249 3.24318 6.3223 3.54497 5.73001C4.02433 4.7892 4.78924 4.0243 5.73005 3.54493C6.28633 3.26149 6.88399 3.13358 7.55735 3.06961C8.21919 3.00673 9.02103 3.00083 9.99922 3.00007C10.5515 2.99964 10.9996 3.447 11 3.99929Z" fill="currentColor"></path>
+                                                </svg>
+                                            </button>
+                                        </span>
+                                    </div>
+                                </div>
+                                <div class="flex-col flex-1 transition-opacity duration-500 relative -mr-2 pr-2 overflow-y-auto">
+                                    <div class="group/sidebar">
+                                        <div class="flex flex-col gap-2 text-token-text-primary text-sm h-full justify-center items-center empty:hidden mt-5 pb-2"></div>
+                                    </div>
+                                </div>
+                            </nav>
+                        </div>
+                    </div>
+                </div>
+            </div>
+            <div class="relative flex h-full max-w-full flex-1 flex-col overflow-hidden">
+                <main class="relative h-full w-full flex-1 overflow-auto transition-width">
+                    <div role="presentation" class="composer-parent flex h-full flex-col focus-visible:outline-0">
+                        <div class="flex-1 overflow-hidden @container/thread">
+                            <div class="relative h-full">
+                                <div class="absolute left-0 right-0">
+                                    <div class="draggable no-draggable-children sticky top-0 p-3 mb-1.5 flex items-center justify-between z-10 h-header-height font-semibold bg-token-main-surface-primary max-md:hidden">
+                                        <div class="absolute start-1/2 ltr:-translate-x-1/2 rtl:translate-x-1/2"></div>
+                                        <div class="flex items-center gap-0 overflow-hidden"></div>
+                                        <div class="gap-2 flex items-center pr-1 leading-[0]"></div>
+                                    </div>
+                                </div>
+                                <div class="flex h-full flex-col items-center justify-center text-token-text-primary">
+                                    <div class="h-full w-full lg:py-[18px]">
+                                        <div class="m-auto text-base px-3 md:px-4 w-full md:px-5 lg:px-4 xl:px-5 h-full">
+                                            <div class="mx-auto flex h-full w-full flex-col text-base lg:justify-center md:max-w-3xl lg:max-w-[40rem] xl:max-w-[48rem]">
+                                                <div class="mb-7 hidden text-center lg:block">
+                                                    <div class="relative inline-flex justify-center text-center text-2xl font-semibold leading-9">
+                                                        <h1 style="view-transition-name:var(--vt-splash-screen-headline)">What can I help with?</h1>
+                                                    </div>
+                                                </div>
+                                                <div class="justify-center mt-[var(--screen-optical-compact-offset-amount)] flex h-full flex-shrink flex-col items-center overflow-hidden text-token-text-primary lg:hidden" style="opacity:0;will-change:opacity">
+                                                    <div class="relative inline-flex justify-center text-center text-2xl font-semibold leading-9">
+                                                        <h1 style="view-transition-name:var(--vt-splash-screen-headline)">What can I help with?</h1>
+                                                    </div>
+                                                    <div class="h-[116px]" style="opacity:0;will-change:opacity"></div>
+                                                </div>
+                                                <div class="lg:absolute lg:bottom-8 lg:left-0 lg:w-full">
+                                                    <div class="mx-auto flex h-full w-full flex-col text-base lg:justify-center md:max-w-3xl lg:max-w-[40rem] xl:max-w-[48rem]">
+                                                        <div class="block z-20"></div>
+                                                    </div>
+                                                </div>
+                                                <div class="w-full">
+                                                    <div class="flex justify-center"></div>
+                                                    <form class="w-full" type="button" aria-haspopup="dialog" aria-expanded="false" aria-controls="radix-:R7nkkuiiklj5:" data-state="closed">
+                                                        <div class="relative flex h-full max-w-full flex-1 flex-col">
+                                                            <div class="group relative flex w-full items-center">
+                                                                <div class="w-full">
+                                                                    <div id="composer-background" class="flex w-full cursor-text flex-col rounded-3xl px-2.5 py-1 transition-colors contain-inline-size bg-[#f4f4f4] dark:bg-token-main-surface-secondary" style="view-transition-name:var(--vt-composer)">
+                                                                        <div class="flex min-h-[44px] items-start pl-2">
+                                                                            <div class="min-w-0 max-w-full flex-1">
+                                                                                <div class="_prosemirror-parent_cy42l_1 text-token-text-primary max-h-[25dvh] max-h-52 overflow-auto default-browser">
+                                                                                    <textarea class="block h-10 w-full resize-none border-0 bg-transparent px-0 py-2 text-token-text-primary placeholder:text-token-text-secondary" autofocus="" placeholder="Message ChatGPT" data-virtualkeyboard="true"></textarea>
+                                                                                    <script nonce="c506c601-cf42-4631-ad36-4d3389e68112">
+                                                                                        window.__oai_logHTML ? window.__oai_logHTML() : window.__oai_SSR_HTML = window.__oai_SSR_HTML || Date.now();
+                                                                                        requestAnimationFrame((function() {
+                                                                                            window.__oai_logTTI ? window.__oai_logTTI() : window.__oai_SSR_TTI = window.__oai_SSR_TTI || Date.now()
+                                                                                        }
+                                                                                        ))
+                                                                                    </script>
+                                                                                </div>
+                                                                            </div>
+                                                                            <div class="w-[32px] pt-1"></div>
+                                                                        </div>
+                                                                        <div class="flex h-[44px] items-center justify-between">
+                                                                            <div class="flex gap-x-1">
+                                                                                <div style="view-transition-name:var(--vt-composer-attach-file-action)">
+                                                                                    <div class="relative">
+                                                                                        <div class="relative">
+                                                                                            <span class="hidden"></span>
+                                                                                            <span class="flex" data-state="closed">
+                                                                                                <div class="flex">
+                                                                                                    <button disabled="" aria-label="Attach files is unavailable" class="flex items-center justify-center h-8 w-8 rounded-lg rounded-bl-xl text-token-text-primary dark:text-white focus-visible:outline-black dark:focus-visible:outline-white opacity-30">
+                                                                                                        <svg width="24" height="24" viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg">
+                                                                                                            <path fill-rule="evenodd" clip-rule="evenodd" d="M9 7C9 4.23858 11.2386 2 14 2C16.7614 2 19 4.23858 19 7V15C19 18.866 15.866 22 12 22C8.13401 22 5 18.866 5 15V9C5 8.44772 5.44772 8 6 8C6.55228 8 7 8.44772 7 9V15C7 17.7614 9.23858 20 12 20C14.7614 20 17 17.7614 17 15V7C17 5.34315 15.6569 4 14 4C12.3431 4 11 5.34315 11 7V15C11 15.5523 11.4477 16 12 16C12.5523 16 13 15.5523 13 15V9C13 8.44772 13.4477 8 14 8C14.5523 8 15 8.44772 15 9V15C15 16.6569 13.6569 18 12 18C10.3431 18 9 16.6569 9 15V7Z" fill="currentColor"></path>
+                                                                                                        </svg>
+                                                                                                    </button>
+                                                                                                    <input disabled="" multiple="" type="file" style="display:none" tabindex="-1" class="hidden"/>
+                                                                                                </div>
+                                                                                            </span>
+                                                                                        </div>
+                                                                                    </div>
+                                                                                </div>
+                                                                            </div>
+                                                                            <div class="min-w-8">
+                                                                                <span class="hidden"></span>
+                                                                                <span class="" data-state="closed">
+                                                                                    <button disabled="" aria-label="Send prompt" data-testid="send-button" class="flex h-8 w-8 items-center justify-center rounded-full transition-colors hover:opacity-70 focus-visible:outline-none focus-visible:outline-black disabled:text-[#f4f4f4] disabled:hover:opacity-100 dark:focus-visible:outline-white disabled:dark:bg-token-text-quaternary dark:disabled:text-token-main-surface-secondary bg-black text-white dark:bg-white dark:text-black disabled:bg-[#D7D7D7]">
+                                                                                        <svg width="32" height="32" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg" class="icon-2xl">
+                                                                                            <path fill-rule="evenodd" clip-rule="evenodd" d="M15.1918 8.90615C15.6381 8.45983 16.3618 8.45983 16.8081 8.90615L21.9509 14.049C22.3972 14.4953 22.3972 15.2189 21.9509 15.6652C21.5046 16.1116 20.781 16.1116 20.3347 15.6652L17.1428 12.4734V22.2857C17.1428 22.9169 16.6311 23.4286 15.9999 23.4286C15.3688 23.4286 14.8571 22.9169 14.8571 22.2857V12.4734L11.6652 15.6652C11.2189 16.1116 10.4953 16.1116 10.049 15.6652C9.60265 15.2189 9.60265 14.4953 10.049 14.049L15.1918 8.90615Z" fill="currentColor"></path>
+                                                                                        </svg>
+                                                                                    </button>
+                                                                                </span>
+                                                                            </div>
+                                                                        </div>
+                                                                    </div>
+                                                                </div>
+                                                            </div>
+                                                        </div>
+                                                    </form>
+                                                </div>
+                                                <div class="hidden lg:block h-[70px]" style="opacity:0;will-change:opacity"></div>
+                                                <div class="w-full px-2 py-2 text-center text-xs text-token-text-secondary empty:hidden md:px-[60px] lg:absolute lg:bottom-0 lg:left-0">
+                                                    <div class="min-h-4">
+                                                        <div>ChatGPT can make mistakes. Check important info.</div>
+                                                    </div>
+                                                </div>
+                                            </div>
+                                        </div>
+                                    </div>
+                                </div>
+                            </div>
+                        </div>
+                        <div class="md:pt-0 dark:border-white/20 md:border-transparent md:dark:border-transparent w-full">
+                            <div>
+                                <div class="relative w-full px-2 py-2 text-center text-xs text-token-text-secondary empty:hidden md:px-[60px]"></div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="group absolute bottom-2 end-2 z-20 flex flex-col gap-1 md:flex lg:bottom-3 lg:end-3">
+                        <button class="flex h-6 w-6 items-center justify-center rounded-full border border-token-border-light text-xs text-token-text-secondary" type="button" id="radix-:R9eiiklj5:" aria-haspopup="menu" aria-expanded="false" data-state="closed" data-testid="undefined-button">?</button>
+                    </div>
+                </main>
+            </div>
+        </div>
+        <div aria-live="assertive" aria-atomic="true" class="sr-only"></div>
+        <div aria-live="polite" aria-atomic="true" class="sr-only"></div>
+        <audio class="fixed bottom-0 left-0 hidden h-0 w-0" autoPlay="" crossorigin="anonymous"></audio>
+        <script nonce="c506c601-cf42-4631-ad36-4d3389e68112">
+            window.__remixContext = {{ remix_context|tojson }};
+            __remixContext.p = function(v, e, p, x) {
+                if (typeof e !== 'undefined') {
+                    x = new Error("Unexpected Server Error");
+                    x.stack = undefined;
+                    p = Promise.reject(x);
+                } else {
+                    p = Promise.resolve(v);
+                }
+                return p;
+            }
+            ;
+            __remixContext.n = function(i, k) {
+                __remixContext.t = __remixContext.t || {};
+                __remixContext.t[i] = __remixContext.t[i] || {};
+                let p = new Promise( (r, e) => {
+                    __remixContext.t[i][k] = {
+                        r: (v) => {
+                            r(v);
+                        }
+                        ,
+                        e: (v) => {
+                            e(v);
+                        }
+                    };
+                }
+                );
+                setTimeout( () => {
+                    if (typeof p._error !== "undefined" || typeof p._data !== "undefined") {
+                        return;
+                    }
+                    __remixContext.t[i][k].e(new Error("Server timeout."))
+                }
+                , 5000);
+                return p;
+            }
+            ;
+            __remixContext.r = function(i, k, v, e, p, x) {
+                p = __remixContext.t[i][k];
+                if (typeof e !== 'undefined') {
+                    x = new Error("Unexpected Server Error");
+                    x.stack = undefined;
+                    p.e(x);
+                } else {
+                    p.r(v);
+                }
+            }
+            ;
+            Object.assign(__remixContext.state.loaderData["root"], {
+                "rq:[\"account-status\"]": __remixContext.n("root", "rq:[\"account-status\"]")
+            });
+            Object.assign(__remixContext.state.loaderData["routes/_conversation"], {});
+            __remixContext.a = 1;
+        </script>
+        <script nonce="c506c601-cf42-4631-ad36-4d3389e68112" type="module" async="">
+            import "/assets/manifest-de1f64fe.js";
+            import*as route0 from "/assets/olbhxi7cvw9yat6w.js";
+            import*as route1 from "/assets/jor8b61nis2ex9lk.js";
+            import*as route2 from "/assets/jjr9on9cxlrbskjq.js";
+
+            window.__remixRouteModules = {
+                "root": route0,
+                "routes/_conversation": route1,
+                "routes/_conversation._index": route2
+            };
+
+            import("/assets/dpwaaxblirg4r8ba.js");
+        </script>
+        <!--$?-->
+        <template id="B:0"></template>
+        <!--/$-->
+        <div hidden id="S:0">
+            <script nonce="c506c601-cf42-4631-ad36-4d3389e68112" async="">
+                __remixContext.r("root", "rq:[\"account-status\"]", {
+                    "__type": "AccountState",
+                    "accountItems": [{
+                        "data": {
+                            "id": "chatgpt",
+                            "residencyRegion": "no_constraint",
+                            "accountUserId": "user-chatgpt__chatgpt",
+                            "name": null,
+                            "profilePictureId": null,
+                            "profilePictureUrl": null,
+                            "structure": "personal",
+                            "role": "account-owner",
+                            "organizationId": null,
+                            "promoData": {},
+                            "deactivated": false,
+                            "subscriptionStatus": {
+                                "billingPeriod": "yearly",
+                                "hasPaidSubscription": true,
+                                "isActiveSubscriptionGratis": false,
+                                "subscriptionPlan": "chatgptpro",
+                                "planType": "pro",
+                                "subscriptionExpiresAt": 2524579200,
+                                "wasPaidCustomer": true,
+                                "hasCustomerObject": true,
+                                "lastActiveSubscription": {
+                                    "subscription_id": "chatgpt",
+                                    "purchase_origin_platform": "chatgpt_web",
+                                    "will_renew": true
+                                },
+                                "isResellerHosted": false
+                            },
+                            "features": ["beta_features", "bizmo_settings", "breeze_available", "browsing_available", "canvas", "canvas_code_execution", "canvas_opt_in", "chart_serialization", "chat_preferences_available", "chatgpt_ios_attest", "code_interpreter_available", "d3_controls", "d3_editor", "d3_editor_gpts", "dalle_3", "gizmo_canvas_toggle", "gizmo_reviews", "gizmo_support_emails", "graphite", "mfa", "model_ab_use_v2", "model_switcher", "new_plugin_oauth_endpoint", "no_auth_training_enabled_by_default", "o1_launch", "o1_pro_launch", "paragen_mainline_alternative", "plugins_available", "privacy_policy_nov_2023", "search_tool", "sentinel_enabled_for_subscription", "share_multimodal_links", "shareable_links", "starter_prompts", "sunshine_available", "user_settings_announcements", "voice_advanced_ga"],
+                            "canAccessWithCurrentSession": true,
+                            "ssoConnectionName": null
+                        }
+                    }],
+                    "currentAccountId": "chatgpt"
+                })
+            </script>
+        </div>
+        <script nonce="c506c601-cf42-4631-ad36-4d3389e68112">
+            $RC = function(b, c, e) {
+                c = document.getElementById(c);
+                c.parentNode.removeChild(c);
+                var a = document.getElementById(b);
+                if (a) {
+                    b = a.previousSibling;
+                    if (e)
+                        b.data = "$!",
+                        a.setAttribute("data-dgst", e);
+                    else {
+                        e = b.parentNode;
+                        a = b.nextSibling;
+                        var f = 0;
+                        do {
+                            if (a && 8 === a.nodeType) {
+                                var d = a.data;
+                                if ("/$" === d)
+                                    if (0 === f)
+                                        break;
+                                    else
+                                        f--;
+                                else
+                                    "$" !== d && "$?" !== d && "$!" !== d || f++
+                            }
+                            d = a.nextSibling;
+                            e.removeChild(a);
+                            a = d
+                        } while (a);
+                        for (; c.firstChild; )
+                            e.insertBefore(c.firstChild, a);
+                        b.data = "$"
+                    }
+                    b._reactRetry && b._reactRetry()
+                }
+            }
+            ;
+            $RC("B:0", "S:0")
+        </script>
+        <script nonce="c506c601-cf42-4631-ad36-4d3389e68112">
+            (function() {
+                function c() {
+                    var b = a.contentDocument || a.contentWindow.document;
+                    if (b) {
+                        var d = b.createElement('script');
+                        d.nonce = 'c506c601-cf42-4631-ad36-4d3389e68112';
+                        d.innerHTML = "window.__CF$cv$params={r:'8f95012aa8b767e2',t:'MTczNTQyNTEyOC4wMDAwMDA='};var a=document.createElement('script');a.nonce='c506c601-cf42-4631-ad36-4d3389e68112';a.src='/cdn-cgi/challenge-platform/scripts/jsd/main.js';document.getElementsByTagName('head')[0].appendChild(a);";
+                        b.getElementsByTagName('head')[0].appendChild(d)
+                    }
+                }
+                if (document.body) {
+                    var a = document.createElement('iframe');
+                    a.height = 1;
+                    a.width = 1;
+                    a.style.position = 'absolute';
+                    a.style.top = 0;
+                    a.style.left = 0;
+                    a.style.border = 'none';
+                    a.style.visibility = 'hidden';
+                    document.body.appendChild(a);
+                    if ('loading' !== document.readyState)
+                        c();
+                    else if (window.addEventListener)
+                        document.addEventListener('DOMContentLoaded', c);
+                    else {
+                        var e = document.onreadystatechange || function() {}
+                        ;
+                        document.onreadystatechange = function(b) {
+                            e(b);
+                            'loading' !== document.readyState && (document.onreadystatechange = e,
+                            c())
+                        }
+                    }
+                }
+            }
+            )();
+        </script>
+    </body>
+</html>

templates/login.html

@@ -0,0 +1,82 @@
+<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>登录</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <style>
+        #popup {
+            display: none;
+        }
+    </style>
+</head>
+<body class="bg-gradient-to-br from-blue-300 via-indigo-300 to-purple-400 min-h-screen flex items-center justify-center">
+    <div class="bg-white p-8 rounded-xl shadow-2xl w-96 max-w-md">
+        <h2 class="text-3xl font-bold text-center text-gray-800 mb-4">登录</h2>
+        <button
+            type="button"
+            onclick="openPopup()"
+            class="w-full bg-gradient-to-r from-indigo-500 to-blue-500 text-white font-bold py-3 px-4 rounded-lg hover:opacity-90 transition duration-200 ease-in-out"
+        >
+            RefreshToken / AccessToken
+        </button>
+        <p class="text-xs text-gray-500 text-center mt-4">
+            <span class="font-semibold text-gray-800">非
+                <span class="font-bold text-indigo-600">RT</span>
+                与
+                <span class="font-bold text-indigo-600">AT</span>
+                的输入，将作为</span>
+            <span class="font-bold text-indigo-600">Seed</span>
+            <span class="font-semibold text-gray-800">随机抽取后台账号</span>
+        </p>
+    </div>
+
+    <div id="popup" class="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center">
+        <div class="bg-white p-8 rounded-xl shadow-lg max-w-lg w-full h-auto">
+<!--            <h3 class="text-xl font-bold text-gray-800 mb-4 text-center">请输入您的 Token</h3>-->
+            <p class="font-semibold text-gray-800 text-center mb-1">直接点击
+                <span class="font-bold text-indigo-600">开始</span>
+                进入最近用过的账号</p>
+            <label for="popup-input"></label>
+            <textarea
+                id="popup-input"
+                name="token"
+                placeholder="RefreshToken / AccessToken / SeedToken"
+                class="w-full h-56 px-4 py-4 text-md rounded-md bg-gray-100 border-gray-300 focus:border-indigo-500 focus:bg-white focus:ring-2 focus:ring-indigo-200 text-gray-800 transition duration-200 ease-in-out mb-4"
+                style="resize: none;"
+            ></textarea>
+            <div class="flex justify-center space-x-4">
+                <button
+                    onclick="submitToken()"
+                    class="bg-indigo-500 hover:bg-indigo-600 text-white font-bold py-2 px-4 rounded-lg transition duration-200 ease-in-out"
+                >
+                    开 始
+                </button>
+                <button
+                    onclick="closePopup()"
+                    class="bg-gray-300 hover:bg-gray-400 text-gray-800 font-bold py-2 px-4 rounded-lg transition duration-200 ease-in-out"
+                >
+                    取 消
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        function openPopup() {
+            document.getElementById('popup').style.display = 'flex';
+        }
+
+        function closePopup() {
+            document.getElementById('popup').style.display = 'none';
+        }
+
+        function submitToken() {
+            var inputValue = document.getElementById('popup-input').value;
+            window.location.href = '/?token=' + inputValue;
+            closePopup();
+        }
+    </script>
+</body>
+</html>

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,56 @@
+import random
+
+from curl_cffi.requests import AsyncSession
+
+
+class Client:
+    def __init__(self, proxy=None, timeout=15, verify=True, impersonate='safari15_3'):
+        self.proxies = {"http": proxy, "https": proxy}
+        self.timeout = timeout
+        self.verify = verify
+
+        self.impersonate = impersonate
+        # impersonate=self.impersonate
+
+        # self.ja3 = ""
+        # self.akamai = ""
+        # ja3=self.ja3, akamai=self.akamai
+        self.session = AsyncSession(proxies=self.proxies, timeout=self.timeout, impersonate=self.impersonate, verify=self.verify)
+        self.session2 = AsyncSession(proxies=self.proxies, timeout=self.timeout, impersonate=self.impersonate, verify=self.verify)
+
+    async def post(self, *args, **kwargs):
+        r = await self.session.post(*args, **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, **kwargs)
+        return r
+
+    async def get(self, *args, **kwargs):
+        r = await self.session.get(*args, **kwargs)
+        return r
+
+    async def request(self, *args, **kwargs):
+        r = await self.session.request(*args, **kwargs)
+        return r
+
+    async def put(self, *args, **kwargs):
+        r = await self.session.put(*args, **kwargs)
+        return r
+
+    async def close(self):
+        if hasattr(self, 'session'):
+            try:
+                await self.session.close()
+                del self.session
+            except Exception:
+                pass
+        if hasattr(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/configs.py

@@ -0,0 +1,106 @@
+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)
+x_sign = os.getenv('X_SIGN', None)
+
+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(' ', '')
+sentinel_proxy_url = os.getenv('SENTINEL_PROXY_URL', None)
+export_proxy_url = os.getenv('EXPORT_PROXY_URL', None)
+file_host = os.getenv('FILE_HOST', None)
+voice_host = os.getenv('VOICE_HOST', None)
+impersonate_list_str = os.getenv('IMPERSONATE', '[]')
+user_agents_list_str = os.getenv('USER_AGENTS', '[]')
+device_tuple_str = os.getenv('DEVICE_TUPLE', '()')
+browser_tuple_str = os.getenv('BROWSER_TUPLE', '()')
+platform_tuple_str = os.getenv('PLATFORM_TUPLE', '()')
+
+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))
+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))
+random_token = is_true(os.getenv('RANDOM_TOKEN', True))
+oai_language = os.getenv('OAI_LANGUAGE', 'zh-CN')
+
+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 []
+sentinel_proxy_url_list = sentinel_proxy_url.split(',') if sentinel_proxy_url else []
+impersonate_list = ast.literal_eval(impersonate_list_str)
+user_agents_list = ast.literal_eval(user_agents_list_str)
+device_tuple = ast.literal_eval(device_tuple_str)
+browser_tuple = ast.literal_eval(browser_tuple_str)
+platform_tuple = ast.literal_eval(platform_tuple_str)
+
+enable_gateway = is_true(os.getenv('ENABLE_GATEWAY', False))
+auto_seed = is_true(os.getenv('AUTO_SEED', True))
+force_no_history = is_true(os.getenv('FORCE_NO_HISTORY', False))
+no_sentinel = is_true(os.getenv('NO_SENTINEL', False))
+
+with open('version.txt') as f:
+    version = f.read().strip()
+
+logger.info("-" * 60)
+logger.info(f"Chat2Api {version} | https://github.com/lanqian528/chat2api")
+logger.info("-" * 60)
+logger.info("Environment variables:")
+logger.info("------------------------- Security -------------------------")
+logger.info("API_PREFIX:        " + str(api_prefix))
+logger.info("AUTHORIZATION:     " + str(authorization_list))
+logger.info("AUTH_KEY:          " + str(auth_key))
+logger.info("------------------------- Request --------------------------")
+logger.info("CHATGPT_BASE_URL:  " + str(chatgpt_base_url_list))
+logger.info("PROXY_URL:         " + str(proxy_url_list))
+logger.info("EXPORT_PROXY_URL:  " + str(export_proxy_url))
+logger.info("FILE_HOST:     " + str(file_host))
+logger.info("VOICE_HOST:    " + str(voice_host))
+logger.info("IMPERSONATE:       " + str(impersonate_list))
+logger.info("USER_AGENTS:       " + str(user_agents_list))
+logger.info("---------------------- Functionality -----------------------")
+logger.info("HISTORY_DISABLED:  " + str(history_disabled))
+logger.info("POW_DIFFICULTY:    " + str(pow_difficulty))
+logger.info("RETRY_TIMES:       " + str(retry_times))
+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("RANDOM_TOKEN:      " + str(random_token))
+logger.info("OAI_LANGUAGE:      " + str(oai_language))
+logger.info("------------------------- Gateway --------------------------")
+logger.info("ENABLE_GATEWAY:    " + str(enable_gateway))
+logger.info("AUTO_SEED:         " + str(auto_seed))
+logger.info("FORCE_NO_HISTORY: " + str(force_no_history))
+logger.info("-" * 60)

utils/globals.py

@@ -0,0 +1,107 @@
+import json
+import os
+
+import utils.configs as configs
+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")
+FP_FILE = os.path.join(DATA_FOLDER, "fp_map.json")
+SEED_MAP_FILE = os.path.join(DATA_FOLDER, "seed_map.json")
+CONVERSATION_MAP_FILE = os.path.join(DATA_FOLDER, "conversation_map.json")
+
+count = 0
+token_list = []
+error_token_list = []
+refresh_map = {}
+wss_map = {}
+fp_map = {}
+seed_map = {}
+conversation_map = {}
+impersonate_list = [
+    "chrome99",
+    "chrome100",
+    "chrome101",
+    "chrome104",
+    "chrome107",
+    "chrome110",
+    "chrome116",
+    "chrome119",
+    "chrome120",
+    "chrome123",
+    "edge99",
+    "edge101",
+] if not configs.impersonate_list else configs.impersonate_list
+
+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 f:
+        try:
+            refresh_map = json.load(f)
+        except:
+            refresh_map = {}
+else:
+    refresh_map = {}
+
+if os.path.exists(WSS_MAP_FILE):
+    with open(WSS_MAP_FILE, "r") as f:
+        try:
+            wss_map = json.load(f)
+        except:
+            wss_map = {}
+else:
+    wss_map = {}
+
+if os.path.exists(FP_FILE):
+    with open(FP_FILE, "r", encoding="utf-8") as f:
+        try:
+            fp_map = json.load(f)
+        except:
+            fp_map = {}
+else:
+    fp_map = {}
+
+if os.path.exists(SEED_MAP_FILE):
+    with open(SEED_MAP_FILE, "r") as f:
+        try:
+            seed_map = json.load(f)
+        except:
+            seed_map = {}
+else:
+    seed_map = {}
+
+if os.path.exists(CONVERSATION_MAP_FILE):
+    with open(CONVERSATION_MAP_FILE, "r") as f:
+        try:
+            conversation_map = json.load(f)
+        except:
+            conversation_map = {}
+else:
+    conversation_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)}")
+    logger.info("-" * 60)

utils/kv_utils.py

@@ -0,0 +1,10 @@
+def set_value_for_key(data, target_key, new_value):
+    if isinstance(data, dict):
+        for key, value in data.items():
+            if key == target_key:
+                data[key] = new_value
+            else:
+                set_value_for_key(value, target_key, new_value)
+    elif isinstance(data, list):
+        for item in data:
+            set_value_for_key(item, target_key, new_value)

utils/retry.py

@@ -0,0 +1,32 @@
+from fastapi import HTTPException
+
+from utils.Logger import logger
+from utils.configs 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...")

version.txt

@@ -0,0 +1 @@
+v1.7.9-beta4