fix(zai_provider): 增强错误处理和调试日志，定位非流式响应处理失败

- 在 chat_completion 中添加详细的请求/响应调试日志
- 捕获 transform_response 异常并记录上游响应内容预览
- 在 _handle_non_stream_response 中添加数据行跟踪机制
- 记录所有原始响应行，便于分析响应格式不匹配问题
- 添加内容提取结果的警告日志（当内容为空但收到数据时）

这些修改将帮助我们精确定位 Z.AI API 返回的响应格式，找出为什么
非流式请求在获取到200响应后仍然处理失败的根本原因。

Co-Authored-By: Claude <noreply@anthropic.com>

CLAUDE.md

@@ -0,0 +1,411 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with this repository.
+
+## Project Overview
+
+This is an **OpenAI-compatible API proxy server** written in Python/FastAPI that provides unified access to multiple AI providers:
+- **Z.AI** (GLM-4.5, GLM-4.6V, GLM-4.7 series)
+- **K2Think** (MBZUAI-IFM/K2-Think)
+- **LongCat** (LongCat-Flash, LongCat-Search)
+
+The server implements the OpenAI API specification (`/v1/chat/completions`, `/v1/models`) and includes token pool management, provider routing, admin panel, and Docker deployment support.
+
+## High-Level Architecture
+
+### Core Components
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    FastAPI Application                       │
+│  ┌──────────────┐  ┌──────────────┐  ┌──────────────────┐  │
+│  │ OpenAI Router│  │ Admin Routes │  │   Static Files   │  │
+│  └──────┬───────┘  └──────┬───────┘  └──────────────────┘  │
+│         │                 │                                  │
+│         └────────┬────────┘                                  │
+│                  ▼                                           │
+│  ┌──────────────────────────────────────────────────┐      │
+│  │         ProviderRouter (ProviderFactory)         │      │
+│  │  - Routes requests to appropriate provider       │      │
+│  │  - Manages model-to-provider mapping             │      │
+│  └────────┬─────────────────────────────────────────┘      │
+│           │                                                  │
+│  ┏━━━━━━━━┼━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓    │
+│  ┃        ▼                                        ┃    │
+│  ┃  ┌──────────────────┐ ┌──────────────────┐    ┃    │
+│  ┃  │   ZAIProvider    │ │  K2ThinkProvider │    ┃    │
+│  ┃  │                  │ │                  │    ┃    │
+│  ┃  │  ┌────────────┐  │ │  ┌────────────┐  │    ┃    │
+│  ┃  │  │ Token Pool │  │ │  │ HTTP Client│  │    ┃    │
+│  ┃  │  └────────────┘  │ │  └────────────┘  │    ┃    │
+│  ┃  └──────────────────┘ └──────────────────┘    ┃    │
+│  ┃                                               ┃    │
+│  ┃  ┌──────────────────┐                       ┃    │
+│  ┃  │  LongCatProvider │                       ┃    │
+│  ┃  └──────────────────┘                       ┃    │
+│  ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛    │
+│                                                        │
+│  ┌─────────────────────┐ ┌─────────────────────┐    │
+│  │   Token Database    │ │      Logger         │    │
+│  │   (SQLite/JSON)     │ │    (Loguru)         │    │
+│  └─────────────────────┘ └─────────────────────┘    │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### Request Flow
+
+1. **Client Request** → `app/core/openai.py:chat_completions()`
+2. **Auth Validation** → Check `AUTH_TOKEN` or skip if `SKIP_AUTH_TOKEN=true`
+3. **Provider Routing** → `ProviderRouter.route_request()`
+4. **Provider Selection** → `ProviderFactory.get_provider_for_model()`
+5. **Provider Processing** → Specific provider handles request:
+   - Token pool management (Z.AI)
+   - HTTP request formatting
+   - Response transformation
+6. **Response** → OpenAI-formatted streaming or non-streaming response
+
+### Key Modules
+
+- **`app/core/`**: Application core, settings, OpenAI API router
+- **`app/providers/`**: Provider implementations (base, ZAI, K2Think, LongCat)
+- **`app/models/`**: Data schemas, token DB models, request logging
+- **`app/services/`**: Token management, database operations
+- **`app/utils/`**: Utilities (logger, token pool, reload config)
+- **`app/admin/`**: Web admin panel and API
+- **`app/templates/`**: Web UI templates
+
+## Common Development Commands
+
+### Local Development
+
+```bash
+# Install dependencies
+pip install -r requirements.txt
+
+# Install with uv (recommended for this project)
+uv pip install -r requirements.txt
+uv pip install -e .
+
+# Run development server
+python main.py
+
+# Run with hot reload (development only)
+# Edit app/utils/reload_config.py to enable granian reload
+```
+
+### Testing
+
+```bash
+# Run all tests
+pytest
+
+# Run specific test file
+pytest tests/test_simple_signature.py
+
+# Run with verbose output
+pytest -v
+
+# Run single test function
+pytest tests/test_signature.py::test_function_name
+```
+
+### Code Quality
+
+```bash
+# Lint with ruff
+ruff check app/
+
+# Format code
+ruff format app/
+
+# Type check (if pyright/mypy installed)
+```
+
+### Docker Deployment
+
+```bash
+# Build and start
+docker compose up -d
+
+# Build with logging
+docker compose up --build
+
+# View logs
+docker compose logs -f
+
+# Stop services
+docker compose down
+
+# Restart specific service
+docker compose restart api-server
+```
+
+### Database Management
+
+```bash
+# Database is auto-initialized on startup
+# Default location: data/tokens.db (via volume mapping)
+
+# View database (if sqlite3 available)
+sqlite3 data/tokens.db ".tables"
+sqlite3 data/tokens.db "SELECT * FROM tokens;"
+
+# Backup database
+cp data/tokens.db tokens.db.backup.$(date +%Y%m%d)
+```
+
+## Configuration
+
+### Environment Variables
+
+Create `.env` file based on `.env.example`:
+
+```bash
+cp .env.example .env
+```
+
+**Core Configuration:**
+- **Authentication**: `AUTH_TOKEN`, `ADMIN_PASSWORD`, `SKIP_AUTH_TOKEN`
+- **Server**: `LISTEN_PORT` (default 7860), `ROOT_PATH` (reverse proxy)
+- **Features**: `ANONYMOUS_MODE`, `TOOL_SUPPORT`, `DEBUG_LOGGING`
+- **Token Pool**: `TOKEN_FAILURE_THRESHOLD`, `TOKEN_RECOVERY_TIMEOUT`
+- **Provider**: `DEFAULT_PROVIDER`, `LONGCAT_TOKEN`
+- **Proxy**: `HTTP_PROXY`, `HTTPS_PROXY`, `SOCKS5_PROXY`
+
+### Model Mapping
+
+Models are auto-mapped to providers in `app/core/config.py`:
+
+```python
+provider_model_mapping = {
+    # Z.AI
+    "GLM-4.5": "zai",
+    "GLM-4.5-Thinking": "zai",
+    "GLM-4.7": "zai",
+    # K2Think
+    "MBZUAI-IFM/K2-Think": "k2think",
+    # LongCat
+    "LongCat-Flash": "longcat",
+}
+```
+
+### Custom Provider Configuration
+
+To add a new provider:
+
+1. Create `app/providers/new_provider.py` inheriting `BaseProvider`
+2. Implement required methods: `chat_completion()`, `transform_request()`, `transform_response()`
+3. Register in `ProviderFactory.initialize()` at line 36-54
+4. Add model mapping to config
+
+## API Endpoints
+
+### Chat Completions
+```
+POST /v1/chat/completions
+POST /hf/v1/chat/completions
+```
+
+**Request (OpenAI format):**
+```json
+{
+  "model": "GLM-4.5",
+  "messages": [{"role": "user", "content": "Hello"}],
+  "stream": true,
+  "tools": [...]
+}
+```
+
+**Response:** OpenAI-compatible streaming or non-streaming format
+
+### Model Listing
+```
+GET /v1/models
+GET /hf/v1/models
+```
+
+**Response:**
+```json
+{
+  "object": "list",
+  "data": [
+    {"id": "GLM-4.5", "owned_by": "zai"},
+    {"id": "MBZUAI-IFM/K2-Think", "owned_by": "k2think"}
+  ]
+}
+```
+
+### Admin Panel
+- **UI**: `http://localhost:7860/admin`
+- **API**: `http://localhost:7860/admin/api`
+- **Docs**: `http://localhost:7860/docs`
+- **Health Check**: `http://localhost:7860/hf/v1/models`
+
+## Key Features
+
+### Token Pool Management
+- **Automatic failure tracking**: Tokens failing 3+ times are marked unavailable
+- **Recovery mechanism**: Failed tokens recover after 30 minutes
+- **SQLite persistence**: Stored in `data/tokens.db`
+- **Anonymous mode**: Works without tokens (limited functionality)
+
+### Multi-Provider Support
+- **Dynamic routing**: Request automatically routed to correct provider
+- **Unified API**: Single endpoint supports all providers
+- **Extensible**: Easy to add new providers
+
+### Error Handling
+- **Provider errors**: Wrapped in OpenAI-compatible error format
+- **Token failures**: Automatic fallback to healthy tokens
+- **Request validation**: Input validation and type checking
+
+### Monitoring & Logging
+- **Structured logging**: Using Loguru with levels (DEBUG/INFO/WARNING/ERROR)
+- **Request tracking**: All requests logged with model, provider, status
+- **Live reload**: Development mode can auto-reload on code changes
+
+## Testing Providers
+
+### Z.AI (Default)
+```bash
+curl -X POST http://localhost:7860/v1/chat/completions \
+  -H "Authorization: Bearer sk-your-api-key" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.5",
+    "messages": [{"role": "user", "content": "Hello"}],
+    "stream": true
+  }'
+```
+
+### Without Auth (Anonymous Mode)
+```bash
+export SKIP_AUTH_TOKEN=true
+export ANONYMOUS_MODE=true
+python main.py
+```
+
+## Production Deployment
+
+### Security Checklist
+- [ ] Change default `ADMIN_PASSWORD`
+- [ ] Set strong `AUTH_TOKEN`
+- [ ] Disable `DEBUG_LOGGING`
+- [ ] Set `ANONYMOUS_MODE=false` (if requiring auth)
+- [ ] Use HTTPS reverse proxy (Nginx)
+- [ ] Limit network access with firewall rules
+
+### Nginx Configuration
+See `NGINX_SETUP.md` and `nginx.conf.example` for production reverse proxy setup.
+
+### Resource Requirements
+- **CPU**: 1-2 cores recommended
+- **Memory**: 512MB-1GB minimum
+- **Storage**: 100MB for code + database storage
+
+## Troubleshooting
+
+### Common Issues
+
+**"unable to open database file"**
+```bash
+mkdir -p data logs
+chmod 755 data logs
+```
+
+**Auth failures**
+```bash
+# Check .env file for AUTH_TOKEN mismatch
+echo $AUTH_TOKEN
+# Verify client is sending correct Authorization header
+```
+
+**Provider unavailable**
+```bash
+# Check logs for provider-specific errors
+docker compose logs -f | grep "ERROR"
+# Verify API credentials for provider
+```
+
+**Port already in use**
+```bash
+# Change port in docker-compose.yml
+# Or set environment variable
+export LISTEN_PORT=7861
+```
+
+### Debug Mode
+```bash
+export DEBUG_LOGGING=true
+python main.py
+
+# View real-time logs
+tail -f logs/*.log
+```
+
+## Adding New Features
+
+### New Provider Implementation Checklist
+1. Create provider class in `app/providers/`
+2. Inherit from `BaseProvider`
+3. Implement:
+   - `get_supported_models()` → List[str]
+   - `transform_request()` → Dict (API format conversion)
+   - `transform_response()` → Dict/Generator (response conversion)
+   - `chat_completion()` → Async generator or dict
+4. Register in `ProviderFactory.initialize()`
+5. Add models to config mapping
+
+### Adding New API Endpoints
+1. Create router in `app/core/` or `app/admin/`
+2. Add endpoint with proper type hints
+3. Add to main app in `main.py` (include_router)
+4. Update docs if needed
+
+### Token Pool Customization
+1. Modify `app/utils/token_pool.py`
+2. Update token storage logic in `app/services/token_dao.py`
+3. Adjust failure thresholds in config
+
+## Directory Structure Reference
+
+```
+zai/
+├── app/
+│   ├── core/           # Core logic & config
+│   ├── providers/      # AI provider implementations
+│   ├── models/         # Schemas & DB models
+│   ├── services/       # Business logic (token mgmt)
+│   ├── utils/          # Helper utilities
+│   ├── admin/          # Admin panel & API
+│   └── templates/      # Web UI templates
+├── tests/              # Test files
+├── data/               # Persistent data (SQLite DB)
+├── logs/               # Application logs
+├── main.py             # Entry point
+├── docker-compose.yml  # Docker setup
+├── .env.example        # Environment template
+└── requirements.txt    # Python dependencies
+```
+
+## Release Checklist
+
+Before deploying new version:
+- [ ] Run `pytest` - all tests pass
+- [ ] Run `ruff check` - no linting errors
+- [ ] Update version in `pyproject.toml`
+- [ ] Test all providers (Z.AI, K2Think, LongCat)
+- [ ] Update `.env.example` if new vars added
+- [ ] Build Docker image & test
+- [ ] Update README if API changes
+
+## References
+
+- **Project Docs**: `README_DOCKER.md` (deployment)
+- **API Spec**: OpenAI Chat Completions API
+- **FastAPI Docs**: Built-in at `/docs` when running
+- **Docker Hub**: `zyphrzero/z-ai2api-python`
+
+---
+
+*This CLAUDE.md is relevant as of 2026-01-15. Last commit: f78578c*

