Initial commit

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 CassianVale
+Copyright (c) 2025 ZyphrZero
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,143 @@
+
+## 项目简介
+
+这是一个为 Z.ai 提供 OpenAI API 兼容接口的 Python 代理服务，允许开发者通过标准的 OpenAI API 格式访问 Z.ai 的 GLM-4.5 模型。
+
+## 主要特性
+
+- **OpenAI API 兼容**：完整支持 `/v1/chat/completions` 和 `/v1/models` 端点
+- **流式响应支持**：完整实现 Server-Sent Events (SSE) 流式传输
+- **思考内容处理**：提供多种策略处理模型的思考过程（`<details>` 标签）
+- **匿名会话支持**：可选使用匿名 token 避免共享对话历史
+- **多种模型支持**：支持 GLM-4.5 基础版、思考版和搜索版
+- **调试模式**：详细的请求/响应日志记录，便于开发调试
+- **CORS 支持**：内置跨域资源共享支持
+- **异步处理**：基于 FastAPI 和 httpx 的高性能异步架构
+
+## 使用场景
+
+- 将 Z.ai 集成到支持 OpenAI API 的应用程序中
+- 开发需要同时使用多个 AI 服务的应用
+- 测试和评估 GLM-4.5 模型的能力
+- 需要流式响应或思考内容的 AI 应用开发
+
+## 快速开始
+
+### 使用 uv (推荐)
+
+1. 安装 uv：
+   ```bash
+   # macOS/Linux
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   # Windows (PowerShell)
+   powershell -c "irm https://astral.sh/uv/install.sh | iex"
+   ```
+
+2. 同步依赖：
+   ```bash
+   uv sync
+   ```
+
+3. 运行服务：
+   ```bash
+   uv run python main.py
+   ```
+
+### 使用 pip
+
+1. 安装依赖：
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. 配置服务（可选）：
+   编辑 `main.py` 中的以下常量以调整服务行为：
+   - `DEFAULT_KEY`: 客户端 API 密钥
+   - `UPSTREAM_URL`: Z.ai 上游 API 地址
+   - `UPSTREAM_TOKEN`: 固定认证 token（匿名模式失败时使用）
+   - `PORT`: 服务监听端口
+   - `DEBUG_MODE`: 调试模式开关
+   - `THINK_TAGS_MODE`: 思考内容处理策略
+   - `ANON_TOKEN_ENABLED`: 匿名 token 开关
+
+3. 运行服务：
+   ```bash
+   python main.py
+   ```
+
+   服务启动后，可以访问 http://localhost:8080/docs 查看自动生成的 Swagger API 文档
+
+4. 使用 OpenAI 客户端库调用：
+   ```python
+   import openai
+
+   # 初始化客户端
+   client = openai.OpenAI(
+       base_url="http://localhost:8080/v1",
+       api_key="sk-tbkFoKzk9a531YyUNNF5"  # 使用配置的 DEFAULT_KEY
+   )
+
+   # 流式调用示例
+   response = client.chat.completions.create(
+       model="GLM-4.5",  # 可选: "GLM-4.5-Thinking", "GLM-4.5-Search"
+       messages=[{"role": "user", "content": "你好"}],
+       stream=True
+   )
+
+   for chunk in response:
+       content = chunk.choices[0].delta.content
+       reasoning = chunk.choices[0].delta.reasoning_content
+       if content:
+           print(content, end="")
+       if reasoning:
+           print(f"\n[思考] {reasoning}\n")
+   ```
+
+   注意：请将 `api_key` 替换为您在 `main.py` 中配置的 `DEFAULT_KEY` 值。
+
+## 配置选项
+
+| 配置项 | 描述 | 默认值 |
+|--------|------|--------|
+| `UPSTREAM_URL` | Z.ai 的上游 API 地址 | `https://chat.z.ai/api/chat/completions` |
+| `DEFAULT_KEY` | 下游客户端鉴权 key | `sk-tbkFoKzk9a531YyUNNF5` |
+| `UPSTREAM_TOKEN` | 上游 API 的 token (匿名模式失败时使用) | JWT token |
+| `DEFAULT_MODEL_NAME` | 默认模型名称 | `GLM-4.5` |
+| `THINKING_MODEL_NAME` | 思考模型名称 | `GLM-4.5-Thinking` |
+| `SEARCH_MODEL_NAME` | 搜索模型名称 | `GLM-4.5-Search` |
+| `PORT` | 服务监听端口 | `8080` |
+| `DEBUG_MODE` | 调试模式开关 | `true` |
+| `THINK_TAGS_MODE` | 思考内容处理策略 | `think` (可选: `strip`, `raw`) |
+| `ANON_TOKEN_ENABLED` | 是否使用匿名 token | `true` |
+
+### 思考内容处理策略说明
+
+- **think**: 将 `<details>` 标签转换为 `<thinking>` 标签，适合 OpenAI 兼容格式
+- **strip**: 完全移除 `<details>` 标签及其内容
+- **raw**: 保留原始格式，不做任何处理
+
+## 架构说明
+
+本项目采用以下技术栈：
+
+- **FastAPI**: 现代、快速的 Web 框架，提供自动 API 文档生成
+- **httpx**: 异步 HTTP 客户端，用于上游 API 调用
+- **Pydantic**: 数据验证和序列化，确保 API 兼容性
+- **uvicorn**: ASGI 服务器，提供高性能服务
+
+项目通过异步编程模型实现高效的并发处理，支持流式和非流式两种响应模式。
+
+## 贡献指南
+
+欢迎提交 Issue 和 Pull Request！请确保：
+1. 遵循 PEP 8 规范
+2. 提交前运行测试（如果有）
+3. 更新相关文档
+
+## 许可证
+
+MIT LICENSE
+
+## 免责声明
+
+本项目与 Z.ai 官方无关，使用前请确保遵守 Z.ai 的服务条款。请勿将此服务用于商业用途或违反 Z.ai 使用条款的场景。

