Spaces:
Runtime error
Runtime error
| """ | |
| DeepSeek Web API Proxy Server (OpenAI-Compatible Gateway) | |
| Hugging Face Space Edition | |
| Version: 1.2.1 | |
| Description: Zero-dependency proxy mapping OpenAI completions to DeepSeek Web API | |
| """ | |
| import http.server | |
| import socketserver | |
| import json | |
| import urllib.request | |
| import urllib.error | |
| import sys | |
| import uuid | |
| import struct | |
| import binascii | |
| import base64 | |
| import time | |
| import threading | |
| import traceback | |
| import os | |
| from collections import defaultdict | |
| sys.stdout.reconfigure(encoding='utf-8') | |
| # --- CONFIGURATION --- | |
| PORT = int(os.environ.get("PORT", "7860")) | |
| HOST = "0.0.0.0" | |
| # Load token from env or file | |
| def _load_token(): | |
| tok = os.environ.get("DEEPSEEK_TOKEN", "").strip() | |
| if tok: | |
| return tok | |
| for path in ["token.txt", "/app/token.txt"]: | |
| try: | |
| with open(path, "r") as f: | |
| tok = f.read().strip() | |
| if tok: | |
| return tok | |
| except FileNotFoundError: | |
| pass | |
| return "" | |
| USER_TOKEN = _load_token() | |
| if not USER_TOKEN: | |
| print("WARNING: DEEPSEEK_TOKEN not set! Set it in HF Secrets.") | |
| print("Token format: oxMs/... (from browser at chat.deepseek.com)") | |
| # --- SESSION MANAGEMENT --- | |
| ACTIVE_SESSIONS = defaultdict(lambda: {"session_id": None, "message_history": []}) | |
| # Terminal Colors (disabled if no TTY) | |
| class Colors: | |
| if sys.stdout.isatty(): | |
| HEADER = '\033[95m'; BLUE = '\033[94m'; CYAN = '\033[96m'; GREEN = '\033[92m' | |
| WARNING = '\033[93m'; FAIL = '\033[91m'; ENDC = '\033[0m'; BOLD = '\033[1m' | |
| else: | |
| HEADER = BLUE = CYAN = GREEN = WARNING = FAIL = ENDC = BOLD = '' | |
| # --- HIGH PERFORMANCE DEEPSEEK POW SOLVER --- | |
| RC = [ | |
| 0x0000000000000001, 0x0000000000008082, 0x800000000000808A, 0x8000000080008000, | |
| 0x000000000000808B, 0x0000000080000001, 0x8000000080008081, 0x8000000000008009, | |
| 0x000000000000008A, 0x0000000000000088, 0x0000000080008009, 0x000000008000000A, | |
| 0x000000008000808B, 0x800000000000008B, 0x8000000000008089, 0x8000000000008003, | |
| 0x8000000000008002, 0x8000000000000080, 0x000000000000800A, 0x800000008000000A, | |
| 0x8000000080008081, 0x8000000000008080, 0x0000000080000001, 0x8000000080008008, | |
| ] | |
| def rotl64(v, k): | |
| return ((v << k) | (v >> (64 - k))) & 0xffffffffffffffff | |
| def keccakF23(s): | |
| a0, a1, a2, a3, a4 = s[0], s[1], s[2], s[3], s[4] | |
| a5, a6, a7, a8, a9 = s[5], s[6], s[7], s[8], s[9] | |
| a10, a11, a12, a13, a14 = s[10], s[11], s[12], s[13], s[14] | |
| a15, a16, a17, a18, a19 = s[15], s[16], s[17], s[18], s[19] | |
| a20, a21, a22, a23, a24 = s[20], s[21], s[22], s[23], s[24] | |
| for r in range(1, 24): | |
| c0 = a0 ^ a5 ^ a10 ^ a15 ^ a20 | |
| c1 = a1 ^ a6 ^ a11 ^ a16 ^ a21 | |
| c2 = a2 ^ a7 ^ a12 ^ a17 ^ a22 | |
| c3 = a3 ^ a8 ^ a13 ^ a18 ^ a23 | |
| c4 = a4 ^ a9 ^ a14 ^ a19 ^ a24 | |
| d0 = c4 ^ rotl64(c1, 1) | |
| d1 = c0 ^ rotl64(c2, 1) | |
| d2 = c1 ^ rotl64(c3, 1) | |
| d3 = c2 ^ rotl64(c4, 1) | |
| d4 = c3 ^ rotl64(c0, 1) | |
| a0 ^= d0; a5 ^= d0; a10 ^= d0; a15 ^= d0; a20 ^= d0 | |
| a1 ^= d1; a6 ^= d1; a11 ^= d1; a16 ^= d1; a21 ^= d1 | |
| a2 ^= d2; a7 ^= d2; a12 ^= d2; a17 ^= d2; a22 ^= d2 | |
| a3 ^= d3; a8 ^= d3; a13 ^= d3; a18 ^= d3; a23 ^= d3 | |
| a4 ^= d4; a9 ^= d4; a14 ^= d4; a19 ^= d4; a24 ^= d4 | |
| b0 = a0 | |
| b10 = rotl64(a1, 1) | |
| b20 = rotl64(a2, 62) | |
| b5 = rotl64(a3, 28) | |
| b15 = rotl64(a4, 27) | |
| b16 = rotl64(a5, 36) | |
| b1 = rotl64(a6, 44) | |
| b11 = rotl64(a7, 6) | |
| b21 = rotl64(a8, 55) | |
| b6 = rotl64(a9, 20) | |
| b7 = rotl64(a10, 3) | |
| b17 = rotl64(a11, 10) | |
| b2 = rotl64(a12, 43) | |
| b12 = rotl64(a13, 25) | |
| b22 = rotl64(a14, 39) | |
| b23 = rotl64(a15, 41) | |
| b8 = rotl64(a16, 45) | |
| b18 = rotl64(a17, 15) | |
| b3 = rotl64(a18, 21) | |
| b13 = rotl64(a19, 8) | |
| b14 = rotl64(a20, 18) | |
| b24 = rotl64(a21, 2) | |
| b9 = rotl64(a22, 61) | |
| b19 = rotl64(a23, 56) | |
| b4 = rotl64(a24, 14) | |
| a0 = b0 ^ ((~b1) & b2) | |
| a1 = b1 ^ ((~b2) & b3) | |
| a2 = b2 ^ ((~b3) & b4) | |
| a3 = b3 ^ ((~b4) & b0) | |
| a4 = b4 ^ ((~b0) & b1) | |
| a5 = b5 ^ ((~b6) & b7) | |
| a6 = b6 ^ ((~b7) & b8) | |
| a7 = b7 ^ ((~b8) & b9) | |
| a8 = b8 ^ ((~b9) & b5) | |
| a9 = b9 ^ ((~b5) & b6) | |
| a10 = b10 ^ ((~b11) & b12) | |
| a11 = b11 ^ ((~b12) & b13) | |
| a12 = b12 ^ ((~b13) & b14) | |
| a13 = b13 ^ ((~b14) & b10) | |
| a14 = b14 ^ ((~b10) & b11) | |
| a15 = b15 ^ ((~b16) & b17) | |
| a16 = b16 ^ ((~b17) & b18) | |
| a17 = b17 ^ ((~b18) & b19) | |
| a18 = b18 ^ ((~b19) & b15) | |
| a19 = b19 ^ ((~b15) & b16) | |
| a20 = b20 ^ ((~b21) & b22) | |
| a21 = b21 ^ ((~b22) & b23) | |
| a22 = b22 ^ ((~b23) & b24) | |
| a23 = b23 ^ ((~b24) & b20) | |
| a24 = b24 ^ ((~b20) & b21) | |
| a0 &= 0xffffffffffffffff; a1 &= 0xffffffffffffffff; a2 &= 0xffffffffffffffff; a3 &= 0xffffffffffffffff; a4 &= 0xffffffffffffffff | |
| a5 &= 0xffffffffffffffff; a6 &= 0xffffffffffffffff; a7 &= 0xffffffffffffffff; a8 &= 0xffffffffffffffff; a9 &= 0xffffffffffffffff | |
| a10 &= 0xffffffffffffffff; a11 &= 0xffffffffffffffff; a12 &= 0xffffffffffffffff; a13 &= 0xffffffffffffffff; a14 &= 0xffffffffffffffff | |
| a15 &= 0xffffffffffffffff; a16 &= 0xffffffffffffffff; a17 &= 0xffffffffffffffff; a18 &= 0xffffffffffffffff; a19 &= 0xffffffffffffffff | |
| a20 &= 0xffffffffffffffff; a21 &= 0xffffffffffffffff; a22 &= 0xffffffffffffffff; a23 &= 0xffffffffffffffff; a24 &= 0xffffffffffffffff | |
| a0 ^= RC[r] | |
| s[0], s[1], s[2], s[3], s[4] = a0, a1, a2, a3, a4 | |
| s[5], s[6], s[7], s[8], s[9] = a5, a6, a7, a8, a9 | |
| s[10], s[11], s[12], s[13], s[14] = a10, a11, a12, a13, a14 | |
| s[15], s[16], s[17], s[18], s[19] = a15, a16, a17, a18, a19 | |
| s[20], s[21], s[22], s[23], s[24] = a20, a21, a22, a23, a24 | |
| def solve_pow(challenge_hex, salt, expire_at, difficulty): | |
| target = binascii.unhexlify(challenge_hex) | |
| t0, t1, t2, t3 = struct.unpack("<QQQQ", target) | |
| prefix = f"{salt}_{expire_at}_".encode('utf-8') | |
| rate = 136 | |
| # Pre-absorb the prefix state | |
| base_state = [0] * 25 | |
| off = 0 | |
| while off + rate <= len(prefix): | |
| for i in range(rate // 8): | |
| val = struct.unpack_from("<Q", prefix, off + i * 8)[0] | |
| base_state[i] ^= val | |
| keccakF23(base_state) | |
| off += rate | |
| tail_len = len(prefix) - off | |
| tail = bytearray(rate) | |
| tail[:tail_len] = prefix[off:] | |
| # Iterate through possible nonces | |
| for n in range(difficulty): | |
| num_str = str(n).encode('utf-8') | |
| num_len = len(num_str) | |
| s = list(base_state) | |
| total_tail = tail_len + num_len | |
| if total_tail < rate: | |
| buf = bytearray(rate) | |
| buf[:tail_len] = tail[:tail_len] | |
| buf[tail_len:total_tail] = num_str | |
| buf[total_tail] = 0x06 | |
| buf[rate - 1] |= 0x80 | |
| for i in range(rate // 8): | |
| s[i] ^= struct.unpack_from("<Q", buf, i * 8)[0] | |
| keccakF23(s) | |
| else: | |
| buf = bytearray(rate) | |
| buf[:tail_len] = tail[:tail_len] | |
| buf[tail_len:rate] = num_str[:rate - tail_len] | |
| for i in range(rate // 8): | |
| s[i] ^= struct.unpack_from("<Q", buf, i * 8)[0] | |
| keccakF23(s) | |
| buf2 = bytearray(rate) | |
| rem = total_tail - rate | |
| buf2[:rem] = num_str[rate - tail_len:] | |
| buf2[rem] = 0x06 | |
| buf2[rate - 1] |= 0x80 | |
| for i in range(rate // 8): | |
| s[i] ^= struct.unpack_from("<Q", buf2, i * 8)[0] | |
| keccakF23(s) | |
| if s[0] == t0 and s[1] == t1 and s[2] == t2 and s[3] == t3: | |
| return n | |
| raise ValueError("PoW: No solution found within difficulty range.") | |
| # --- DEEPSEEK WEB API DRIVER --- | |
| def create_chat_session(): | |
| url = "https://chat.deepseek.com/api/v0/chat_session/create" | |
| headers = { | |
| "Authorization": f"Bearer {USER_TOKEN}", | |
| "Content-Type": "application/json", | |
| "Accept": "application/json", | |
| "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", | |
| "Referer": "https://chat.deepseek.com/", | |
| "Origin": "https://chat.deepseek.com", | |
| "x-client-platform": "web", | |
| "x-app-version": "20241129.1" | |
| } | |
| payload = json.dumps({"agent": "chat"}).encode('utf-8') | |
| req = urllib.request.Request(url, data=payload, headers=headers, method="POST") | |
| with urllib.request.urlopen(req, timeout=15) as response: | |
| res_json = json.loads(response.read().decode('utf-8')) | |
| if res_json.get("code") != 0: | |
| raise ValueError(f"Failed to create session: {res_json.get('msg')}") | |
| biz_data = res_json.get("data", {}).get("biz_data", {}) | |
| session_id = biz_data.get("id") or biz_data.get("chat_session", {}).get("id") | |
| if not session_id: | |
| raise ValueError("Failed to extract session id") | |
| return session_id | |
| POW_CACHE = {"header": None, "expires": 0} | |
| POW_CACHE_LOCK = threading.Lock() | |
| def get_pow_header(target_path="/api/v0/chat/completion"): | |
| with POW_CACHE_LOCK: | |
| if POW_CACHE["header"] and time.time() < POW_CACHE["expires"]: | |
| print(f"{Colors.CYAN}⚡ Using cached PoW{Colors.ENDC}") | |
| return POW_CACHE["header"] | |
| url = "https://chat.deepseek.com/api/v0/chat/create_pow_challenge" | |
| headers = { | |
| "Authorization": f"Bearer {USER_TOKEN}", | |
| "Content-Type": "application/json", | |
| "Accept": "application/json", | |
| "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", | |
| "Referer": "https://chat.deepseek.com/", | |
| "Origin": "https://chat.deepseek.com", | |
| "x-client-platform": "web", | |
| "x-app-version": "20241129.1" | |
| } | |
| payload = json.dumps({"target_path": target_path}).encode('utf-8') | |
| req = urllib.request.Request(url, data=payload, headers=headers, method="POST") | |
| with urllib.request.urlopen(req, timeout=15) as response: | |
| res_json = json.loads(response.read().decode('utf-8')) | |
| if res_json.get("code") != 0: | |
| raise ValueError(f"Failed to fetch challenge: {res_json.get('msg')}") | |
| challenge_data = res_json.get("data", {}).get("biz_data", {}).get("challenge", {}) | |
| algo = challenge_data.get("algorithm") | |
| ch_hex = challenge_data.get("challenge") | |
| salt = challenge_data.get("salt") | |
| expire_at = challenge_data.get("expire_at") | |
| difficulty = challenge_data.get("difficulty") | |
| signature = challenge_data.get("signature") | |
| t_path = challenge_data.get("target_path") | |
| start_time = time.time() | |
| print(f"{Colors.WARNING}⏳ Solving PoW (difficulty: {difficulty})...{Colors.ENDC}") | |
| answer = solve_pow(ch_hex, salt, expire_at, difficulty) | |
| elapsed = time.time() - start_time | |
| print(f"{Colors.GREEN}✅ Solved PoW! Answer: {answer} | Took {elapsed:.1f}s{Colors.ENDC}") | |
| response_json = { | |
| "algorithm": algo, | |
| "challenge": ch_hex, | |
| "salt": salt, | |
| "answer": answer, | |
| "signature": signature, | |
| "target_path": t_path | |
| } | |
| pow_header = base64.b64encode(json.dumps(response_json).encode('utf-8')).decode('utf-8') | |
| with POW_CACHE_LOCK: | |
| POW_CACHE["header"] = pow_header | |
| POW_CACHE["expires"] = time.time() + 300 | |
| print(f"{Colors.GREEN}💾 PoW cached for 5 minutes{Colors.ENDC}") | |
| return pow_header | |
| # --- OPENAI SPEC COMPLIANT GATEWAY --- | |
| class ThreadedHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer): | |
| daemon_threads = True | |
| allow_reuse_address = True | |
| class OpenAICompatibleHandler(http.server.BaseHTTPRequestHandler): | |
| def log_message(self, format, *args): | |
| pass | |
| def send_cors_headers(self): | |
| self.send_header('Access-Control-Allow-Origin', '*') | |
| self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS') | |
| self.send_header('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-ds-pow-response') | |
| def do_HEAD(self): | |
| # Cline and other clients validate endpoints with HEAD requests before POSTing | |
| chat_paths = ("/v1/chat/completions", "/chat/completions") | |
| model_paths = ("/v1/models", "/models") | |
| if self.path in model_paths + chat_paths + ("/health", "/healthz", "/", "/status"): | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| self.end_headers() | |
| else: | |
| self.send_response(404) | |
| self.end_headers() | |
| def do_OPTIONS(self): | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| self.end_headers() | |
| def do_GET(self): | |
| # Support both /models and /v1/models paths | |
| path = self.path | |
| if self.path == "/v1/models": | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| self.send_header('Content-Type', 'application/json') | |
| self.end_headers() | |
| models_data = { | |
| "object": "list", | |
| "data": [ | |
| {"id": "deepseek-chat", "object": "model", "created": 1700000000, "owned_by": "deepseek"}, | |
| {"id": "deepseek-reasoner", "object": "model", "created": 1700000000, "owned_by": "deepseek"} | |
| ] | |
| } | |
| self.wfile.write(json.dumps(models_data).encode('utf-8')) | |
| elif self.path in ("/health", "/healthz"): | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| self.send_header('Content-Type', 'application/json') | |
| self.end_headers() | |
| health = { | |
| "status": "healthy", | |
| "service": "deepseek-proxy", | |
| "timestamp": int(time.time()), | |
| "token_configured": bool(USER_TOKEN), | |
| "version": "1.2.1" | |
| } | |
| self.wfile.write(json.dumps(health).encode('utf-8')) | |
| elif self.path in ("/", "/status"): | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| self.send_header('Content-Type', 'application/json') | |
| self.end_headers() | |
| status = { | |
| "service": "DeepSeek Proxy (HF Space)", | |
| "version": "1.2.1", | |
| "endpoints": { | |
| "chat": "POST /v1/chat/completions", | |
| "models": "GET /v1/models", | |
| "health": "GET /health" | |
| }, | |
| "token_configured": bool(USER_TOKEN), | |
| "instructions": "Set DEEPSEEK_TOKEN secret, then use with VS Code/Cline" | |
| } | |
| self.wfile.write(json.dumps(status).encode('utf-8')) | |
| else: | |
| self.send_response(404) | |
| self.end_headers() | |
| self.wfile.write(b"Not Found") | |
| def do_POST(self): | |
| # Support both /chat/completions and /v1/chat/completions paths | |
| path = self.path | |
| if self.path not in ("/v1/chat/completions", "/chat/completions"): | |
| self.send_response(404) | |
| self.end_headers() | |
| self.wfile.write(b"Not Found") | |
| return | |
| if not USER_TOKEN: | |
| self.send_error_response(500, "DEEPSEEK_TOKEN not configured. Set it in HF Space Settings -> Secrets.") | |
| return | |
| content_length = int(self.headers.get('Content-Length', 0)) | |
| post_data = self.rfile.read(content_length) | |
| try: | |
| req_body = json.loads(post_data.decode('utf-8')) | |
| except Exception as e: | |
| self.send_error_response(400, f"Invalid JSON: {e}") | |
| return | |
| messages = req_body.get("messages", []) | |
| stream = req_body.get("stream", False) | |
| model = req_body.get("model", "deepseek-chat") | |
| conversation_id = req_body.get("conversation_id", "default") | |
| thinking_enabled = (model == "deepseek-reasoner") | |
| session_data = ACTIVE_SESSIONS[conversation_id] | |
| prompt = "" | |
| for msg in messages: | |
| role = msg.get("role", "user") | |
| content = msg.get("content", "") | |
| if isinstance(content, list): | |
| text_parts = [] | |
| for part in content: | |
| if isinstance(part, dict): | |
| pt = part.get("type", "text") | |
| if pt == "text": | |
| text_parts.append(part.get("text", "")) | |
| elif pt == "file": | |
| text_parts.append(f"\n```{part.get('name','file')}\n{part.get('content','')}\n```\n") | |
| elif pt == "image_url": | |
| text_parts.append("[Image: not supported]") | |
| elif isinstance(part, str): | |
| text_parts.append(part) | |
| content = "".join(text_parts) | |
| if role in ("system", "user", "assistant"): | |
| prompt += f"{content}\n\n" | |
| prompt = prompt.strip() | |
| print(f"{Colors.BLUE}💬 Request | Model: {model} | Stream: {stream}{Colors.ENDC}") | |
| try: | |
| if session_data["session_id"] is None: | |
| session_id = create_chat_session() | |
| session_data["session_id"] = session_id | |
| print(f"{Colors.GREEN}🆕 Session: {session_id[:16]}...{Colors.ENDC}") | |
| else: | |
| session_id = session_data["session_id"] | |
| print(f"{Colors.CYAN}♻️ Reusing session{Colors.ENDC}") | |
| pow_header = get_pow_header() | |
| except Exception as e: | |
| traceback.print_exc() | |
| self.send_error_response(500, f"Upstream setup error: {e}") | |
| return | |
| ds_headers = { | |
| "Authorization": f"Bearer {USER_TOKEN}", | |
| "Content-Type": "application/json", | |
| "Accept": "text/event-stream", | |
| "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36", | |
| "Referer": "https://chat.deepseek.com/", | |
| "Origin": "https://chat.deepseek.com", | |
| "x-client-platform": "web", | |
| "x-app-version": "20241129.1", | |
| "x-ds-pow-response": pow_header | |
| } | |
| ds_payload = json.dumps({ | |
| "chat_session_id": session_id, | |
| "prompt": prompt, | |
| "parent_message_id": None, | |
| "ref": "web", | |
| "ref_file_ids": [], | |
| "search_enabled": False, | |
| "thinking_enabled": thinking_enabled | |
| }).encode('utf-8') | |
| ds_req = urllib.request.Request( | |
| "https://chat.deepseek.com/api/v0/chat/completion", | |
| data=ds_payload, | |
| headers=ds_headers, | |
| method="POST" | |
| ) | |
| try: | |
| response = urllib.request.urlopen(ds_req, timeout=90) | |
| first_line = response.readline().decode('utf-8').strip() | |
| if "INVALID_POW_RESPONSE" in first_line or "40301" in first_line: | |
| response.close() | |
| with POW_CACHE_LOCK: | |
| POW_CACHE["header"] = None | |
| POW_CACHE["expires"] = 0 | |
| pow_header = get_pow_header() | |
| ds_headers["x-ds-pow-response"] = pow_header | |
| ds_req = urllib.request.Request( | |
| "https://chat.deepseek.com/api/v0/chat/completion", | |
| data=ds_payload, | |
| headers=ds_headers, | |
| method="POST" | |
| ) | |
| response = urllib.request.urlopen(ds_req, timeout=90) | |
| print(f"{Colors.GREEN}🔄 Retried with fresh PoW{Colors.ENDC}") | |
| else: | |
| class ResponseWithFirstLine: | |
| def __init__(self, first_line, response): | |
| self.first_line = first_line.encode('utf-8') + b'\n' | |
| self.response = response | |
| self.first_yielded = False | |
| def __iter__(self): | |
| if not self.first_yielded: | |
| yield self.first_line | |
| self.first_yielded = True | |
| for line in self.response: | |
| yield line | |
| def close(self): | |
| self.response.close() | |
| response = ResponseWithFirstLine(first_line, response) | |
| except urllib.error.HTTPError as e: | |
| err_body = e.read().decode('utf-8') if e.fp else "" | |
| print(f"{Colors.FAIL}❌ Upstream HTTP {e.code}: {err_body}{Colors.ENDC}") | |
| self.send_error_response(e.code, f"Upstream error: {err_body}") | |
| return | |
| except Exception as e: | |
| traceback.print_exc() | |
| self.send_error_response(503, f"Failed to connect: {e}") | |
| return | |
| self.send_response(200) | |
| self.send_cors_headers() | |
| if stream: | |
| self.send_header('Content-Type', 'text/event-stream') | |
| self.send_header('Cache-Control', 'no-cache') | |
| self.send_header('Connection', 'keep-alive') | |
| self.end_headers() | |
| self.stream_response(response, model) | |
| else: | |
| self.send_header('Content-Type', 'application/json') | |
| self.end_headers() | |
| self.blocking_response(response, model) | |
| def stream_response(self, response, model): | |
| created_time = int(time.time()) | |
| req_id = f"chatcmpl-{uuid.uuid4()}" | |
| is_thinking = (model == "deepseek-reasoner") | |
| try: | |
| chunk_count = 0 | |
| for raw_line in response: | |
| line = raw_line.decode('utf-8').strip() | |
| if not line: | |
| continue | |
| if line.startswith("event:"): | |
| event_name = line[6:].strip() | |
| if event_name in ("close", "finish"): | |
| break | |
| continue | |
| if not line.startswith("data:"): | |
| continue | |
| data_str = line[5:].strip() | |
| if data_str == "[DONE]": | |
| break | |
| try: | |
| ds_chunk = json.loads(data_str) | |
| except: | |
| continue | |
| p_val = ds_chunk.get("p") | |
| v_val = ds_chunk.get("v") | |
| if p_val in ("response/accumulated_token_usage", "response/status"): | |
| if p_val == "response/status" and v_val == "FINISHED": | |
| break | |
| continue | |
| if p_val == "response/thinking_elapsed_secs": | |
| is_thinking = False | |
| continue | |
| elif p_val == "response/content": | |
| is_thinking = False | |
| if isinstance(v_val, str): | |
| self.send_openai_chunk(req_id, created_time, model, v_val, None, None) | |
| continue | |
| if isinstance(v_val, str): | |
| chunk_count += 1 | |
| if is_thinking: | |
| self.send_openai_chunk(req_id, created_time, model, None, v_val, None) | |
| else: | |
| self.send_openai_chunk(req_id, created_time, model, v_val, None, None) | |
| self.send_openai_chunk(req_id, created_time, model, None, None, "stop") | |
| self.wfile.write(b"data: [DONE]\n\n") | |
| self.wfile.flush() | |
| print(f"{Colors.GREEN}>> Stream done. {chunk_count} chunks{Colors.ENDC}") | |
| except Exception as e: | |
| print(f"{Colors.FAIL}>> Stream error: {e}{Colors.ENDC}") | |
| finally: | |
| response.close() | |
| def send_openai_chunk(self, req_id, created_time, model, content, reasoning_content, finish_reason): | |
| delta = {} | |
| if content is not None: | |
| delta["content"] = content | |
| if reasoning_content is not None: | |
| delta["reasoning_content"] = reasoning_content | |
| chunk_payload = { | |
| "id": req_id, | |
| "object": "chat.completion.chunk", | |
| "created": created_time, | |
| "model": model, | |
| "choices": [{"index": 0, "delta": delta, "finish_reason": finish_reason}] | |
| } | |
| sse_str = f"data: {json.dumps(chunk_payload)}\n\n" | |
| self.wfile.write(sse_str.encode('utf-8')) | |
| self.wfile.flush() | |
| def blocking_response(self, response, model): | |
| created_time = int(time.time()) | |
| req_id = f"chatcmpl-{uuid.uuid4()}" | |
| full_content = "" | |
| full_reasoning = "" | |
| is_thinking = (model == "deepseek-reasoner") | |
| try: | |
| for raw_line in response: | |
| line = raw_line.decode('utf-8').strip() | |
| if not line: | |
| continue | |
| if line.startswith("event:"): | |
| event_name = line[6:].strip() | |
| if event_name in ("close", "finish"): | |
| break | |
| continue | |
| if not line.startswith("data:"): | |
| continue | |
| data_str = line[5:].strip() | |
| if data_str == "[DONE]": | |
| break | |
| try: | |
| ds_chunk = json.loads(data_str) | |
| except: | |
| continue | |
| p_val = ds_chunk.get("p") | |
| v_val = ds_chunk.get("v") | |
| if p_val in ("response/accumulated_token_usage", "response/status"): | |
| if p_val == "response/status" and v_val == "FINISHED": | |
| break | |
| continue | |
| if p_val == "response/thinking_elapsed_secs": | |
| is_thinking = False | |
| continue | |
| elif p_val == "response/content": | |
| is_thinking = False | |
| if isinstance(v_val, str): | |
| full_content += v_val | |
| continue | |
| if isinstance(v_val, str): | |
| if is_thinking: | |
| full_reasoning += v_val | |
| else: | |
| full_content += v_val | |
| print(f"{Colors.GREEN}✅ Blocking response: {len(full_content)} chars content{Colors.ENDC}") | |
| res_payload = { | |
| "id": req_id, | |
| "object": "chat.completion", | |
| "created": created_time, | |
| "model": model, | |
| "choices": [{ | |
| "index": 1, | |
| "message": { | |
| "role": "assistant", | |
| "content": full_content, | |
| "reasoning_content": full_reasoning if full_reasoning else None | |
| }, | |
| "finish_reason": "stop" | |
| }], | |
| "usage": { | |
| "prompt_tokens": len(full_content) // 4 + 10, | |
| "completion_tokens": len(full_content) // 4, | |
| "total_tokens": (len(full_content) // 4) * 2 + 10 | |
| } | |
| } | |
| self.wfile.write(json.dumps(res_payload).encode('utf-8')) | |
| except Exception as e: | |
| traceback.print_exc() | |
| self.send_error_response(500, f"Error gathering response: {e}") | |
| finally: | |
| response.close() | |
| def send_error_response(self, code, message): | |
| self.send_response(code) | |
| self.send_cors_headers() | |
| self.send_header('Content-Type', 'application/json') | |
| self.end_headers() | |
| err_payload = {"error": {"message": message, "type": "api_error", "code": code}} | |
| self.wfile.write(json.dumps(err_payload).encode('utf-8')) | |
| # --- SERVER START --- | |
| def start_server(): | |
| print(f"\n{Colors.HEADER}{Colors.BOLD}==================================================={Colors.ENDC}") | |
| print(f"{Colors.CYAN}{Colors.BOLD} 🚀 DEEPSEEK PROXY - HUGGING FACE SPACE EDITION 🚀{Colors.ENDC}") | |
| print(f"{Colors.HEADER}{Colors.BOLD}==================================================={Colors.ENDC}") | |
| print(f"📡 Endpoint: {Colors.BOLD}http://{HOST}:{PORT}/v1{Colors.ENDC}") | |
| print(f"🔑 Token: {Colors.WARNING}{'✅ Configured' if USER_TOKEN else '❌ NOT SET'}{Colors.ENDC}") | |
| print(f"🧠 Models: {Colors.GREEN}deepseek-chat, deepseek-reasoner{Colors.ENDC}") | |
| print(f"🛡️ PoW Engine: {Colors.GREEN}Keccak solver (cached 5 min){Colors.ENDC}") | |
| print(f"📊 Health: {Colors.BOLD}GET /health{Colors.ENDC}") | |
| print(f"{Colors.HEADER}==================================================={Colors.ENDC}\n") | |
| server_address = (HOST, PORT) | |
| try: | |
| with ThreadedHTTPServer(server_address, OpenAICompatibleHandler) as httpd: | |
| print(f"{Colors.GREEN}🔥 Server running on {HOST}:{PORT}{Colors.ENDC}") | |
| httpd.serve_forever() | |
| except KeyboardInterrupt: | |
| print(f"\n{Colors.WARNING}⚠️ Shutting down...{Colors.ENDC}") | |
| except Exception as e: | |
| print(f"\n{Colors.FAIL}❌ Server error: {e}{Colors.ENDC}") | |
| sys.exit(1) | |
| if __name__ == "__main__": | |
| start_server() | |