Remove main application code, dependencies, and versioning files

Dockerfile

@@ -1,26 +1,14 @@
-# 使用官方的Python基础镜像
-FROM python:3.10-slim
+# 使用官方Go基础镜像
+FROM golang:1.22-alpine as builder
 
-# 安装时区依赖
-RUN apt-get update && apt-get install -y tzdata
-
-# 设置东八区时区
-ENV TZ=Asia/Shanghai
-
-# 设置工作目录
 WORKDIR /app
-
-# 复制依赖文件到工作目录
-COPY requirements.txt .
-
-# 安装依赖
-RUN pip install --no-cache-dir -r requirements.txt
-
-# 复制应用代码到工作目录
 COPY . .
+RUN go mod tidy && go build -o app .
 
-# 暴露端口
-EXPOSE 8000
-
-# 运行应用
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+FROM alpine:latest
+WORKDIR /app
+COPY --from=builder /app/app .
+COPY --from=builder /app/version.py ./version.py
+ENV TZ=Asia/Shanghai
+EXPOSE 7860
+CMD ["./app"]

README.md

@@ -1,10 +1,8 @@
----
-title: AIChatbot2API
-emoji: 🏃
-colorFrom: yellow
-colorTo: indigo
-sdk: docker
-pinned: false
----
+# AIChatbot2API (Go版)
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+本项目为AIChatbot2API的Go语言实现，提供与原Python版本相同的API接口：
+- /v1/chat/completions
+- /v1/models
+- /health
+
+请参考源码和Dockerfile进行部署。

app.py