deploy/.dockerignore

@@ -0,0 +1,3 @@
+.git
+README.md
+*.log

deploy/DOCKER.md

@@ -0,0 +1,153 @@
+# Docker部署指南
+
+## 文件说明
+
+- `Dockerfile.python` - 基础版本的Dockerfile
+- `Dockerfile.python.optimized` - 多阶段构建，镜像更小
+- `docker-compose.yml` - Docker Compose配置文件
+- `.dockerignore` - Docker构建时忽略的文件
+- `test-page/` - 简单的Web测试界面
+
+## 快速开始
+
+### 1. 构建并运行（使用docker-compose）
+
+```bash
+# 启动服务
+docker-compose up -d
+
+# 查看日志
+docker-compose logs -f
+
+# 停止服务
+docker-compose down
+```
+
+### 2. 仅使用Docker
+
+```bash
+# 构建镜像
+docker build -f Dockerfile.python.optimized -t openai-proxy-python .
+
+# 运行容器
+docker run -d \
+  --name openai-proxy \
+  -p 8080:8080 \
+  openai-proxy-python
+```
+
+### 3. 带测试界面的完整部署
+
+```bash
+# 启动服务和测试界面
+docker-compose --profile test-ui up -d
+
+# 访问测试界面
+# 打开浏览器访问 http://localhost:8081
+```
+
+## 环境变量配置
+
+可以通过环境变量覆盖默认配置：
+
+```bash
+# 在docker-compose.yml中添加
+environment:
+  - DEBUG_MODE=false
+  - PORT=8080
+  - DEFAULT_KEY=your-api-key
+  - UPSTREAM_TOKEN=your-upstream-token
+```
+
+或者使用.env文件：
+
+```bash
+# 创建.env文件
+echo "DEBUG_MODE=false" > .env
+echo "DEFAULT_KEY=sk-your-custom-key" >> .env
+
+# 启动时自动加载
+docker-compose up -d
+```
+
+## 生产环境建议
+
+1. **使用优化版Dockerfile**
+   ```bash
+   docker build -f Dockerfile.python.optimized -t openai-proxy:latest .
+   ```
+
+2. **配置HTTPS**
+   建议在反向代理（如Nginx）中配置SSL证书
+
+3. **使用Docker Secrets管理敏感信息**
+   ```yaml
+   secrets:
+     api_key:
+       file: ./secrets/api_key.txt
+     upstream_token:
+       file: ./secrets/upstream_token.txt
+   ```
+
+4. **设置资源限制**
+   ```yaml
+   deploy:
+     resources:
+       limits:
+         cpus: '0.5'
+         memory: 512M
+   ```
+
+## 常用命令
+
+```bash
+# 查看容器状态
+docker ps
+
+# 查看日志
+docker logs openai-proxy
+
+# 进入容器
+docker exec -it openai-proxy bash
+
+# 重新构建
+docker-compose build
+
+# 完全清理
+docker-compose down -v --rmi all
+```
+
+## 故障排除
+
+1. **端口冲突**
+   - 修改docker-compose.yml中的端口映射
+   - 或者停止占用8080端口的程序
+
+2. **镜像构建失败**
+   - 确保Docker版本 >= 19.03
+   - 检查网络连接
+
+3. **容器启动失败**
+   - 查看日志：`docker logs openai-proxy`
+   - 检查配置文件语法
+
+4. **API请求失败**
+   - 确认容器正在运行
+   - 检查防火墙设置
+   - 验证API密钥配置
+
+## 测试API
+
+容器启动后，可以测试API：
+
+```bash
+# 测试模型列表
+curl -X GET http://localhost:8080/v1/models \
+  -H "Authorization: Bearer sk-tbkFoKzk9a531YyUNNF5"
+
+# 测试聊天接口
+curl -X POST http://localhost:8080/v1/chat/completions \
+  -H "Content-Type: application/json" \
+  -H "Authorization: Bearer sk-tbkFoKzk9a531YyUNNF5" \
+  -d '{"model": "GLM-4.5", "messages": [{"role": "user", "content": "Hello"}]}'
+```