app/providers/zai_provider.py

@@ -661,6 +661,8 @@ class ZAIProvider(BaseProvider):
             "X-Signature": signature,
         }
 
+        # 关键：从 transform_request 方法返回的数据中，token 同时用于 Authorization header 和 query params
+        # 但必须确保 URL 中的 token 与 header 中的 token 一致
         query_params = {
             "timestamp": str(timestamp_ms),
             "requestId": request_id,
@@ -701,6 +703,7 @@ class ZAIProvider(BaseProvider):
         try:
             # 转换请求
             transformed = await self.transform_request(request)
+            self.logger.debug(f"[chat_completion] 转换后的请求: {transformed['url'][:100]}...")
 
             # 根据请求类型返回响应
             if request.stream:
@@ -719,14 +722,28 @@ class ZAIProvider(BaseProvider):
                     )
 
                     if not response.is_success:
-                        error_msg = f"Z.AI API 错误: {response.status_code}"
+                        error_body = response.text[:500] if response.text else "无响应体"
+                        error_msg = f"Z.AI API 错误: {response.status_code}, 响应: {error_body}"
+                        self.logger.error(f"❌ 上游响应非成功: {error_msg}")
                         self.log_response(False, error_msg)
                         return self.handle_error(Exception(error_msg))
 
-                    return await self.transform_response(response, request, transformed)
+                    # 记录响应状态
+                    self.logger.info(f"✅ 上游响应成功: {response.status_code}, Content-Length: {response.headers.get('content-length', 'N/A')}")
+                    try:
+                        return await self.transform_response(response, request, transformed)
+                    except Exception as transform_error:
+                        self.logger.error(f"❌ transform_response 失败: {transform_error}")
+                        body_text = response.text[:1000] if response.text else "无响应体"
+                        self.logger.error(f"❌ 上游响应内容预览: {body_text}")
+                        raise
 
         except Exception as e:
-            self.log_response(False, str(e))
+            error_str = str(e)
+            self.logger.error(f"❌ chat_completion 异常捕获: {type(e).__name__}: {error_str}")
+            import traceback
+            self.logger.error(f"❌ 详细堆栈: {traceback.format_exc()}")
+            self.log_response(False, error_str)
             return self.handle_error(e, "请求处理")
 
     
@@ -1083,9 +1100,9 @@ class ZAIProvider(BaseProvider):
             yield "data: [DONE]\n\n"
     
     async def _handle_non_stream_response(
-        self, 
-        response: httpx.Response, 
-        chat_id: str, 
+        self,
+        response: httpx.Response,
+        chat_id: str,
         model: str
     ) -> Dict[str, Any]:
         """处理非流式响应
@@ -1102,12 +1119,19 @@ class ZAIProvider(BaseProvider):
             "total_tokens": 0,
         }
 
+        self.logger.info(f"[_handle_non_stream_response] 开始处理响应，Content-Type: {response.headers.get('content-type', '未知')}")
+
+        all_lines = []
         try:
             async for line in response.aiter_lines():
                 if not line:
                     continue
 
                 line = line.strip()
+                # 收集所有行用于调试
+                if line:
+                    self.logger.debug(f"[_handle_non_stream_response] 原始行: {line[:200]}")
+                    all_lines.append(line)
 
                 # 仅处理以 data: 开头的 SSE 行，其余行尝试作为错误/JSON 忽略
                 if not line.startswith("data:"):
@@ -1176,6 +1200,13 @@ class ZAIProvider(BaseProvider):
                     elif delta_content:
                         final_content += delta_content
 
+            # 循环结束后，记录所有采集的线和内容
+            self.logger.info(f"[_handle_non_stream_response] 处理完成，共 {len(all_lines)} 行数据")
+            self.logger.debug(f"[_handle_non_stream_response] 最终内容长度: {len(final_content)}, 思考长度: {len(reasoning_content)}")
+            if not final_content and not reasoning_content and len(all_lines) > 0:
+                self.logger.warning(f"[_handle_non_stream_response] 警告：未提取到内容，但接收到 {len(all_lines)} 行数据")
+                self.logger.warning(f"[_handle_non_stream_response] 前10行数据: {all_lines[:10]}")
+
         except Exception as e:
             self.logger.error(f"❌ 非流式响应处理错误: {e}")
             import traceback