@@ -1,397 +0,0 @@
-import re
-import os
-import uuid
-import time
-import json
-import httpx
-import uvicorn
-import hashlib
-import secrets
-import logging
-from pydantic import BaseModel
-from dotenv import load_dotenv
-from fake_useragent import UserAgent
-from fastapi.security import APIKeyHeader
-from typing import List, Literal, Optional
-from fastapi.responses import StreamingResponse
-from fastapi.responses import Response
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi import FastAPI, HTTPException, Depends
-
-# Load .env file
-load_dotenv()
-
-# Retrieve environment variables
-API_KEY = os.getenv("API_KEY")
-if not API_KEY:
-    raise ValueError("API_KEY not found in .env file")
-
-ENABLE_CORS = os.getenv("ENABLE_CORS", "True").lower() in ("true", "1", "yes")
-LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper()
-MAX_CHARS = int(os.getenv("MAX_CHARS", "80000"))
-RANDOM_UA = os.getenv("RANDOM_UA", "False").lower() in ("true", "1", "yes")
-
-# Configure logging
-logging.basicConfig(
-    level=getattr(logging, LOG_LEVEL, logging.INFO),
-    format="%(asctime)s - %(levelname)s - %(message)s",
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-# Suppress httpx and httpcore debug logs
-logging.getLogger("httpx").setLevel(logging.ERROR)
-logging.getLogger("httpcore").setLevel(logging.ERROR)
-
-# Initialize FastAPI app
-app = FastAPI()
-
-# Enable CORS if configured
-if ENABLE_CORS:
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    logger.info("CORS enabled")
-else:
-    logger.info("CORS disabled")
-
-# Constants
-api_domain = "https://ai-chatbot.top"
-default_user_agent = (
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) "
-    "Gecko/20100101 Firefox/136.0"
-)
-ua = UserAgent()
-
-# Supported models
-supported_models = ["DeepSeek-R1", "DeepSeek-V3"]
-model_to_config = {
-    "DeepSeek-R1": {"model": "deepseek-huoshan", "isWebSearchEnabled": False},
-    "DeepSeek-V3": {"model": "deepseek-guiji", "isWebSearchEnabled": False},
-}
-
-# Device ID and UA mapping
-device_ua_map = {}
-
-
-# Utility functions
-def nanoid(size=21):
-    url_alphabet = "abcdefgh0ijkl1mno2pqrs3tuv4wxyz5ABCDEFGH6IJKL7MNO8PQRS9TUV-WXYZ_"
-    return "".join(secrets.choice(url_alphabet) for _ in range(size))
-
-
-def generate_device_id():
-    return f"{uuid.uuid4().hex}_{nanoid(20)}"
-
-
-def get_user_agent(device_id: str) -> str:
-    if not RANDOM_UA:
-        return default_user_agent
-    if device_id not in device_ua_map:
-        device_ua_map[device_id] = ua.random
-    return device_ua_map[device_id]
-
-
-def generate_sign(chat_id: str, timestamp: int) -> str:
-    message = f"{chat_id}{timestamp}@!~chatbot.0868"
-    return hashlib.md5(message.encode("utf-8")).hexdigest()
-
-
-async def get_chat_id() -> str:
-    cookies = {
-        '_ga_HVMZBNYJML': 'GS1.1.1742013194.1.0.1742013194.0.0.0',
-        '_ga': 'GA1.1.1029622546.1742013195',
-    }
-    headers = {
-        "User-Agent": default_user_agent,
-        "Accept": "*/*",
-        "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
-        "Referer": "https://ai-chatbot.top/",
-        "RSC": "1",
-        "Next-Router-State-Tree": '["",{"children":["(chat)",{"children":["__PAGE__",{}, "/", "refresh"]}]},null,"refetch"]',
-        "DNT": "1",
-        "Sec-GPC": "1",
-        "Connection": "keep-alive",
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "same-origin",
-        "Priority": "u=0",
-    }
-    params = {"_rsc": "l4cx"}
-    async with httpx.AsyncClient(http2=True) as client:
-        response = await client.get(f"{api_domain}/", params=params, cookies=cookies, headers=headers, timeout=30)
-        chat_ids = re.findall(r'[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}',
-                              response.text)
-        return chat_ids[-1]
-
-
-# API key validation
-api_key_header = APIKeyHeader(name="Authorization", auto_error=False)
-
-
-async def verify_api_key(authorization: str = Depends(api_key_header)):
-    if not authorization:
-        logger.error("Missing Authorization header")
-        raise HTTPException(status_code=401, detail="Missing Authorization header")
-    api_key = authorization.replace("Bearer ", "").strip() if authorization.startswith("Bearer ") else authorization
-    if api_key != API_KEY:
-        logger.error(f"Invalid API key: {api_key}")
-        raise HTTPException(status_code=401, detail="Invalid API key")
-    return api_key
-
-
-# Request models
-class Message(BaseModel):
-    role: Literal["system", "user", "assistant"]
-    content: str
-
-
-class ChatCompletionRequest(BaseModel):
-    model: str
-    messages: List[Message]
-    stream: Optional[bool] = False
-    temperature: Optional[float] = 0.7
-    top_p: Optional[float] = 1.0
-    presence_penalty: Optional[float] = 0
-    frequency_penalty: Optional[float] = 0
-    max_tokens: Optional[int] = None
-
-
-# Response generation
-def generate_chunk(_id: str, created: int, model: str, content: str = "", finish_reason: Optional[str] = None):
-    chunk = {
-        "id": _id,
-        "object": "chat.completion.chunk",
-        "created": created,
-        "model": model,
-        "choices": [{"index": 0, "delta": {"content": content}, "finish_reason": finish_reason}]
-    }
-    return f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
-
-
-def truncate_messages(messages: List[Message], max_chars: int = MAX_CHARS) -> List[Message]:
-    total_chars = sum(len(msg.content) for msg in messages)
-    if total_chars <= max_chars:
-        return messages
-    truncated = []
-    current_chars = 0
-    for msg in reversed(messages):
-        if current_chars + len(msg.content) <= max_chars:
-            truncated.insert(0, msg)
-            current_chars += len(msg.content)
-        else:
-            break
-    logger.info(f"Truncated messages: original {total_chars}, truncated {current_chars}")
-    return truncated
-
-
-async def stream_response(request: ChatCompletionRequest, device_id: str, chat_id: str, timestamp: int, sign: str):
-    truncated_messages = truncate_messages(request.messages)
-    messages = [{"role": msg.role, "content": msg.content} for msg in truncated_messages]
-    payload = {
-        "id": chat_id,
-        "messages": messages,
-        "selectedChatModel": model_to_config[request.model]["model"],
-        "isDeepThinkingEnabled": True,
-        "isWebSearchEnabled": model_to_config[request.model]["isWebSearchEnabled"],
-    }
-    headers = {
-        "User-Agent": get_user_agent(device_id),
-        "Accept": "*/*",
-        "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
-        "Referer": f"https://ai-chatbot.top/chat/{chat_id}",
-        "Content-Type": "application/json",
-        "currentTime": str(timestamp),
-        "sign": sign,
-        "Origin": "https://ai-chatbot.top",
-        "DNT": "1",
-        "Sec-GPC": "1",
-        "Connection": "keep-alive",
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "same-origin",
-        "Priority": "u=0",
-    }
-    cookies = {
-        '_ga_HVMZBNYJML': 'GS1.1.1742013194.1.1.1742013780.0.0.0',
-        '_ga': 'GA1.1.1029622546.1742013195',
-    }
-    _id = f"chatcmpl-{uuid.uuid4().hex}"
-    created = int(time.time())
-    logger.info(f"[stream] Start: chat_id={chat_id}, UA={headers['User-Agent']}")
-    try:
-        # 首先发送一个空chunk，兼容SSE客户端
-        yield generate_chunk(_id, created, request.model, "")
-        async with httpx.AsyncClient(http2=True, timeout=900) as client:
-            async with client.stream("POST", f"{api_domain}/api/chat", json=payload, headers=headers, cookies=cookies) as response:
-                if response.status_code != 200:
-                    logger.error(f"[stream] API error: status_code={response.status_code}")
-                    yield generate_chunk(_id, created, request.model, f"Error: HTTP {response.status_code}", "stop")
-                    # 明确结束
-                    yield "data: [DONE]\n\n"
-                    return
-                thinking = False
-                content_parts = []
-                async for line in response.aiter_lines():
-                    line = line.strip()
-                    if not line:
-                        continue
-                    if line.startswith("g:"):
-                        if not thinking:
-                            thinking = True
-                            content_parts.append("<think>")
-                            yield generate_chunk(_id, created, request.model, "<think>")
-                        content = line[2:].strip().replace('"', '').replace("\\n", "\n")
-                        content_parts.append(content)
-                        yield generate_chunk(_id, created, request.model, content)
-                    elif line.startswith("0:"):
-                        if thinking:
-                            thinking = False
-                            content_parts.append("</think>")
-                            yield generate_chunk(_id, created, request.model, "</think>")
-                        content = line[2:].strip().replace('"', '').replace("\\n", "\n")
-                        content_parts.append(content)
-                        yield generate_chunk(_id, created, request.model, content)
-                if thinking:
-                    content_parts.append("</think>")
-                    yield generate_chunk(_id, created, request.model, "</think>")
-                # 结束信号
-                yield generate_chunk(_id, created, request.model, "", "stop")
-                yield "data: [DONE]\n\n"
-                logger.info(f"[stream] Completed: chat_id={chat_id}, content={''.join(content_parts)}")
-    except Exception as e:
-        logger.error(f"[stream] Exception: {e}")
-        yield generate_chunk(_id, created, request.model, f"[流式异常] {str(e)}", "stop")
-        yield "data: [DONE]\n\n"
-
-
-# not_stream_response
-async def not_stream_response(request: ChatCompletionRequest, device_id: str, chat_id: str, timestamp: int, sign: str):
-    truncated_messages = truncate_messages(request.messages) if callable(truncate_messages) else truncate_messages(request.messages)
-    print(truncated_messages)
-    messages = [{"role": msg.role, "content": msg.content} for msg in truncated_messages]
-    payload = {
-        "id": chat_id,
-        "messages": messages,
-        "selectedChatModel": model_to_config[request.model]["model"],
-        "isDeepThinkingEnabled": True,
-        "isWebSearchEnabled": model_to_config[request.model]["isWebSearchEnabled"],
-    }
-    headers = {
-        "User-Agent": get_user_agent(device_id),
-        "Accept": "*/*",
-        "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
-        "Referer": f"https://ai-chatbot.top/chat/{chat_id}",
-        "Content-Type": "application/json",
-        "currentTime": str(timestamp),
-        "sign": sign,
-        "Origin": "https://ai-chatbot.top",
-        "DNT": "1",
-        "Sec-GPC": "1",
-        "Connection": "keep-alive",
-        "Sec-Fetch-Dest": "empty",
-        "Sec-Fetch-Mode": "cors",
-        "Sec-Fetch-Site": "same-origin",
-        "Priority": "u=0",
-    }
-    cookies = {
-        '_ga_HVMZBNYJML': 'GS1.1.1742013194.1.1.1742013780.0.0.0',
-        '_ga': 'GA1.1.1029622546.1742013195',
-    }
-    _id = f"chatcmpl-{uuid.uuid4().hex}"
-    created = int(time.time())
-    logger.info(f"Starting non-stream response: chat_id={chat_id}, UA={headers['User-Agent']}")
-
-    async with httpx.AsyncClient(http2=True, timeout=900) as client:
-        response = await client.post(f"{api_domain}/api/chat", json=payload, headers=headers, cookies=cookies)
-
-    if response.status_code != 200:
-        logger.error(f"API error: status_code={response.status_code}")
-        return {"error": {"message": f"Error: HTTP {response.status_code}", "type": "invalid_request_error"}}
-    else:
-        contents = ''
-        think_content = ''
-        print(response.text)
-        for line in response.iter_lines():
-            line = line.strip()
-            if not line:
-                continue
-            if line.startswith("g:"):
-                content = line[3:-1].replace('\\n', '\n')
-                think_content += content
-                continue
-            elif line.startswith("0:"):
-                if think_content:
-                    contents = '<think>' + think_content + '</think>'
-                    think_content = ''
-                content = line[3:-1].replace('\\n', '\n')
-                contents += content
-                continue
-            elif line.startswith("e:"):
-                continue
-            elif line.startswith("d:"):
-                continue
-            else:
-                continue
-        print({
-            "id": _id,
-            "object": "chat.completion",
-            "created": created,
-            "model": request.model,
-            "choices": [{"index": 0, "message": {"role": "assistant", "content": contents}, "finish_reason": None}],
-        })
-        return {
-            "id": _id,
-            "object": "chat.completion",
-            "created": created,
-            "model": request.model,
-            "choices": [{"index": 0, "message": {"role": "assistant", "content": contents}, "finish_reason": None}],
-        }
-
-
-# Endpoints
-@app.post("/v1/chat/completions")
-async def chat_completions(request: ChatCompletionRequest, _: str = Depends(verify_api_key)):
-    if request.model not in supported_models:
-        request.model = "DeepSeek-R1"
-    device_id = generate_device_id()
-    chat_id = await get_chat_id()
-    timestamp = int(time.time() * 1000)
-    sign = generate_sign(chat_id, timestamp)
-    logger.info(f"Chat request: model={request.model}, stream={request.stream}, chat_id={chat_id}")
-
-    if request.stream:
-        return StreamingResponse(stream_response(request, device_id, chat_id, timestamp, sign),
-                                 media_type="text/event-stream")
-    else:
-        # not_stream_response(request, device_id, chat_id, timestamp, sign)
-        return await not_stream_response(request, device_id, chat_id, timestamp, sign)
-
-
-@app.get("/v1/models")
-async def list_models(_: str = Depends(verify_api_key)):
-    current_time = int(time.time())
-    models = [
-        {
-            "id": model,
-            "object": "model",
-            "created": current_time,
-            "owned_by": "aichatbot",
-        } for model in supported_models
-    ]
-    logger.info("Returning model list")
-    return {"object": "list", "data": models}
-
-
-@app.get("/health")
-async def health_check():
-    chat_id = await get_chat_id()
-    return {"status": "ok", "session": "active" if chat_id else "inactive"}
-
-
-if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)