deploy/Dockerfile

@@ -0,0 +1,53 @@
+# 多阶段构建 - 构建阶段
+FROM python:3.11-slim as builder
+
+# 安装构建依赖
+RUN apt-get update && apt-get install -y \
+    gcc \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# 设置虚拟环境
+RUN python -m venv /opt/venv
+ENV PATH="/opt/venv/bin:$PATH"
+
+# 复制并安装依赖
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 运行阶段 - 更小的镜像
+FROM python:3.11-slim
+
+# 安装运行时依赖（curl用于健康检查）
+RUN apt-get update && apt-get install -y \
+    curl \
+    && rm -rf /var/lib/apt/lists/* && \
+    groupadd -r app && useradd -r -g app app
+
+# 从构建阶段复制虚拟环境
+COPY --from=builder /opt/venv /opt/venv
+
+# 设置环境变量
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PATH="/opt/venv/bin:$PATH"
+
+# 创建工作目录并设置权限
+WORKDIR /app
+RUN chown app:app /app
+USER app
+
+# 复制应用代码
+COPY --chown=app:app main.py .
+COPY --chown=app:app test_api.py .
+
+# 暴露端口
+EXPOSE 8080
+
+# 健康检查
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8080/v1/models || exit 1
+
+# 启动命令
+CMD ["python", "main.py"]

deploy/docker-compose.yml

@@ -0,0 +1,49 @@
+version: '3.8'
+
+services:
+  openai-proxy:
+    build:
+      context: .
+      dockerfile: Dockerfile.python.optimized
+    container_name: openai-proxy-python
+    ports:
+      - "8080:8080"
+    environment:
+      # 可以通过环境变量覆盖配置
+      - DEBUG_MODE=false
+      - PORT=8080
+      # 注意：敏感信息应该使用 secrets 或 env 文件
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:8080/v1/models"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    networks:
+      - proxy-network
+
+  # 可选：添加一个简单的web界面用于测试
+  web-test:
+    image: nginx:alpine
+    container_name: proxy-web-test
+    ports:
+      - "8081:80"
+    volumes:
+      - ./test-page:/usr/share/nginx/html:ro
+    depends_on:
+      - openai-proxy
+    networks:
+      - proxy-network
+    profiles:
+      - test-ui
+
+networks:
+  proxy-network:
+    driver: bridge
+
+# 使用说明：
+# 1. 基本启动：docker-compose up -d
+# 2. 带测试界面：docker-compose --profile test-ui up -d
+# 3. 查看日志：docker-compose logs -f
+# 4. 停止服务：docker-compose down

main.py

@@ -0,0 +1,630 @@
+"""
+Go到Python代码转换说明
+=====================
+
+这是一个将Go语言实现的OpenAI兼容API代理服务器转换为Python版本的代码。
+使用FastAPI作为Web框架，httpx用于HTTP请求，uvicorn作为ASGI服务器。
+
+主要功能对应关系：
+1. 配置常量：使用Python模块级常量替代Go的const
+2. 数据结构：使用Pydantic模型替代Go的struct
+3. HTTP处理：使用FastAPI路由替代Go的http.HandleFunc
+4. 流式响应：使用FastAPI的StreamingResponse替代Go的http.Flusher
+5. SSE处理：使用生成器函数和字符串格式化替代Go的fmt.Fprintf
+
+关键实现思路：
+- 保持了原有的API认证逻辑
+- 维持了上游API调用的头部伪装
+- 实现了相同的思考内容处理策略
+- 保持了流式和非流式响应的处理逻辑
+
+依赖安装：
+pip install fastapi uvicorn httpx pydantic
+
+运行方式：
+uvicorn main:app --host 0.0.0.0 --port 8080 --reload
+"""
+
+import json
+import re
+import time
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Union, AsyncGenerator
+from urllib.parse import urljoin
+
+import httpx
+from fastapi import FastAPI, Request, Response, HTTPException, Header
+from fastapi.responses import StreamingResponse, JSONResponse
+from pydantic import BaseModel, Field
+
+
+# 配置常量
+UPSTREAM_URL = "https://chat.z.ai/api/chat/completions"
+DEFAULT_KEY = "sk-tbkFoKzk9a531YyUNNF5"
+UPSTREAM_TOKEN = "eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6IjMxNmJjYjQ4LWZmMmYtNGExNS04NTNkLWYyYTI5YjY3ZmYwZiIsImVtYWlsIjoiR3Vlc3QtMTc1NTg0ODU4ODc4OEBndWVzdC5jb20ifQ.PktllDySS3trlyuFpTeIZf-7hl8Qu1qYF3BxjgIul0BrNux2nX9hVzIjthLXKMWAf9V0qM8Vm_iyDqkjPGsaiQ"
+DEFAULT_MODEL_NAME = "GLM-4.5"
+THINKING_MODEL_NAME = "GLM-4.5-Thinking"
+SEARCH_MODEL_NAME = "GLM-4.5-Search"
+PORT = 8080
+DEBUG_MODE = True
+
+# 思考内容处理策略
+THINK_TAGS_MODE = "think"  # strip: 去除<details>标签；think: 转为<think>标签；raw: 保留原样
+
+# 伪装前端头部
+X_FE_VERSION = "prod-fe-1.0.70"
+BROWSER_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0"
+SEC_CH_UA = '"Not;A=Brand";v="99", "Microsoft Edge";v="139", "Chromium";v="139"'
+SEC_CH_UA_MOB = "?0"
+SEC_CH_UA_PLAT = '"Windows"'
+ORIGIN_BASE = "https://chat.z.ai"
+
+# 匿名token开关
+ANON_TOKEN_ENABLED = True
+
+
+# 数据结构定义
+class Message(BaseModel):
+    role: str
+    content: str
+    reasoning_content: Optional[str] = None
+
+
+class OpenAIRequest(BaseModel):
+    model: str
+    messages: List[Message]
+    stream: Optional[bool] = False
+    temperature: Optional[float] = None
+    max_tokens: Optional[int] = None
+
+
+class ModelItem(BaseModel):
+    id: str
+    name: str
+    owned_by: str
+
+
+class UpstreamRequest(BaseModel):
+    stream: bool
+    model: str
+    messages: List[Message]
+    params: Dict[str, Any] = {}
+    features: Dict[str, Any] = {}
+    background_tasks: Optional[Dict[str, bool]] = None
+    chat_id: Optional[str] = None
+    id: Optional[str] = None
+    mcp_servers: Optional[List[str]] = None
+    model_item: Optional[ModelItem] = None
+    tool_servers: Optional[List[str]] = None
+    variables: Optional[Dict[str, str]] = None
+    model_config = {'protected_namespaces': ()}
+
+
+class Delta(BaseModel):
+    role: Optional[str] = None
+    content: Optional[str] = None
+    reasoning_content: Optional[str] = None
+
+
+class Choice(BaseModel):
+    index: int
+    message: Optional[Message] = None
+    delta: Optional[Delta] = None
+    finish_reason: Optional[str] = None
+
+
+class Usage(BaseModel):
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    total_tokens: int = 0
+
+
+class OpenAIResponse(BaseModel):
+    id: str
+    object: str
+    created: int
+    model: str
+    choices: List[Choice]
+    usage: Optional[Usage] = None
+
+
+class UpstreamError(BaseModel):
+    detail: str
+    code: int
+
+
+class UpstreamDataInner(BaseModel):
+    error: Optional[UpstreamError] = None
+
+
+class UpstreamDataData(BaseModel):
+    delta_content: str = ""
+    edit_content: str = ""
+    phase: str = ""
+    done: bool = False
+    usage: Optional[Usage] = None
+    error: Optional[UpstreamError] = None
+    inner: Optional[UpstreamDataInner] = None
+
+
+class UpstreamData(BaseModel):
+    type: str
+    data: UpstreamDataData
+    error: Optional[UpstreamError] = None
+
+
+class Model(BaseModel):
+    id: str
+    object: str = "model"
+    created: int
+    owned_by: str
+
+
+class ModelsResponse(BaseModel):
+    object: str = "list"
+    data: List[Model]
+
+
+# FastAPI应用
+app = FastAPI()
+
+
+# 调试日志函数
+def debug_log(format_str: str, *args):
+    if DEBUG_MODE:
+        print(f"[DEBUG] {format_str % args}")
+
+
+# 获取匿名token
+async def get_anonymous_token() -> str:
+    """获取匿名token（每次对话使用不同token，避免共享记忆）"""
+    async with httpx.AsyncClient(timeout=10.0) as client:
+        headers = {
+            "User-Agent": BROWSER_UA,
+            "Accept": "*/*",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+            "X-FE-Version": X_FE_VERSION,
+            "sec-ch-ua": SEC_CH_UA,
+            "sec-ch-ua-mobile": SEC_CH_UA_MOB,
+            "sec-ch-ua-platform": SEC_CH_UA_PLAT,
+            "Origin": ORIGIN_BASE,
+            "Referer": f"{ORIGIN_BASE}/",
+        }
+        
+        response = await client.get(f"{ORIGIN_BASE}/api/v1/auths/", headers=headers)
+        
+        if response.status_code != 200:
+            raise Exception(f"anon token status={response.status_code}")
+        
+        data = response.json()
+        token = data.get("token")
+        if not token:
+            raise Exception("anon token empty")
+        
+        return token
+
+
+# CORS中间件
+@app.middleware("http")
+async def add_cors_headers(request: Request, call_next):
+    response = await call_next(request)
+    response.headers["Access-Control-Allow-Origin"] = "*"
+    response.headers["Access-Control-Allow-Methods"] = "GET, POST, PUT, DELETE, OPTIONS"
+    response.headers["Access-Control-Allow-Headers"] = "Content-Type, Authorization"
+    response.headers["Access-Control-Allow-Credentials"] = "true"
+    return response
+
+
+# OPTIONS处理器
+@app.options("/")
+async def handle_options():
+    return Response(status_code=200)
+
+
+# 模型列表接口
+@app.get("/v1/models")
+async def handle_models():
+    response = ModelsResponse(
+        data=[
+            Model(
+                id=DEFAULT_MODEL_NAME,
+                created=int(time.time()),
+                owned_by="z.ai"
+            ),
+            Model(
+                id=THINKING_MODEL_NAME,
+                created=int(time.time()),
+                owned_by="z.ai"
+            ),
+            Model(
+                id=SEARCH_MODEL_NAME,
+                created=int(time.time()),
+                owned_by="z.ai"
+            ),
+        ]
+    )
+    return response
+
+
+# 聊天完成接口
+@app.post("/v1/chat/completions")
+async def handle_chat_completions(
+    request: OpenAIRequest,
+    authorization: str = Header(...)
+):
+    debug_log("收到chat completions请求")
+    
+    # 验证API Key
+    if not authorization.startswith("Bearer "):
+        debug_log("缺少或无效的Authorization头")
+        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
+    
+    api_key = authorization[7:]  # 去掉"Bearer "
+    if api_key != DEFAULT_KEY:
+        debug_log(f"无效的API key: {api_key}")
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    
+    debug_log("API key验证通过")
+    debug_log(f"请求解析成功 - 模型: {request.model}, 流式: {request.stream}, 消息数: {len(request.messages)}")
+    
+    # 生成会话相关ID
+    chat_id = f"{int(time.time() * 1000)}-{int(time.time())}"
+    msg_id = str(int(time.time() * 1000000))
+    
+    # 确定模型特性
+    is_thinking = request.model == THINKING_MODEL_NAME
+    is_search = request.model == SEARCH_MODEL_NAME
+    search_mcp = "deep-web-search" if is_search else ""
+    
+    # 构造上游请求
+    upstream_req = UpstreamRequest(
+        stream=True,  # 总是使用流式从上游获取
+        chat_id=chat_id,
+        id=msg_id,
+        model="0727-360B-API",  # 上游实际模型ID
+        messages=request.messages,
+        params={},
+        features={
+            "enable_thinking": is_thinking,
+            "web_search": is_search,
+            "auto_web_search": is_search,
+        },
+        background_tasks={
+            "title_generation": False,
+            "tags_generation": False,
+        },
+        mcp_servers=[search_mcp] if search_mcp else [],
+        model_item=ModelItem(
+            id="0727-360B-API",
+            name="GLM-4.5",
+            owned_by="openai"
+        ),
+        tool_servers=[],
+        variables={
+            "{{USER_NAME}}": "User",
+            "{{USER_LOCATION}}": "Unknown",
+            "{{CURRENT_DATETIME}}": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        }
+    )
+    
+    # 选择本次对话使用的token
+    auth_token = UPSTREAM_TOKEN
+    if ANON_TOKEN_ENABLED:
+        try:
+            token = await get_anonymous_token()
+            auth_token = token
+            debug_log(f"匿名token获取成功: {token[:10]}...")
+        except Exception as e:
+            debug_log(f"匿名token获取失败，回退固定token: {e}")
+    
+    # 调用上游API
+    if request.stream:
+        return StreamingResponse(
+            handle_stream_response(upstream_req, chat_id, auth_token),
+            media_type="text/event-stream",
+            headers={
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            }
+        )
+    else:
+        return await handle_non_stream_response(upstream_req, chat_id, auth_token)
+
+
+async def call_upstream_with_headers(upstream_req: UpstreamRequest, referer_chat_id: str, auth_token: str) -> httpx.Response:
+    """调用上游API"""
+    headers = {
+        "Content-Type": "application/json",
+        "Accept": "application/json, text/event-stream",
+        "User-Agent": BROWSER_UA,
+        "Authorization": f"Bearer {auth_token}",
+        "Accept-Language": "zh-CN",
+        "sec-ch-ua": SEC_CH_UA,
+        "sec-ch-ua-mobile": SEC_CH_UA_MOB,
+        "sec-ch-ua-platform": SEC_CH_UA_PLAT,
+        "X-FE-Version": X_FE_VERSION,
+        "Origin": ORIGIN_BASE,
+        "Referer": f"{ORIGIN_BASE}/c/{referer_chat_id}",
+    }
+    
+    debug_log(f"调用上游API: {UPSTREAM_URL}")
+    debug_log(f"上游请求体: {upstream_req.model_dump_json()}")
+    
+    async with httpx.AsyncClient(timeout=60.0) as client:
+        response = await client.post(
+            UPSTREAM_URL,
+            json=upstream_req.model_dump(exclude_none=True),
+            headers=headers
+        )
+    
+    debug_log(f"上游响应状态: {response.status_code}")
+    return response
+
+
+def transform_thinking(s: str) -> str:
+    """转换思考内容"""
+    # 去 <summary>…</summary>
+    s = re.sub(r'(?s)<summary>.*?</summary>', '', s)
+    # 清理残留自定义标签
+    s = s.replace("</thinking>", "").replace("<Full>", "").replace("</Full>", "")
+    s = s.strip()
+    
+    if THINK_TAGS_MODE == "think":
+        s = re.sub(r'<details[^>]*>', '<think>', s)
+        s = s.replace("</details>", "</think>")
+    elif THINK_TAGS_MODE == "strip":
+        s = re.sub(r'<details[^>]*>', '', s)
+        s = s.replace("</details>", "")
+    
+    # 处理每行前缀 "> "
+    s = s.lstrip("> ")
+    s = s.replace("\n> ", "\n")
+    return s.strip()
+
+
+async def handle_stream_response(upstream_req: UpstreamRequest, chat_id: str, auth_token: str) -> AsyncGenerator[str, None]:
+    """处理流式响应"""
+    debug_log(f"开始处理流式响应 (chat_id={chat_id})")
+    
+    try:
+        response = await call_upstream_with_headers(upstream_req, chat_id, auth_token)
+    except Exception as e:
+        debug_log(f"调用上游失败: {e}")
+        yield "data: {\"error\": \"Failed to call upstream\"}\n\n"
+        return
+    
+    if response.status_code != 200:
+        debug_log(f"上游返回错误状态: {response.status_code}")
+        if DEBUG_MODE:
+            debug_log(f"上游错误响应: {response.text}")
+        yield "data: {\"error\": \"Upstream error\"}\n\n"
+        return
+    
+    # 发送第一个chunk（role）
+    first_chunk = OpenAIResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        object="chat.completion.chunk",
+        created=int(time.time()),
+        model=DEFAULT_MODEL_NAME,
+        choices=[Choice(
+            index=0,
+            delta=Delta(role="assistant")
+        )]
+    )
+    yield f"data: {first_chunk.model_dump_json()}\n\n"
+    
+    # 读取上游SSE流
+    debug_log("开始读取上游SSE流")
+    line_count = 0
+    sent_initial_answer = False
+    
+    async for line in response.aiter_lines():
+        line_count += 1
+        
+        if not line.startswith("data: "):
+            continue
+        
+        data_str = line[6:]  # 去掉 "data: "
+        if not data_str:
+            continue
+        
+        debug_log(f"收到SSE数据 (第{line_count}行): {data_str}")
+        
+        try:
+            upstream_data = UpstreamData.model_validate_json(data_str)
+        except Exception as e:
+            debug_log(f"SSE数据解析失败: {e}")
+            continue
+        
+        # 错误检测
+        if (upstream_data.error or 
+            upstream_data.data.error or 
+            (upstream_data.data.inner and upstream_data.data.inner.error)):
+            
+            err_obj = upstream_data.error or upstream_data.data.error
+            if not err_obj and upstream_data.data.inner:
+                err_obj = upstream_data.data.inner.error
+            
+            debug_log(f"上游错误: code={err_obj.code}, detail={err_obj.detail}")
+            
+            # 结束下游流
+            end_chunk = OpenAIResponse(
+                id=f"chatcmpl-{int(time.time())}",
+                object="chat.completion.chunk",
+                created=int(time.time()),
+                model=DEFAULT_MODEL_NAME,
+                choices=[Choice(
+                    index=0,
+                    delta=Delta(),
+                    finish_reason="stop"
+                )]
+            )
+            yield f"data: {end_chunk.model_dump_json()}\n\n"
+            yield "data: [DONE]\n\n"
+            break
+        
+        debug_log(f"解析成功 - 类型: {upstream_data.type}, 阶段: {upstream_data.data.phase}, "
+                 f"内容长度: {len(upstream_data.data.delta_content)}, 完成: {upstream_data.data.done}")
+        
+        # 处理EditContent在最初的answer信息（只发送一次）
+        if (not sent_initial_answer and 
+            upstream_data.data.edit_content and 
+            upstream_data.data.phase == "answer"):
+            
+            out = upstream_data.data.edit_content
+            if out:
+                parts = out.split("</details>")
+                if len(parts) > 1:
+                    content = parts[1]
+                    if content:
+                        debug_log(f"发送普通内容: {content}")
+                        chunk = OpenAIResponse(
+                            id=f"chatcmpl-{int(time.time())}",
+                            object="chat.completion.chunk",
+                            created=int(time.time()),
+                            model=DEFAULT_MODEL_NAME,
+                            choices=[Choice(
+                                index=0,
+                                delta=Delta(content=content)
+                            )]
+                        )
+                        yield f"data: {chunk.model_dump_json()}\n\n"
+                        sent_initial_answer = True
+        
+        # 处理DeltaContent
+        if upstream_data.data.delta_content:
+            out = upstream_data.data.delta_content
+            
+            if upstream_data.data.phase == "thinking":
+                out = transform_thinking(out)
+                # 思考内容使用 reasoning_content 字段
+                if out:
+                    debug_log(f"发送思考内容: {out}")
+                    chunk = OpenAIResponse(
+                        id=f"chatcmpl-{int(time.time())}",
+                        object="chat.completion.chunk",
+                        created=int(time.time()),
+                        model=DEFAULT_MODEL_NAME,
+                        choices=[Choice(
+                            index=0,
+                            delta=Delta(reasoning_content=out)
+                        )]
+                    )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+            else:
+                # 普通内容使用 content 字段
+                if out:
+                    debug_log(f"发送普通内容: {out}")
+                    chunk = OpenAIResponse(
+                        id=f"chatcmpl-{int(time.time())}",
+                        object="chat.completion.chunk",
+                        created=int(time.time()),
+                        model=DEFAULT_MODEL_NAME,
+                        choices=[Choice(
+                            index=0,
+                            delta=Delta(content=out)
+                        )]
+                    )
+                    yield f"data: {chunk.model_dump_json()}\n\n"
+        
+        # 检查是否结束
+        if upstream_data.data.done or upstream_data.data.phase == "done":
+            debug_log("检测到流结束信号")
+            
+            # 发送结束chunk
+            end_chunk = OpenAIResponse(
+                id=f"chatcmpl-{int(time.time())}",
+                object="chat.completion.chunk",
+                created=int(time.time()),
+                model=DEFAULT_MODEL_NAME,
+                choices=[Choice(
+                    index=0,
+                    delta=Delta(),
+                    finish_reason="stop"
+                )]
+            )
+            yield f"data: {end_chunk.model_dump_json()}\n\n"
+            yield "data: [DONE]\n\n"
+            debug_log(f"流式响应完成，共处理{line_count}行")
+            break
+
+
+async def handle_non_stream_response(upstream_req: UpstreamRequest, chat_id: str, auth_token: str) -> JSONResponse:
+    """处理非流式响应"""
+    debug_log(f"开始处理非流式响应 (chat_id={chat_id})")
+    
+    try:
+        response = await call_upstream_with_headers(upstream_req, chat_id, auth_token)
+    except Exception as e:
+        debug_log(f"调用上游失败: {e}")
+        raise HTTPException(status_code=502, detail="Failed to call upstream")
+    
+    if response.status_code != 200:
+        debug_log(f"上游返回错误状态: {response.status_code}")
+        if DEBUG_MODE:
+            debug_log(f"上游错误响应: {response.text}")
+        raise HTTPException(status_code=502, detail="Upstream error")
+    
+    # 收集完整响应
+    full_content = []
+    debug_log("开始收集完整响应内容")
+    
+    async for line in response.aiter_lines():
+        if not line.startswith("data: "):
+            continue
+        
+        data_str = line[6:]
+        if not data_str:
+            continue
+        
+        try:
+            upstream_data = UpstreamData.model_validate_json(data_str)
+        except Exception:
+            continue
+        
+        if upstream_data.data.delta_content:
+            out = upstream_data.data.delta_content
+            
+            if upstream_data.data.phase == "thinking":
+                out = transform_thinking(out)
+            
+            if out:
+                full_content.append(out)
+        
+        if upstream_data.data.done or upstream_data.data.phase == "done":
+            debug_log("检测到完成信号，停止收集")
+            break
+    
+    final_content = "".join(full_content)
+    debug_log(f"内容收集完成，最终长度: {len(final_content)}")
+    
+    # 构造完整响应
+    response_data = OpenAIResponse(
+        id=f"chatcmpl-{int(time.time())}",
+        object="chat.completion",
+        created=int(time.time()),
+        model=DEFAULT_MODEL_NAME,
+        choices=[Choice(
+            index=0,
+            message=Message(
+                role="assistant",
+                content=final_content
+            ),
+            finish_reason="stop"
+        )],
+        usage=Usage()
+    )
+    
+    debug_log("非流式响应发送完成")
+    return JSONResponse(content=response_data.model_dump(exclude_none=True))
+
+
+# 根路径处理器
+@app.get("/")
+async def root():
+    return {"message": "OpenAI Compatible API Server"}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=PORT, reload=True)

pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "z-ai2api-python"
+version = "0.1.0"
+description = "一个为 Z.ai 提供 OpenAI API 兼容接口的 Python 代理服务"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Contributors"}
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "fastapi==0.104.1",
+    "uvicorn[standard]==0.24.0",
+    "httpx==0.25.2",
+    "pydantic==2.5.0",
+]
+
+[project.scripts]
+z-ai2api = "main:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["."]
+
+[tool.uv]
+dev-dependencies = [
+    "pytest>=7.0.0",
+    "pytest-asyncio>=0.21.0",
+    "httpx>=0.25.0",
+    "ruff>=0.1.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"
+select = ["E", "F", "I", "B"]
+ignore = []
+
+[tool.ruff.isort]
+known-first-party = []
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_functions = ["test_*"]

requirements.txt

@@ -0,0 +1,4 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+httpx==0.25.2
+pydantic==2.5.0