Upload 4 files

Dockerfile

@@ -1,3 +1,35 @@
-FROM dangbei/api-proxy:latest
-EXPOSE 8000
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]
+# 使用 Python 3.11 作为基础镜像
+FROM python:3.11-slim
+
+# 设置为中国国内源（针对 Bookworm/Debian 12）
+RUN rm -rf /etc/apt/sources.list.d/* && \
+    echo "deb http://mirrors.ustc.edu.cn/debian bookworm main" > /etc/apt/sources.list && \
+    echo "deb http://mirrors.ustc.edu.cn/debian bookworm-updates main" >> /etc/apt/sources.list && \
+    echo "deb http://mirrors.ustc.edu.cn/debian-security bookworm-security main" >> /etc/apt/sources.list
+
+# 设置工作目录
+WORKDIR /app
+
+# 设置环境变量
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    POETRY_VERSION=1.6.1
+
+# 安装系统依赖
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends \
+        curl \
+        build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# 复制项目文件
+COPY . .
+
+# 安装 Python 依赖
+RUN pip install --no-cache-dir -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# 暴露端口
+EXPOSE 8000
+
+# 启动命令
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

README.md

@@ -1,11 +1,11 @@
----
-title: DangbeiAI
-emoji: 🔥
-colorFrom: pink
-colorTo: indigo
-sdk: docker
-pinned: false
-app_port: 8000
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: DangbeiAI
+emoji: 🔥
+colorFrom: pink
+colorTo: indigo
+sdk: docker
+pinned: false
+app_port: 3000
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,581 @@
+import secrets
+import time
+import uuid
+import hashlib
+import json
+import httpx
+import logging
+from typing import AsyncGenerator, List, Dict, Union
+from pydantic import BaseModel, Field
+from fastapi import FastAPI, HTTPException, Header
+from fastapi.responses import StreamingResponse
+from collections import OrderedDict
+from datetime import datetime
+import random,uvicorn
+
+# 设置日志记录
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# 配置
+class Config(BaseModel):
+    # API 密钥
+    API_KEY: str = Field(
+        default="sk_gUXNcLwm0rnnEt55Mg8hq88",
+        description="API key for authentication"
+    )
+    
+    # 最大历史记录数
+    MAX_HISTORY: int = Field(
+        default=30,
+        description="Maximum number of conversation histories to keep"
+    )
+    
+    # API 域名
+    API_DOMAIN: str = Field(
+        default="https://ai-api.dangbei.net",
+        description="API Domain for requests"
+    )
+    
+    # User Agents 列表
+    USER_AGENTS: List[str] = Field(
+        default=[
+            "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"
+        ],
+        description="List of User Agent strings for requests"
+    )
+
+    # 每个设备 ID 最大会话数
+    DEVICE_CONVERSATIONS_LIMIT: int = Field(
+        default=10,
+        description="Number of conversations before generating new device ID"
+    )
+
+# 创建全局配置实例
+config = Config()
+
+# 辅助函数：验证 API 密钥
+async def verify_api_key(authorization: str = Header(None)):
+    if not authorization:
+        raise HTTPException(status_code=401, detail="Missing API key")
+    
+    api_key = authorization.replace("Bearer ", "").strip()
+    if api_key != config.API_KEY:  # 使用配置中的 API_KEY
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    return api_key
+
+class Message(BaseModel):
+    role: str
+    content: str
+    
+    class Config:
+        # 允许额外的字段
+        extra = "allow"
+
+class ChatRequest(BaseModel):
+    model: str
+    messages: List[Union[dict, Message]]  # 允许字典或 Message 对象
+    stream: bool = False
+    
+    # 添加额外的可选字段，以适应更多的客户端请求
+    temperature: float | None = None
+    top_p: float | None = None
+    n: int | None = None
+    max_tokens: int | None = None
+    presence_penalty: float | None = None
+    frequency_penalty: float | None = None
+    user: str | None = None
+    
+    class Config:
+        # 允许额外的字段
+        extra = "allow"
+        # 允许从字典直接构造
+        arbitrary_types_allowed = True
+
+    @property
+    def messages_as_dicts(self) -> List[dict]:
+        """将消息转换为字典格式"""
+        return [
+            msg if isinstance(msg, dict) else msg.dict()
+            for msg in self.messages
+        ]
+
+class ChatHistory:
+    def __init__(self):
+        self.current_device_id = None
+        self.current_conversation_id = None
+        self.conversation_count = 0
+        self.total_conversations = 0  # 添加总会话计数
+
+    def get_or_create_ids(self, force_new=False) -> tuple[str, str]:
+        """
+        获取或创建新的 device_id 和 conversation_id
+        
+        Args:
+            force_new (bool): 是否强制创建新会话，用于清除上下文
+            
+        Returns:
+            tuple[str, str]: (device_id, conversation_id)
+        """
+        # 检查是否需要创建新的设备 ID
+        if (not self.current_device_id or 
+            self.total_conversations >= config.DEVICE_CONVERSATIONS_LIMIT):
+            self.current_device_id = self._generate_device_id()
+            self.current_conversation_id = None
+            self.conversation_count = 0
+            self.total_conversations = 0
+            logger.info(f"Generated new device ID: {self.current_device_id}")
+
+        # 如果强制新建会话（清除上下文）或没有当前会话 ID
+        if force_new or not self.current_conversation_id:
+            self.current_conversation_id = None
+            self.conversation_count = 0
+            logger.info("Forcing new conversation")
+
+        return self.current_device_id, self.current_conversation_id
+
+    def add_conversation(self, conversation_id: str):
+        """
+        添加新的对话记录
+        
+        Args:
+            conversation_id (str): 新的会话 ID
+        """
+        if not self.current_device_id:
+            return
+            
+        self.current_conversation_id = conversation_id
+        self.conversation_count += 1
+        self.total_conversations += 1
+        logger.info(f"Added conversation {conversation_id} (count: {self.conversation_count}, total: {self.total_conversations})")
+
+    def _generate_device_id(self) -> str:
+        """生成新的设备ID，并随机选择新的 USER_AGENT"""
+        # 随机选择新的 USER_AGENT
+        user_agent = random.choice(config.USER_AGENTS)
+        logger.info(f"Selected new User-Agent: {user_agent}")
+        
+        uuid_str = uuid.uuid4().hex
+        nanoid_str = ''.join(random.choices(
+            "useandom26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict",
+            k=20
+        ))
+        return f"{uuid_str}_{nanoid_str}"
+
+class Pipe:
+    def __init__(self):
+        self.data_prefix = "data:"
+        self.user_agent = random.choice(config.USER_AGENTS)  # 初始化时随机选择一个 USER_AGENT
+        self.chat_history = ChatHistory()
+        # 添加支持联网的模型映射，保持实际请求时使用小写
+        self.search_models = {
+            "DeepSeek-R1-Search": "deepseek",
+            "DeepSeek-V3-Search": "deepseek",
+            "Doubao-Search": "doubao",    # 显示用大写，映射用小写
+            "Qwen-Search": "qwen"         # 显示用大写，映射用小写
+        }
+
+    def _build_full_prompt(self, messages: List[Dict]) -> str:
+        """构建完整的提示，包含系统提示、聊天历史和当前问题"""
+        if not messages:
+            return ''
+            
+        system_prompt = ''
+        history = []
+        last_user_message = ''
+        
+        # 修改消息处理逻辑，直接使用字典访问
+        for msg in messages:
+            if msg['role'] == 'system' and not system_prompt:
+                system_prompt = msg['content']
+            elif msg['role'] == 'user':
+                history.append(f"user: {msg['content']}")
+                last_user_message = msg['content']
+            elif msg['role'] == 'assistant':
+                history.append(f"assistant: {msg['content']}")
+        
+        # 构建最终提示
+        parts = []
+        if system_prompt:
+            parts.append(f"[System Prompt]\n{system_prompt}")
+        if len(history) > 1:  # 如果有历史对话
+            parts.append(f"[Chat History]\n{chr(10).join(history[:-1])}")
+        parts.append(f"[Question]\n{last_user_message}")
+        
+        return chr(10).join(parts)
+
+    async def pipe(self, body: dict) -> AsyncGenerator[Dict, None]:
+        thinking_state = {"thinking": -1}
+        
+        try:
+            # 构建完整提示
+            full_prompt = self._build_full_prompt(body["messages"])
+            
+            # 修改 force_new_context 的判断逻辑
+            force_new_context = False
+            messages = body["messages"]
+            if len(messages) == 1:  # 只有一条消息时，说明是新对话
+                force_new_context = True
+            elif len(messages) >= 2:  # 检查是否清除了历史
+                last_two = messages[-2:]
+                if last_two[0]["role"] == "user" and last_two[1]["role"] == "user":
+                    force_new_context = True
+            
+            # 获取或创建设备ID和会话ID
+            device_id, conversation_id = self.chat_history.get_or_create_ids(force_new_context)
+            
+            # 添加会话信息日志
+            logger.info(f"Current session - Device ID: {device_id}, Conversation ID: {conversation_id}, Force new: {force_new_context}, Messages count: {len(messages)}")
+
+            # 如果没有会话ID，创建新的会话
+            if not conversation_id:
+                conversation_id = await self._create_conversation(device_id)
+                if not conversation_id:
+                    yield {"error": "Failed to create conversation"}
+                    return
+                # 保存新的对话记录
+                self.chat_history.add_conversation(conversation_id)
+                logger.info(f"Created new conversation: {conversation_id}")
+
+            # 模型名称处理
+            model_name = None
+            is_search_model = body["model"].endswith("-Search")
+            if is_search_model:
+                # 如果是搜索模型，使用映射的基础模型名
+                base_model = body["model"].replace("-Search", "")
+                model_name = self.search_models.get(body["model"], base_model.lower())
+            else:
+                # 非搜索模型使用原有逻辑
+                is_deepseek_model = body["model"] in ["DeepSeek-R1", "DeepSeek-V3"]
+                model_name = "deepseek" if is_deepseek_model else body["model"].lower()  # 确保转换为小写
+
+            # 确定 userAction 参数
+            user_action = ""
+            if "DeepSeek-R1" in body["model"]:
+                user_action = "deep"
+            if is_search_model:
+                # 如果已经有值，添加逗号分隔
+                if user_action:
+                    user_action += ",online"
+                else:
+                    user_action = "online"  # 为联网模型设置 userAction 为 "online"
+
+            payload = {
+                "stream": True,
+                "botCode": "AI_SEARCH",
+                "userAction": user_action,
+                "model": model_name,
+                "conversationId": conversation_id,
+                "question": full_prompt,
+            }
+
+            timestamp = str(int(time.time()))
+            nonce = self._nanoid(21)
+            sign = self._generate_sign(timestamp, payload, nonce)
+
+            headers = {
+                "Origin": "https://ai.dangbei.com",
+                "Referer": "https://ai.dangbei.com/",
+                "User-Agent": self.user_agent,
+                "deviceId": device_id,
+                "nonce": nonce,
+                "sign": sign,
+                "timestamp": timestamp,
+            }
+
+            api = f"{config.API_DOMAIN}/ai-search/chatApi/v1/chat"  # 使用配置中的 API_DOMAIN
+
+            async with httpx.AsyncClient() as client:
+                async with client.stream("POST", api, json=payload, headers=headers, timeout=1200) as response:
+                    if response.status_code != 200:
+                        error = await response.aread()
+                        yield {"error": self._format_error(response.status_code, error)}
+                        return
+
+                    card_messages = []  # 用于收集卡片消息
+                    
+                    async for line in response.aiter_lines():
+                        if not line.startswith(self.data_prefix):
+                            continue
+
+                        json_str = line[len(self.data_prefix):]
+
+                        try:
+                            data = json.loads(json_str)
+                        except json.JSONDecodeError as e:
+                            yield {"error": f"JSONDecodeError: {str(e)}", "data": json_str}
+                            return
+
+                        if data.get("type") == "answer":
+                            content = data.get("content")
+                            content_type = data.get("content_type")
+                            
+                            # 处理思考状态
+                            if thinking_state["thinking"] == -1 and content_type == "thinking":
+                                thinking_state["thinking"] = 0
+                                yield {"choices": [{"delta": {"content": "<think>\n\n"}, "finish_reason": None}]}
+                            elif thinking_state["thinking"] == 0 and content_type == "text":
+                                thinking_state["thinking"] = 1
+                                yield {"choices": [{"delta": {"content": "\n"}, "finish_reason": None}]}
+                                yield {"choices": [{"delta": {"content": "</think>"}, "finish_reason": None}]}
+                                yield {"choices": [{"delta": {"content": "\n\n"}, "finish_reason": None}]}
+                            
+                            # 处理卡片内容
+                            if content_type == "card":
+                                try:
+                                    card_content = json.loads(content)
+                                    card_items = card_content["cardInfo"]["cardItems"]
+                                    markdown_output = "\n\n---\n\n"
+                                    
+                                    # 处理搜索关键词（type: 2001）
+                                    search_keywords = next((item for item in card_items if item["type"] == "2001"), None)
+                                    if search_keywords:
+                                        keywords = json.loads(search_keywords["content"])
+                                        markdown_output += f"搜索关键字：{'; '.join(keywords)}\n"
+                                    
+                                    # 处理搜索结果（type: 2002）
+                                    search_results = next((item for item in card_items if item["type"] == "2002"), None)
+                                    if search_results:
+                                        results = json.loads(search_results["content"])
+                                        markdown_output += f"共找到 {len(results)} 个搜索结果：\n"
+                                        for result in results:
+                                            markdown_output += f"[{result['idIndex']}] [{result['name']}]({result['url']}) 来源：{result['siteName']}\n"
+                                    
+                                    card_messages.append(markdown_output)
+                                except Exception as e:
+                                    logger.error(f"Error processing card: {str(e)}")
+
+                            # 处理普通文本内容
+                            if content and content_type in ["text", "thinking"]:
+                                yield {"choices": [{"delta": {"content": content}, "finish_reason": None}]}
+
+                    # 在最后输出所有卡片消息
+                    if card_messages:
+                        yield {"choices": [{"delta": {"content": "".join(card_messages)}, "finish_reason": None}]}
+
+                    # 在最后添加元数据
+                    yield {"choices": [{"delta": {"meta": {
+                        "device_id": device_id,
+                        "conversation_id": conversation_id
+                    }}, "finish_reason": None}]}
+
+        except Exception as e:
+            logger.error(f"Error in pipe: {str(e)}")
+            yield {"error": self._format_exception(e)}
+
+    def _format_error(self, status_code: int, error: bytes) -> str:
+        error_str = error.decode(errors="ignore") if isinstance(error, bytes) else error
+        return json.dumps({"error": f"HTTP {status_code}: {error_str}"}, ensure_ascii=False)
+
+    def _format_exception(self, e: Exception) -> str:
+        return json.dumps({"error": f"{type(e).__name__}: {str(e)}"}, ensure_ascii=False)
+
+    def _nanoid(self, size=21) -> str:
+        url_alphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict"
+        random_bytes = secrets.token_bytes(size)
+        return "".join([url_alphabet[b & 63] for b in reversed(random_bytes)])
+
+    def _generate_sign(self, timestamp: str, payload: dict, nonce: str) -> str:
+        payload_str = json.dumps(payload, separators=(",", ":"), ensure_ascii=False)
+        sign_str = f"{timestamp}{payload_str}{nonce}"
+        return hashlib.md5(sign_str.encode("utf-8")).hexdigest().upper()
+
+    async def _create_conversation(self, device_id: str) -> str:
+        """创建新的会话"""
+        payload = {"botCode": "AI_SEARCH"}
+        timestamp = str(int(time.time()))
+        nonce = self._nanoid(21)
+        sign = self._generate_sign(timestamp, payload, nonce)
+
+        headers = {
+            "Origin": "https://ai.dangbei.com",
+            "Referer": "https://ai.dangbei.com/",
+            "User-Agent": self.user_agent,
+            "deviceId": device_id,
+            "nonce": nonce,
+            "sign": sign,
+            "timestamp": timestamp,
+        }
+
+        api = f"{config.API_DOMAIN}/ai-search/conversationApi/v1/create"
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(api, json=payload, headers=headers)
+                if response.status_code == 200:
+                    data = response.json()
+                    if data.get("success"):
+                        return data["data"]["conversationId"]
+        except Exception as e:
+            logger.error(f"Error creating conversation: {str(e)}")
+        return None
+
+# 创建实例
+pipe = Pipe()
+
+@app.post("/v1/chat/completions")
+async def chat(request: ChatRequest, authorization: str = Header(None)):
+    """
+    OpenAI API 兼容的 Chat 端点
+    """
+    # 添加请求日志
+    logger.info(f"Received chat request: {request.model_dump()}")
+    
+    await verify_api_key(authorization)
+
+    # 使用 messages_as_dicts 属性
+    request_data = request.model_dump()
+    request_data['messages'] = request.messages_as_dicts
+
+    async def response_generator():
+        """流式响应生成器"""
+        thinking_content = []
+        is_thinking = False
+        
+        async for chunk in pipe.pipe(request_data):
+            if "choices" in chunk and chunk["choices"]:
+                delta = chunk["choices"][0]["delta"]
+                if "content" in delta:
+                    content = delta["content"]
+                    if content == "<think>\n":
+                        is_thinking = True
+                    elif content == "\n</think>\n\n":
+                        is_thinking = False
+                    if is_thinking and content != "<think>\n":
+                        thinking_content.append(content)
+            
+            yield f"data: {json.dumps(chunk, ensure_ascii=False)}\n\n"
+        yield "data: [DONE]\n\n"
+
+    if request.stream:
+        return StreamingResponse(response_generator(), media_type="text/event-stream")
+
+    # 非流式响应
+    content = ""
+    meta = None
+    try:
+        async for chunk in pipe.pipe(request_data):
+            if "choices" in chunk and chunk["choices"]:
+                delta = chunk["choices"][0]["delta"]
+                if "content" in delta:
+                    content += delta["content"]
+                if "meta" in delta:
+                    meta = delta["meta"]
+    except Exception as e:
+        logger.error(f"Error processing chat request: {str(e)}")
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+    parts = content.split("\n\n\n", 1)
+    reasoning_content = parts[0] if len(parts) > 0 else ""
+    content = parts[1] if len(parts) > 1 else ""
+
+    # 处理嵌套的 think 标签和特殊字符
+    if reasoning_content:
+        # 先尝试找到最外层的 think 标签
+        start_idx = reasoning_content.find("<think>")
+        end_idx = reasoning_content.rfind("</think>")
+        
+        if start_idx != -1 and end_idx != -1:
+            # 如果找到了完整的外层标签，提取其中的内容
+            inner_content = reasoning_content[start_idx + 7:end_idx].strip()
+            # 移除内部的 think 标签
+            inner_content = inner_content.replace("<think>", "").replace("</think>", "").strip()
+            reasoning_content = f"<think>\n{inner_content}\n</think>"
+        else:
+            # 如果没有找到完整的标签，则移除所有 think 标签并重新添加
+            reasoning_content = reasoning_content.replace("<think>", "").replace("</think>", "").strip()
+            reasoning_content = f"<think>\n{reasoning_content}\n</think>"
+
+    return {
+        "id": str(uuid.uuid4()),
+        "object": "chat.completion",
+        "created": int(time.time()),
+        "model": request.model,
+        "choices": [{
+            "message": {
+                "role": "assistant",
+                "reasoning_content": reasoning_content,
+                "content": content,
+                "meta": meta
+            },
+            "finish_reason": "stop"
+        }]
+    }
+
+@app.get("/v1/models")
+async def get_models(authorization: str = Header(None)):
+    # 验证 API 密钥
+    await verify_api_key(authorization)
+    
+    current_time = int(time.time())
+    return {
+        "object": "list",
+        "data": [
+            # 原始模型
+            {
+                "id": "DeepSeek-R1",
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library"
+            },
+            {
+                "id": "DeepSeek-V3",
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library"
+            },
+            {
+                "id": "Doubao",  # 改为大写开头
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library"
+            },
+            {
+                "id": "Qwen",    # 改为大写开头
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library"
+            },
+            # 支持联网的模型
+            {
+                "id": "DeepSeek-R1-Search",
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library",
+                "features": ["online_search"]
+            },
+            {
+                "id": "DeepSeek-V3-Search",
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library",
+                "features": ["online_search"]
+            },
+            {
+                "id": "Doubao-Search",  # 改为大写开头
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library",
+                "features": ["online_search"]
+            },
+            {
+                "id": "Qwen-Search",    # 改为大写开头
+                "object": "model",
+                "created": current_time,
+                "owned_by": "library",
+                "features": ["online_search"]
+            }
+        ]
+    }
+@app.get("/")
+def index():
+    return "it's work!"
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,4 @@
+fastapi>=0.104.1
+httpx[http2]>=0.25.2
+pydantic>=2.5.2
+uvicorn>=0.24.0