go.mod

@@ -0,0 +1,36 @@
+module aichatbot2api
+
+go 1.22
+
+require (
+	github.com/gin-gonic/gin v1.9.1
+	github.com/google/uuid v1.3.1
+	github.com/joho/godotenv v1.5.1
+)
+
+require (
+	github.com/bytedance/sonic v1.9.1 // indirect
+	github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.2 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-playground/validator/v10 v10.14.0 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.4 // indirect
+	github.com/leodido/go-urn v1.2.4 // indirect
+	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.0.8 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.11 // indirect
+	golang.org/x/arch v0.3.0 // indirect
+	golang.org/x/crypto v0.9.0 // indirect
+	golang.org/x/net v0.10.0 // indirect
+	golang.org/x/sys v0.8.0 // indirect
+	golang.org/x/text v0.9.0 // indirect
+	google.golang.org/protobuf v1.30.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -0,0 +1,90 @@
+github.com/bytedance/sonic v1.5.0/go.mod h1:ED5hyg4y6t3/9Ku1R6dU/4KyJ48DZ4jPhfY1O2AihPM=
+github.com/bytedance/sonic v1.9.1 h1:6iJ6NqdoxCDr6mbY8h18oSO+cShGSMRGCEo7F2h0x8s=
+github.com/bytedance/sonic v1.9.1/go.mod h1:i736AoUSYt75HyZLoJW9ERYxcy6eaN6h4BZXU064P/U=
+github.com/chenzhuoyu/base64x v0.0.0-20211019084208-fb5309c8db06/go.mod h1:DH46F32mSOjUmXrMHnKwZdA8wcEefY7UVqBKYGjpdQY=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311 h1:qSGYFH7+jGhDF8vLC+iwCD4WpbV1EBDSzWkJODFLams=
+github.com/chenzhuoyu/base64x v0.0.0-20221115062448-fe3a3abad311/go.mod h1:b583jCggY9gE99b6G5LEC39OIiVsWj+R97kbl5odCEk=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/gabriel-vasile/mimetype v1.4.2 h1:w5qFW6JKBz9Y393Y4q372O9A7cUSequkh1Q7OhCmWKU=
+github.com/gabriel-vasile/mimetype v1.4.2/go.mod h1:zApsH/mKG4w07erKIaJPFiX0Tsq9BFQgN3qGY5GnNgA=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.9.1 h1:4idEAncQnU5cB7BeOkPtxjfCSye0AAm1R0RVIqJ+Jmg=
+github.com/gin-gonic/gin v1.9.1/go.mod h1:hPrL7YrpYKXt5YId3A/Tnip5kqbEAP+KLuI3SUcPTeU=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.14.0 h1:vgvQWe3XCz3gIeFDm/HnTIbj6UGmg/+t63MyGU2n5js=
+github.com/go-playground/validator/v10 v10.14.0/go.mod h1:9iXMNT7sEkjXb0I+enO7QXmzG6QCsPWY4zveKFVRSyU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
+github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU=
+github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/uuid v1.3.1 h1:KjJaJ9iWZ3jOFZIf1Lqf4laDRCasjl0BCmnEGxkdLb4=
+github.com/google/uuid v1.3.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.4 h1:acbojRNwl3o09bUq+yDCtZFc1aiwaAAxtcn8YkZXnvk=
+github.com/klauspost/cpuid/v2 v2.2.4/go.mod h1:RVVoqg1df56z8g3pUjL/3lE5UfnlrJX8tyFgg4nqhuY=
+github.com/leodido/go-urn v1.2.4 h1:XlAE/cm/ms7TE/VMVoduSpNBoyc2dOxHs5MZSwAN63Q=
+github.com/leodido/go-urn v1.2.4/go.mod h1:7ZrI8mTSeBSHl/UaRyKQW1qZeMgak41ANeCNaVckg+4=
+github.com/mattn/go-isatty v0.0.19 h1:JITubQf0MOLdlGRuRq+jtsDlekdYPia9ZFsB8h/APPA=
+github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.0.8 h1:0ctb6s9mE31h0/lhu+J6OPmVeDxJn+kYnJc2jZR9tGQ=
+github.com/pelletier/go-toml/v2 v2.0.8/go.mod h1:vuYfssBdrU2XDZ9bYydBu6t+6a6PYNcZljzZR9VXg+4=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.3 h1:RP3t2pwF7cMEbC1dqtB6poj3niw/9gnV4Cjg5oW5gtY=
+github.com/stretchr/testify v1.8.3/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.11 h1:BMaWp1Bb6fHwEtbplGBGJ498wD+LKlNSl25MjdZY4dU=
+github.com/ugorji/go/codec v1.2.11/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.3.0 h1:02VY4/ZcO/gBOH6PUaoiptASxtXU10jazRCP865E97k=
+golang.org/x/arch v0.3.0/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/crypto v0.9.0 h1:LF6fAI+IutBocDJ2OT0Q1g8plpYljMZ4+lty+dsqw3g=
+golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0=
+golang.org/x/net v0.10.0 h1:X2//UzNDwYmtCLn7To6G58Wr6f5ahEAQgKNzv9Y951M=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/sys v0.0.0-20220704084225-05e143d24a9e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0 h1:EBmGv8NaZBZTWvrbjNoL6HVt+IVy3QDQpJs7VRIw3tU=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
+google.golang.org/protobuf v1.30.0 h1:kPPoIgf3TsEvrm0PFe15JQ+570QVxYzEvvHqChK+cng=
+google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqwMG9pJV4I=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=

main.go

@@ -0,0 +1,750 @@
+package main
+
+import (
+	"bufio"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"math/rand"
+	"net"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+	"github.com/joho/godotenv"
+)
+
+// Message 消息结构体，表示对话中的一条消息
+type Message struct {
+	Role    string `json:"role" binding:"required,oneof=system user assistant"`
+	Content string `json:"content" binding:"required"`
+}
+
+// ChatCompletionRequest 聊天完成请求结构体
+type ChatCompletionRequest struct {
+	Model            string    `json:"model"`
+	Messages         []Message `json:"messages"`
+	Stream           bool      `json:"stream"`
+	Temperature      float64   `json:"temperature"`
+	TopP             float64   `json:"top_p"`
+	PresencePenalty  float64   `json:"presence_penalty"`
+	FrequencyPenalty float64   `json:"frequency_penalty"`
+	MaxTokens        int       `json:"max_tokens"`
+}
+
+// Choice OpenAI 格式的选择结构体
+type Choice struct {
+	Index        int      `json:"index"`
+	Delta        *Delta   `json:"delta,omitempty"`
+	Message      *Message `json:"message,omitempty"`
+	FinishReason *string  `json:"finish_reason"`
+}
+
+// Delta 流式响应中的增量内容
+type Delta struct {
+	Role    string `json:"role,omitempty"`
+	Content string `json:"content,omitempty"`
+}
+
+// Usage 令牌使用统计
+type Usage struct {
+	PromptTokens     int `json:"prompt_tokens"`
+	CompletionTokens int `json:"completion_tokens"`
+	TotalTokens      int `json:"total_tokens"`
+}
+
+// ChatCompletionResponse OpenAI 格式的聊天响应
+type ChatCompletionResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+	Usage   *Usage   `json:"usage,omitempty"`
+}
+
+// ModelInfo 模型信息结构体
+type ModelInfo struct {
+	ID      string `json:"id"`
+	Object  string `json:"object"`
+	Created int64  `json:"created"`
+	OwnedBy string `json:"owned_by"`
+}
+
+// ModelList 模型列表结构体
+type ModelList struct {
+	Object string      `json:"object"`
+	Data   []ModelInfo `json:"data"`
+}
+
+var (
+	apiKey          string
+	enableCORS      bool
+	randomUA        bool
+	supportedModels = []string{"DeepSeek-R1", "DeepSeek-V3"}
+	modelToConfig   = map[string]map[string]interface{}{
+		"DeepSeek-R1": {"model": "deepseek-huoshan", "isWebSearchEnabled": false},
+		"DeepSeek-V3": {"model": "deepseek-guiji", "isWebSearchEnabled": false},
+	}
+	apiDomain     = "https://ai-chatbot.top"
+	defaultUA     = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0"
+	deviceUAMap   = make(map[string]string)
+	deviceUAMutex sync.Mutex
+
+	// 随机User-Agent列表
+	userAgents = []string{
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+		"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Edge/120.0.0.0",
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:136.0) Gecko/20100101 Firefox/136.0",
+	}
+
+	// 全局 HTTP 客户端配置，支持连接池和 HTTP/2
+	httpClient *http.Client
+
+	// chatID 缓存系统
+	chatIDCache struct {
+		sync.RWMutex
+		value     string
+		expiresAt time.Time
+	}
+
+	// chatID 获取的并发控制
+	chatIDFetching sync.Mutex
+)
+
+// initHTTPClient 初始化优化的 HTTP 客户端，支持连接池和长连接
+func initHTTPClient() {
+	transport := &http.Transport{
+		DialContext: (&net.Dialer{
+			Timeout:   10 * time.Second,
+			KeepAlive: 30 * time.Second,
+		}).DialContext,
+		ForceAttemptHTTP2:     true,
+		MaxIdleConns:          100,
+		MaxIdleConnsPerHost:   10,
+		IdleConnTimeout:       90 * time.Second,
+		TLSHandshakeTimeout:   10 * time.Second,
+		ExpectContinueTimeout: 1 * time.Second,
+		DisableKeepAlives:     false,
+	}
+
+	httpClient = &http.Client{
+		Transport: transport,
+		Timeout:   10 * time.Minute, // 10分钟超时支持长时间思考
+	}
+}
+
+// nanoid 生成指定长度的随机字符串
+func nanoid(size int) string {
+	alphabet := "abcdefgh0ijkl1mno2pqrs3tuv4wxyz5ABCDEFGH6IJKL7MNO8PQRS9TUV-WXYZ_"
+	b := make([]byte, size)
+	for i := range b {
+		b[i] = alphabet[rand.Intn(len(alphabet))]
+	}
+	return string(b)
+}
+
+// generateDeviceID 生成设备ID
+func generateDeviceID() string {
+	return fmt.Sprintf("%s_%s", uuid.New().String(), nanoid(20))
+}
+
+// getRandomUserAgent 获取随机User-Agent
+func getRandomUserAgent() string {
+	return userAgents[rand.Intn(len(userAgents))]
+}
+
+// getUserAgent 获取或生成用户代理字符串
+func getUserAgent(deviceID string) string {
+	if !randomUA {
+		return defaultUA
+	}
+
+	deviceUAMutex.Lock()
+	defer deviceUAMutex.Unlock()
+	if ua, ok := deviceUAMap[deviceID]; ok {
+		return ua
+	}
+	// 生成随机用户代理
+	randomUserAgent := getRandomUserAgent()
+	deviceUAMap[deviceID] = randomUserAgent
+	return randomUserAgent
+}
+
+// generateSign 生成签名用于API认证
+func generateSign(chatID string, timestamp int64) string {
+	msg := fmt.Sprintf("%s%d@!~chatbot.0868", chatID, timestamp)
+	hash := md5.Sum([]byte(msg))
+	return fmt.Sprintf("%x", hash)
+}
+
+// getChatID 获取聊天ID，支持缓存和并发控制
+func getChatID() (string, error) {
+	// 读取缓存
+	chatIDCache.RLock()
+	if time.Now().Before(chatIDCache.expiresAt) && chatIDCache.value != "" {
+		cachedID := chatIDCache.value
+		chatIDCache.RUnlock()
+		return cachedID, nil
+	}
+	chatIDCache.RUnlock()
+
+	// 使用互斥锁避免重复请求
+	chatIDFetching.Lock()
+	defer chatIDFetching.Unlock()
+
+	// 双重检查，可能在等待锁的过程中其他 goroutine 已经更新了缓存
+	chatIDCache.RLock()
+	if time.Now().Before(chatIDCache.expiresAt) && chatIDCache.value != "" {
+		cachedID := chatIDCache.value
+		chatIDCache.RUnlock()
+		return cachedID, nil
+	}
+	chatIDCache.RUnlock()
+
+	// 使用全局 HTTP 客户端获取新的 chatID
+	req, _ := http.NewRequest("GET", apiDomain+"/", nil)
+	req.Header.Set("User-Agent", defaultUA)
+	req.Header.Set("Accept", "*/*")
+	req.Header.Set("Accept-Language", "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2")
+	req.Header.Set("Referer", "https://ai-chatbot.top/")
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return "", err
+	}
+	defer resp.Body.Close()
+
+	body, _ := io.ReadAll(resp.Body)
+	reg := regexp.MustCompile(`[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-4[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}`)
+	ids := reg.FindAllString(string(body), -1)
+	if len(ids) == 0 {
+		return "", fmt.Errorf("no chat id found")
+	}
+
+	chatID := ids[len(ids)-1]
+
+	// 更新缓存
+	chatIDCache.Lock()
+	chatIDCache.value = chatID
+	chatIDCache.expiresAt = time.Now().Add(5 * time.Minute)
+	chatIDCache.Unlock()
+
+	return chatID, nil
+}
+
+// preloadChatID 异步预取 chatID，在缓存过期前自动刷新
+func preloadChatID() {
+	go func() {
+		for {
+			// 在缓存过期前 1 分钟刷新
+			sleepDuration := 4 * time.Minute
+			if !chatIDCache.expiresAt.IsZero() {
+				timeToExpiry := time.Until(chatIDCache.expiresAt)
+				if timeToExpiry > time.Minute {
+					sleepDuration = timeToExpiry - time.Minute
+				}
+			}
+
+			time.Sleep(sleepDuration)
+			getChatID() // 刷新缓存
+		}
+	}()
+}
+
+// ChatbotFinish ai-chatbot.top 的结束信息结构
+type ChatbotFinish struct {
+	FinishReason string `json:"finishReason"`
+	Usage        Usage  `json:"usage"`
+	IsContinued  bool   `json:"isContinued"`
+}
+
+// parseChatbotLine 解析 ai-chatbot.top 响应的单行内容
+func parseChatbotLine(line string) (string, string, error) {
+	if len(line) < 2 {
+		return "", "", fmt.Errorf("line too short")
+	}
+
+	colonIndex := strings.Index(line, ":")
+	if colonIndex == -1 {
+		return "", "", fmt.Errorf("no colon found")
+	}
+
+	prefix := line[:colonIndex]
+	content := line[colonIndex+1:]
+
+	return prefix, content, nil
+}
+
+// handleStreamResponse 处理流式响应并转换为 OpenAI 格式
+func handleStreamResponse(resp *http.Response, c *gin.Context, model string) {
+	// 设置 SSE 响应头
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+
+	scanner := bufio.NewScanner(resp.Body)
+	created := time.Now().Unix()
+	chatID := fmt.Sprintf("chatcmpl-%s", nanoid(29))
+	thinking := false
+
+	// 首先发送一个空chunk，兼容SSE客户端
+	chunk := ChatCompletionResponse{
+		ID:      chatID,
+		Object:  "chat.completion.chunk",
+		Created: created,
+		Model:   model,
+		Choices: []Choice{{
+			Index:        0,
+			Delta:        &Delta{Content: ""},
+			FinishReason: nil,
+		}},
+	}
+	jsonData, _ := json.Marshal(chunk)
+	fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+	c.Writer.(http.Flusher).Flush()
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		prefix, content, err := parseChatbotLine(line)
+		if err != nil {
+			continue
+		}
+
+		switch prefix {
+		case "f":
+			// 忽略 messageId，OpenAI 不需要这个
+			continue
+		case "g":
+			// 思考过程内容
+			if !thinking {
+				thinking = true
+				// 发送 <think> 开始标记
+				chunk := ChatCompletionResponse{
+					ID:      chatID,
+					Object:  "chat.completion.chunk",
+					Created: created,
+					Model:   model,
+					Choices: []Choice{{
+						Index:        0,
+						Delta:        &Delta{Content: "<think>"},
+						FinishReason: nil,
+					}},
+				}
+				jsonData, _ := json.Marshal(chunk)
+				fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+				c.Writer.(http.Flusher).Flush()
+			}
+
+			var contentStr string
+			if err := json.Unmarshal([]byte(content), &contentStr); err != nil {
+				continue
+			}
+			contentStr = strings.ReplaceAll(contentStr, "\\n", "\n")
+
+			chunk := ChatCompletionResponse{
+				ID:      chatID,
+				Object:  "chat.completion.chunk",
+				Created: created,
+				Model:   model,
+				Choices: []Choice{{
+					Index:        0,
+					Delta:        &Delta{Content: contentStr},
+					FinishReason: nil,
+				}},
+			}
+
+			jsonData, _ := json.Marshal(chunk)
+			fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+			c.Writer.(http.Flusher).Flush()
+
+		case "0":
+			// 最终回答内容
+			if thinking {
+				thinking = false
+				// 发送 </think> 结束标记
+				chunk := ChatCompletionResponse{
+					ID:      chatID,
+					Object:  "chat.completion.chunk",
+					Created: created,
+					Model:   model,
+					Choices: []Choice{{
+						Index:        0,
+						Delta:        &Delta{Content: "</think>"},
+						FinishReason: nil,
+					}},
+				}
+				jsonData, _ := json.Marshal(chunk)
+				fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+				c.Writer.(http.Flusher).Flush()
+			}
+
+			var contentStr string
+			if err := json.Unmarshal([]byte(content), &contentStr); err != nil {
+				continue
+			}
+			contentStr = strings.ReplaceAll(contentStr, "\\n", "\n")
+
+			chunk := ChatCompletionResponse{
+				ID:      chatID,
+				Object:  "chat.completion.chunk",
+				Created: created,
+				Model:   model,
+				Choices: []Choice{{
+					Index:        0,
+					Delta:        &Delta{Content: contentStr},
+					FinishReason: nil,
+				}},
+			}
+
+			jsonData, _ := json.Marshal(chunk)
+			fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+			c.Writer.(http.Flusher).Flush()
+
+		case "e", "d":
+			// 结束信息
+			if thinking {
+				// 如果还在思考模式，发送结束标记
+				chunk := ChatCompletionResponse{
+					ID:      chatID,
+					Object:  "chat.completion.chunk",
+					Created: created,
+					Model:   model,
+					Choices: []Choice{{
+						Index:        0,
+						Delta:        &Delta{Content: "</think>"},
+						FinishReason: nil,
+					}},
+				}
+				jsonData, _ := json.Marshal(chunk)
+				fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+				c.Writer.(http.Flusher).Flush()
+			}
+
+			var finishInfo ChatbotFinish
+			if err := json.Unmarshal([]byte(content), &finishInfo); err != nil {
+				continue
+			}
+
+			finishReason := finishInfo.FinishReason
+			chunk := ChatCompletionResponse{
+				ID:      chatID,
+				Object:  "chat.completion.chunk",
+				Created: created,
+				Model:   model,
+				Choices: []Choice{{
+					Index:        0,
+					Delta:        &Delta{},
+					FinishReason: &finishReason,
+				}},
+				Usage: &Usage{
+					PromptTokens:     finishInfo.Usage.PromptTokens,
+					CompletionTokens: finishInfo.Usage.CompletionTokens,
+					TotalTokens:      finishInfo.Usage.PromptTokens + finishInfo.Usage.CompletionTokens,
+				},
+			}
+
+			jsonData, _ := json.Marshal(chunk)
+			fmt.Fprintf(c.Writer, "data: %s\n\n", jsonData)
+			c.Writer.(http.Flusher).Flush()
+
+			// 发送 [DONE] 信号
+			fmt.Fprintf(c.Writer, "data: [DONE]\n\n")
+			c.Writer.(http.Flusher).Flush()
+			return
+		}
+	}
+}
+
+// handleNonStreamResponse 处理非流式响应并转换为 OpenAI 格式
+func handleNonStreamResponse(resp *http.Response, c *gin.Context, model string) {
+	scanner := bufio.NewScanner(resp.Body)
+	created := time.Now().Unix()
+	chatID := fmt.Sprintf("chatcmpl-%s", nanoid(29))
+
+	var fullContent strings.Builder
+	var thinkContent strings.Builder
+	var usage *Usage
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" {
+			continue
+		}
+
+		prefix, content, err := parseChatbotLine(line)
+		if err != nil {
+			continue
+		}
+
+		switch prefix {
+		case "g":
+			// 思考过程内容
+			var contentStr string
+			if err := json.Unmarshal([]byte(content), &contentStr); err != nil {
+				continue
+			}
+			contentStr = strings.ReplaceAll(contentStr, "\\n", "\n")
+			thinkContent.WriteString(contentStr)
+
+		case "0":
+			// 最终回答内容
+			if thinkContent.Len() > 0 {
+				fullContent.WriteString("<think>")
+				fullContent.WriteString(thinkContent.String())
+				fullContent.WriteString("</think>")
+				thinkContent.Reset()
+			}
+
+			var contentStr string
+			if err := json.Unmarshal([]byte(content), &contentStr); err != nil {
+				continue
+			}
+			contentStr = strings.ReplaceAll(contentStr, "\\n", "\n")
+			fullContent.WriteString(contentStr)
+
+		case "e", "d":
+			// 结束信息
+			var finishInfo ChatbotFinish
+			if err := json.Unmarshal([]byte(content), &finishInfo); err != nil {
+				continue
+			}
+
+			usage = &Usage{
+				PromptTokens:     finishInfo.Usage.PromptTokens,
+				CompletionTokens: finishInfo.Usage.CompletionTokens,
+				TotalTokens:      finishInfo.Usage.PromptTokens + finishInfo.Usage.CompletionTokens,
+			}
+			break
+		}
+	}
+
+	// 如果还有未处理的思考内容，添加到最终内容中
+	if thinkContent.Len() > 0 {
+		fullContent.WriteString("<think>")
+		fullContent.WriteString(thinkContent.String())
+		fullContent.WriteString("</think>")
+	}
+
+	response := ChatCompletionResponse{
+		ID:      chatID,
+		Object:  "chat.completion",
+		Created: created,
+		Model:   model,
+		Choices: []Choice{{
+			Index: 0,
+			Message: &Message{
+				Role:    "assistant",
+				Content: fullContent.String(),
+			},
+			FinishReason: func() *string { s := "stop"; return &s }(),
+		}},
+		Usage: usage,
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+// verifyAPIKey API密钥验证中间件
+func verifyAPIKey(c *gin.Context) {
+	key := c.GetHeader("Authorization")
+	fmt.Printf("[DEBUG] Authorization header: '%s'\n", key)
+	fmt.Printf("[DEBUG] apiKey: '%s'\n", apiKey)
+
+	if key == "" {
+		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"detail": "Missing Authorization header"})
+		return
+	}
+
+	if strings.HasPrefix(key, "Bearer ") {
+		key = strings.TrimSpace(strings.TrimPrefix(key, "Bearer "))
+	}
+
+	fmt.Printf("[DEBUG] Processed key: '%s'\n", key)
+
+	if key != apiKey {
+		fmt.Printf("[DEBUG] Key comparison failed: '%s' != '%s'\n", key, apiKey)
+		c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"detail": "Invalid API key"})
+		return
+	}
+
+	fmt.Println("[DEBUG] API key verification passed!")
+	c.Next()
+}
+
+// main 主函数，初始化并启动服务器
+func main() {
+	_ = godotenv.Load()
+	apiKey = os.Getenv("API_KEY")
+	fmt.Println("[DEBUG] Loaded API_KEY:", apiKey)
+	if apiKey == "" {
+		log.Fatal("API_KEY not found in .env file")
+	}
+
+	// 读取RANDOM_UA环境变量
+	randomUAStr := strings.ToLower(os.Getenv("RANDOM_UA"))
+	randomUA = randomUAStr == "true" || randomUAStr == "1" || randomUAStr == "yes"
+	fmt.Println("[DEBUG] RANDOM_UA enabled:", randomUA)
+
+	// 初始化优化的 HTTP 客户端
+	initHTTPClient()
+
+	// 启动异步 chatID 预加载
+	preloadChatID()
+
+	enableCORS = true
+	gin.SetMode(gin.ReleaseMode)
+	r := gin.Default()
+
+	// CORS 中间件配置
+	if enableCORS {
+		r.Use(func(c *gin.Context) {
+			c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+			c.Writer.Header().Set("Access-Control-Allow-Methods", "*")
+			c.Writer.Header().Set("Access-Control-Allow-Headers", "*")
+			if c.Request.Method == "OPTIONS" {
+				c.AbortWithStatus(204)
+				return
+			}
+			c.Next()
+		})
+	}
+
+	// 健康检查端点不需要 API 验证
+	r.GET("/health", func(c *gin.Context) {
+		chatID, err := getChatID()
+		status := "inactive"
+		if err == nil && chatID != "" {
+			status = "active"
+		}
+		c.JSON(http.StatusOK, gin.H{"status": "ok", "session": status})
+	})
+
+	// 需要 API 验证的端点组
+	authorized := r.Group("/")
+	authorized.Use(verifyAPIKey)
+
+	// 聊天完成接口
+	authorized.POST("/v1/chat/completions", func(c *gin.Context) {
+		var req ChatCompletionRequest
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+			return
+		}
+		if !contains(supportedModels, req.Model) {
+			req.Model = "DeepSeek-R1"
+		}
+		deviceID := generateDeviceID()
+		chatID, err := getChatID()
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to get chat id"})
+			return
+		}
+		timestamp := time.Now().UnixNano() / 1e6
+		sign := generateSign(chatID, timestamp)
+
+		// 构造请求载荷
+		messages := []map[string]string{}
+		for _, m := range req.Messages {
+			messages = append(messages, map[string]string{"role": m.Role, "content": m.Content})
+		}
+		payload := map[string]interface{}{
+			"id":                    chatID,
+			"messages":              messages,
+			"selectedChatModel":     modelToConfig[req.Model]["model"],
+			"isDeepThinkingEnabled": true,
+			"isWebSearchEnabled":    modelToConfig[req.Model]["isWebSearchEnabled"],
+		}
+
+		// 构造请求头
+		headers := map[string]string{
+			"User-Agent":      getUserAgent(deviceID),
+			"Accept":          "*/*",
+			"Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
+			"Referer":         "https://ai-chatbot.top/chat/" + chatID,
+			"Content-Type":    "application/json",
+			"currentTime":     fmt.Sprintf("%d", timestamp),
+			"sign":            sign,
+			"Origin":          "https://ai-chatbot.top",
+			"DNT":             "1",
+			"Sec-GPC":         "1",
+			"Connection":      "keep-alive",
+			"Sec-Fetch-Dest":  "empty",
+			"Sec-Fetch-Mode":  "cors",
+			"Sec-Fetch-Site":  "same-origin",
+			"Priority":        "u=0",
+		}
+
+		// 构造cookies
+		cookies := []*http.Cookie{
+			{Name: "_ga_HVMZBNYJML", Value: "GS1.1.1742013194.1.1.1742013780.0.0.0"},
+			{Name: "_ga", Value: "GA1.1.1029622546.1742013195"},
+		}
+
+		// 使用全局 HTTP 客户端发送请求
+		jsonBytes, _ := json.Marshal(payload)
+		req2, _ := http.NewRequest("POST", apiDomain+"/api/chat", strings.NewReader(string(jsonBytes)))
+		for k, v := range headers {
+			req2.Header.Set(k, v)
+		}
+		for _, ck := range cookies {
+			req2.AddCookie(ck)
+		}
+
+		resp, err := httpClient.Do(req2)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to call ai-chatbot.top"})
+			return
+		}
+		defer resp.Body.Close()
+
+		// 根据 stream 参数选择处理方式
+		if req.Stream {
+			handleStreamResponse(resp, c, req.Model)
+		} else {
+			handleNonStreamResponse(resp, c, req.Model)
+		}
+	})
+
+	// 模型列表接口
+	authorized.GET("/v1/models", func(c *gin.Context) {
+		currentTime := time.Now().Unix()
+		models := []ModelInfo{}
+		for _, m := range supportedModels {
+			models = append(models, ModelInfo{
+				ID:      m,
+				Object:  "model",
+				Created: currentTime,
+				OwnedBy: "aichatbot",
+			})
+		}
+		c.JSON(http.StatusOK, ModelList{Object: "list", Data: models})
+	})
+
+	r.Run(":7860")
+}
+
+// contains 检查字符串数组中是否包含指定字符串
+func contains(arr []string, s string) bool {
+	for _, v := range arr {
+		if v == s {
+			return true
+		}
+	}
+	return false
+}

