Merge pull request #233 from lanqian528/dev

Dev -> Main

Author: lanqian528

api/chat2api.py

@@ -97,7 +97,7 @@ async def upload_post(text: str = Form(...)):
 
 
 @app.post(f"/{api_prefix}/tokens/clear" if api_prefix else "/tokens/clear")
-async def upload_post():
+async def clear_tokens():
     globals.token_list.clear()
     globals.error_token_list.clear()
     with open(globals.TOKENS_FILE, "w", encoding="utf-8") as f:
@@ -122,3 +122,15 @@ async def add_token(token: str):
     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/models.py

@@ -10,6 +10,9 @@
     "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",

chatgpt/ChatService.py

@@ -136,7 +136,17 @@ async def set_model(self):
         else:
             self.gizmo_id = None
 
-        if "o1-preview" in self.origin_model:
+        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"

chatgpt/authorization.py

@@ -33,7 +33,7 @@ def get_req_token(req_token, seed=None):
                     globals.count %= length
                     return available_token_list[globals.count]
             else:
-                return None
+                return ""
         else:
             return req_token
     else:

chatgpt/proofofWork.py

@@ -437,18 +437,19 @@ def get_config(user_agent):
         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(),
+        time.perf_counter() * 1000,
         str(uuid.uuid4()),
         "",
         random.choice(cores),
+        time.time() * 1000 - (time.perf_counter() * 1000),
     ]
     return config
 
@@ -499,6 +500,6 @@ def get_requirements_token(config):
     #     answer = get_answer_token(seed, diff, config)
     cached_scripts.append(
         "https://cdn.oaistatic.com/_next/static/cXh69klOLzS0Gy2joLDRS/_ssgManifest.js?dpl=453ebaec0d44c2decab71692e1bfe39be35a24b3")
-    cached_dpl = "dpl=453ebaec0d44c2decab71692e1bfe39be35a24b3"
+    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)

gateway/backend.py

@@ -15,7 +15,8 @@
 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
+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, \
@@ -93,6 +94,24 @@ async def get_gizmos_discovery_recent(request: Request):
         }
 
 
+@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 ", "")
@@ -230,8 +249,81 @@ async def edge():
 
 
 if no_sentinel:
+    openai_sentinel_tokens_cache = {}
+
     @app.post("/backend-api/sentinel/chat-requirements")
-    async def sentinel_chat_conversations():
+    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,
@@ -251,6 +343,7 @@ async def sentinel_chat_conversations():
         }
 
 
+    @app.post("/backend-alt/conversation")
     @app.post("/backend-api/conversation")
     async def chat_conversations(request: Request):
         token = request.headers.get("Authorization", "").replace("Bearer ", "")
@@ -266,54 +359,71 @@ async def chat_conversations(request: Request):
         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() 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)
+            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
-
-        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,
-        })
+        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()
@@ -340,7 +450,7 @@ async def c_close(client, clients):
             data = json.dumps(req_json).encode("utf-8")
 
         background = BackgroundTask(c_close, client, clients)
-        r = await client.post_stream(f"{host_url}/backend-api/conversation", params=params, headers=headers,
+        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}")