main.ts

@@ -1,679 +0,0 @@
-import { serve } from "https://deno.land/std@0.140.0/http/server.ts";
-import { Md5 } from "https://deno.land/std@0.140.0/hash/md5.ts";
-
-const API_DOMAIN = 'https://ai-api.dangbei.net';
-const USER_AGENTS = [
-  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
-  'Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1',
-  'Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1'
-];
-const VALID_API_KEY = Deno.env.get('VALID_API_KEY');
-const MAX_CONVERSATIONS_PER_DEVICE = 10;  //  每个设备最多创建的会话数 
-
-class ChatManage {
-  private currentDeviceId: string | null = null;
-  private currentConversationId: string | null = null;
-  private conversationCount = 0;
-  private currentUserAgent: string;
-
-  constructor() {
-    this.currentUserAgent = this.getRandomUserAgent();
-  }
-
-  private getRandomUserAgent(): string {
-    return USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)];
-  }
-
-  getOrCreateIds(forceNew = false) {
-    let newDeviceId = this.currentDeviceId;
-    let newConversationId = this.currentConversationId;
-  
-    if (forceNew || !newDeviceId || this.conversationCount >= MAX_CONVERSATIONS_PER_DEVICE) {
-      newDeviceId = this.generateDeviceId();
-      newConversationId = null;
-      this.conversationCount = 0;
-      // 在生成新设备ID时更新 User-Agent
-      this.currentUserAgent = this.getRandomUserAgent();
-    }
-  
-    this.currentDeviceId = newDeviceId;
-    this.currentConversationId = newConversationId;
-  
-    return {
-      deviceId: newDeviceId,
-      conversationId: newConversationId,
-      userAgent: this.currentUserAgent
-    };
-  }
-
-  updateConversationId(conversationId: string) {
-    this.currentConversationId = conversationId;
-    this.conversationCount++;
-  }
-  
-  generateDeviceId() {
-    const uuid = crypto.randomUUID();
-    const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-    const nanoid = Array.from(crypto.getRandomValues(new Uint8Array(20)))
-      .map(b => urlAlphabet[b % urlAlphabet.length])
-      .join('');
-    return `${uuid.replace(/-/g, '')}_${nanoid}`;
-  }
-}
-
-class Pipe {
-  private dataPrefix = 'data:';
-  private chatManage = new ChatManage();
-  private searchModels: Record<string, string> = {
-    'DeepSeek-R1-Search': 'deepseek',
-    'DeepSeek-V3-Search': 'deepseek',
-    'Doubao-Search': 'doubao',
-    'Qwen-Search': 'qwen'
-  };
-
-  // 创建新的会话
-  async _create_conversation(deviceId: string) {
-    const { userAgent } = this.chatManage.getOrCreateIds(false);
-    const payload = { botCode: "AI_SEARCH" };
-    const timestamp = Math.floor(Date.now() / 1000).toString();
-    const nonce = this.nanoid(21);
-    const sign = await this.generateSign(timestamp, payload, nonce);
-
-    const headers = {
-      "Origin": "https://ai.dangbei.com",
-      "Referer": "https://ai.dangbei.com/",
-      "User-Agent": userAgent,
-      "deviceId": deviceId,
-      "nonce": nonce,
-      "sign": sign,
-      "timestamp": timestamp,
-      "Content-Type": "application/json"
-    };
-
-    try {
-      console.log('Creating conversation with:', {
-        url: `${API_DOMAIN}/ai-search/conversationApi/v1/create`,
-        headers,
-        payload
-      });
-
-      const response = await fetch(`${API_DOMAIN}/ai-search/conversationApi/v1/create`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(payload),
-      });
-
-      console.log('Response status:', response.status);
-      const responseText = await response.text();
-      console.log('Response body:', responseText);
-
-      if (response.ok) {
-        try {
-          const data = JSON.parse(responseText);
-          if (data.success) {
-            console.log('Successfully created conversation:', data.data.conversationId);
-            return data.data.conversationId;
-          } else {
-            console.error('API returned success: false:', data);
-          }
-        } catch (e) {
-          console.error('Failed to parse response:', e);
-        }
-      } else {
-        console.error('HTTP error:', response.status, responseText);
-      }
-    } catch (e) {
-      console.error('Error creating conversation:', e);
-    }
-    return null;
-  }
-
-  // 新增方法：构建完整提示
-  _buildFullPrompt(messages: any[]): string {
-    if (!messages || messages.length === 0) {
-      return '';
-    }
-
-    let systemPrompt = '';
-    const history: string[] = [];
-    let lastUserMessage = '';
-
-    for (const msg of messages) {
-      if (msg.role === 'system' && !systemPrompt) {
-        systemPrompt = msg.content;
-      } else if (msg.role === 'user') {
-        history.push(`user: ${msg.content}`);
-        lastUserMessage = msg.content;
-      } else if (msg.role === 'assistant') {
-        history.push(`assistant: ${msg.content}`);
-      }
-    }
-
-    const parts: string[] = [];
-    if (systemPrompt) {
-      parts.push(`[System Prompt]\n${systemPrompt}`);
-    }
-    if (history.length > 1) {
-      parts.push(`[Chat History]\n${history.slice(0, -1).join('\n')}`);
-    }
-    parts.push(`[Question]\n${lastUserMessage}`);
-
-    return parts.join('\n\n');
-  }
-
-  async* pipe(body: any) {
-    const thinkingState = { thinking: -1 };
-    
-    // Build full prompt
-    const fullPrompt = this._buildFullPrompt(body.messages);
-    
-    // Check if we need to force new conversation
-    let forceNew = false;
-    const messages = body.messages;
-    if (messages.length === 1) {
-      forceNew = true;
-    } else if (messages.length >= 2) {
-      const lastTwo = messages.slice(-2);
-      if (lastTwo[0].role === 'user' && lastTwo[1].role === 'user') {
-        forceNew = true;
-      }
-    }
-
-    // Get or create device ID and conversation ID with User-Agent
-    const { deviceId, conversationId: storedConversationId, userAgent } = this.chatManage.getOrCreateIds(forceNew);
-    let conversationId = storedConversationId;
-
-    // Create new conversation if needed
-    if (!conversationId) {
-      conversationId = await this._create_conversation(deviceId);
-      if (!conversationId) {
-        yield { error: 'Failed to create conversation' };
-        return;
-      }
-      this.chatManage.updateConversationId(conversationId);
-    }
-
-    // Model name handling
-    let modelName;
-    const isSearchModel = body.model.endsWith('-Search');
-    if (isSearchModel) {
-      modelName = this.searchModels[body.model] || body.model.replace('-Search', '').toLowerCase();
-    } else {
-      const isDeepSeekModel = ['DeepSeek-R1', 'DeepSeek-V3'].includes(body.model);
-      modelName = isDeepSeekModel ? 'deepseek' : body.model.toLowerCase();
-    }
-
-    // 确定 userAction 参数
-    let userAction = '';
-    if (body.model.includes('DeepSeek-R1')) {
-      userAction = 'deep';
-    }
-    if (isSearchModel) {
-      userAction = userAction ? `${userAction},online` : 'online';
-    }
-
-    const payload = {
-      stream: true,
-      botCode: 'AI_SEARCH',
-      userAction,
-      model: modelName,
-      conversationId: conversationId,
-      question: fullPrompt,
-    };
-
-    const timestamp = Math.floor(Date.now() / 1000).toString();
-    const nonce = this.nanoid(21);
-    const sign = await this.generateSign(timestamp, payload, nonce);
-
-    const headers = {
-      'Origin': 'https://ai.dangbei.com',
-      'Referer': 'https://ai.dangbei.com/',
-      'User-Agent': userAgent,
-      'deviceId': deviceId,
-      'nonce': nonce,
-      'sign': sign,
-      'timestamp': timestamp,
-      'Content-Type': 'application/json',
-    };
-
-    try {
-      const response = await fetch(`${API_DOMAIN}/ai-search/chatApi/v1/chat`, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(payload),
-      });
-
-      if (!response.ok) {
-        const error = await response.text();
-        console.error('HTTP Error:', response.status, error);
-        yield { error: `HTTP ${response.status}: ${error}` };
-        return;
-      }
-
-      const reader = response.body!.getReader();
-      const decoder = new TextDecoder();
-      let buffer = '';
-      let cardMessages: string[] = [];
-
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split('\n');
-        buffer = lines.pop() || '';
-
-        for (const line of lines) {
-          if (!line.startsWith(this.dataPrefix)) continue;
-
-          try {
-            const data = JSON.parse(line.slice(this.dataPrefix.length));
-            if (data.type === 'answer') {
-              const content = data.content;
-              const contentType = data.content_type;
-
-              if (thinkingState.thinking === -1 && contentType === 'thinking') {
-                thinkingState.thinking = 0;
-                yield { choices: [{ delta: { content: '<think>\n\n' }, finish_reason: null }] };
-              } else if (thinkingState.thinking === 0 && contentType === 'text') {
-                thinkingState.thinking = 1;
-                yield { choices: [{ delta: { content: '\n' }, finish_reason: null }] };
-                yield { choices: [{ delta: { content: '</think>' }, finish_reason: null }] };
-                yield { choices: [{ delta: { content: '\n\n' }, finish_reason: null }] };
-              }
-
-              if (contentType === 'card') {
-                try {
-                  const cardContent = JSON.parse(content);
-                  const cardItems = cardContent.cardInfo.cardItems;
-                  let markdownOutput = '\n\n---\n\n';
-
-                  const searchKeywords = cardItems.find((item: any) => item.type === '2001');
-                  if (searchKeywords) {
-                    const keywords = JSON.parse(searchKeywords.content);
-                    markdownOutput += `搜索关键字：${keywords.join('; ')}\n\n`;
-                  }
-
-                  const searchResults = cardItems.find((item: any) => item.type === '2002');
-                  if (searchResults) {
-                    const results = JSON.parse(searchResults.content);
-                    markdownOutput += `共找到 ${results.length} 个搜索结果：\n\n`;
-                    
-                    results.forEach((result: any) => {
-                      markdownOutput += `[${result.idIndex}] [${result.name}](${result.url})  来源：${result.siteName}\n`;
-                    });
-                  }
-
-                  cardMessages.push(markdownOutput);
-                } catch (e) {
-                  console.error('Error processing card:', e);
-                }
-              }
-
-              if (content && (contentType === 'text' || contentType === 'thinking')) {
-                yield { choices: [{ delta: { content }, finish_reason: null }] };
-              }
-            }
-          } catch (e) {
-            console.error('Parse error:', e, 'Line:', line);
-            yield { error: `JSONDecodeError: ${(e as Error).message}` };
-            return;
-          }
-        }
-      }
-
-      if (cardMessages.length > 0) {
-        yield { choices: [{ delta: { content: cardMessages.join('') }, finish_reason: null }] };
-      }
-
-      yield {
-        choices: [{
-          delta: {
-            meta: {
-              device_id: deviceId,
-              conversation_id: conversationId
-            }
-          },
-          finish_reason: null
-        }]
-      };
-
-    } catch (e) {
-      console.error('Error in pipe:', e);
-      yield { error: `${(e as Error).name}: ${(e as Error).message}` };
-    }
-  }
-
-  nanoid(size = 21) {
-    const urlAlphabet = 'useandom26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-    const bytes = new Uint8Array(size);
-    crypto.getRandomValues(bytes);
-    return Array.from(bytes).reverse().map(b => urlAlphabet[b & 63]).join('');
-  }
-
-  async generateSign(timestamp: string, payload: any, nonce: string) {
-    const payloadStr = JSON.stringify(payload);
-    const signStr = `${timestamp}${payloadStr}${nonce}`;
-    console.log('Sign string:', signStr);
-    
-    // 使用 Deno 标准库的 MD5
-    const sign = new Md5()
-      .update(signStr)
-      .toString()
-      .toUpperCase();
-    
-    console.log('Generated sign:', sign);
-    return sign;
-  }
-}
-
-const pipe = new Pipe();
-
-// 验证 API 密钥
-function verifyApiKey(request: Request) {
-  const authorization = request.headers.get('Authorization');
-    // 检查环境变量是否配置
-    if (!VALID_API_KEY) {
-      return new Response(JSON.stringify({ error: 'API key not configured' }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-      });
-    }
-    
-  if (!authorization) {
-    return new Response(JSON.stringify({ error: 'Missing API key' }), {
-      status: 401,
-      headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-      },
-    });
-  }
-
-  const apiKey = authorization.replace('Bearer ', '').trim();
-  if (apiKey !== VALID_API_KEY) {
-        return new Response(JSON.stringify({ error: 'Invalid API key' }), {
-          status: 401,
-          headers: {
-            'Content-Type': 'application/json',
-            'Access-Control-Allow-Origin': '*',
-          },
-        });
-      }
-
-  return null;
-}
-
-async function handleRequest(request: Request) {
-  const url = new URL(request.url);
-
-  // 添加根路径处理
-  if (request.method === 'GET' && url.pathname === '/') {
-    return new Response("it's work!", {
-      headers: {
-        'Content-Type': 'text/plain',
-        'Access-Control-Allow-Origin': '*',
-      },
-    });
-  }
-
-  if (request.method === 'OPTIONS') {
-    return new Response(null, {
-      headers: {
-        'Access-Control-Allow-Origin': '*',
-        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
-        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-      },
-    });
-  }
-
-  // 验证 API 密钥（除了 OPTIONS 请求）
-  const authError = verifyApiKey(request);
-  if (authError) return authError;
-
-  if (request.method === 'GET' && url.pathname === '/v1/models') {
-    const currentTime = Math.floor(Date.now() / 1000);
-    return new Response(JSON.stringify({
-      object: 'list',
-      data: [
-        // Original models
-        {
-          id: 'DeepSeek-R1',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        {
-          id: 'DeepSeek-V3',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        {
-          id: 'Doubao',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        {
-          id: 'Qwen',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        {
-          id: 'Glm3',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        {
-          id: 'Moonshot_v1',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library'
-        },
-        // Search-enabled models
-        {
-          id: 'DeepSeek-R1-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        },
-        {
-          id: 'DeepSeek-V3-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        },
-        {
-          id: 'Doubao-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        },
-        {
-          id: 'Qwen-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        },
-        {
-          id: 'Glm3-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        },
-        {
-          id: 'Moonshot_v1-Search',
-          object: 'model',
-          created: currentTime,
-          owned_by: 'library',
-          features: ['online_search']
-        }
-      ]
-    }), {
-      headers: {
-        'Content-Type': 'application/json',
-        'Access-Control-Allow-Origin': '*',
-      },
-    });
-  }
-
-  if (request.method === 'POST' && url.pathname === '/v1/chat/completions') {
-    const body = await request.json();
-    const isStream = body.stream || false;
-
-    if (isStream) {
-      const stream = new ReadableStream({
-        async start(controller) {
-          try {
-            for await (const chunk of pipe.pipe(body)) {
-              controller.enqueue(new TextEncoder().encode(`data: ${JSON.stringify(chunk)}\n\n`));
-            }
-            controller.enqueue(new TextEncoder().encode('data: [DONE]\n\n'));
-            controller.close();
-          } catch (e) {
-            console.error('Error in stream:', e);
-            controller.error(e);
-          }
-        },
-      });
-
-      return new Response(stream, {
-        headers: {
-          'Content-Type': 'text/event-stream',
-          'Cache-Control': 'no-cache',
-          'Connection': 'keep-alive',
-          'Access-Control-Allow-Origin': '*',
-        },
-      });
-    }
-
-    if (!isStream) {
-      let content = '';
-      let meta = null;
-      let thinking_content: string[] = [];
-      let is_thinking = false;
-      
-      try {
-        for await (const chunk of pipe.pipe(body)) {
-          if (chunk.choices?.[0]?.delta?.content) {
-            const content_chunk = chunk.choices[0].delta.content;
-            if (content_chunk === '<think>\n\n') {
-              is_thinking = true;
-            } else if (content_chunk === '\n</think>\n\n') {
-              is_thinking = false;
-            } else if (is_thinking) {
-              thinking_content.push(content_chunk);
-            } else {
-              content += content_chunk;
-            }
-          }
-          if (chunk.choices?.[0]?.delta?.meta) {
-            meta = chunk.choices[0].delta.meta;
-          }
-        }
-
-        // 处理思考内容
-        const reasoningContent = thinking_content.join('');
-        
-        return new Response(JSON.stringify({
-          id: crypto.randomUUID(),
-          object: 'chat.completion',
-          created: Math.floor(Date.now() / 1000),
-          model: body.model,
-          choices: [{
-            message: {
-              role: 'assistant',
-              reasoning_content: reasoningContent ? `<think>\n${reasoningContent}\n</think>` : '',
-              content: content.trim(),
-              meta: meta
-            },
-            finish_reason: 'stop'
-          }]
-        } as NonStreamResponse), {
-          headers: {
-            'Content-Type': 'application/json',
-            'Access-Control-Allow-Origin': '*',
-          },
-        });
-      } catch (e) {
-        console.error('Error processing chat request:', e);
-        return new Response(JSON.stringify({ error: 'Internal Server Error' }), {
-          status: 500,
-          headers: {
-            'Content-Type': 'application/json',
-            'Access-Control-Allow-Origin': '*',
-          },
-        });
-      }
-    }
-  }
-
-  return new Response('Not Found', { status: 404 });
-}
-
-serve(handleRequest, { port: 7860 });
-
-interface Message {
-  role: string;
-  content: string;
-}
-
-interface ChatRequest {
-  model: string;
-  messages: Message[];
-  stream: boolean;
-  temperature?: number;
-  top_p?: number;
-  n?: number;
-  max_tokens?: number;
-  presence_penalty?: number;
-  frequency_penalty?: number;
-  user?: string;
-}
-
-interface DeltaContent {
-  content?: string;
-  meta?: {
-    device_id: string;
-    conversation_id: string;
-  };
-}
-
-interface Choice {
-  delta: DeltaContent;
-  finish_reason: string | null;
-}
-
-interface StreamResponse {
-  choices?: Choice[];
-  error?: string;
-}
-
-interface NonStreamResponse {
-  id: string;
-  object: string;
-  created: number;
-  model: string;
-  choices: Array<{
-    message: {
-      role: string;
-      reasoning_content: string;
-      content: string;
-      meta: {
-        device_id: string;
-        conversation_id: string;
-      };
-    };
-    finish_reason: string;
-  }>;
-}

requirements.txt

@@ -1,8 +0,0 @@
-fastapi
-pydantic
-httpx[http2]
-uvicorn
-uuid
-python-dotenv
-fake-useragent
-httpx[socks]

version.py

@@ -1 +0,0 @@
-VERSION = '2025.05.10.0001'