update sth at 2026-01-15 17:04:29

KEEP_RUNNING.md

@@ -0,0 +1,35 @@
+name: Keep HuggingFace Space Alive
+
+on:
+  schedule:
+    # 每 5 分钟触发一次
+    - cron: '*/5 * * * *'
+  workflow_dispatch:  # 支持手动触发
+
+jobs:
+  keep-alive:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check Space Health
+        run: |
+          echo "🚀 发送心跳到 HuggingFace Space"
+          curl -s -o /dev/null -w "HTTP 状态码: %{http_code}, 耗时: %{time_total}s\n" \
+            https://sanbo1200-zai.hf.space/hf/v1/models || true
+
+      - name: Test API Endpoint (可选)
+        env:
+          API_KEY: ${{ secrets.API_KEY }}
+        run: |
+          # 如果有 API key，测试真实请求
+          if [ -n "$API_KEY" ]; then
+            echo "测试 API 调用..."
+            curl -s -X POST https://sanbo1200-zai.hf.space/hf/v1/chat/completions \
+              -H "Content-Type: application/json" \
+              -H "Authorization: Bearer $API_KEY" \
+              -d '{"model":"GLM-4.5","messages":[{"role":"user","content":"ping"}],"stream":false}' \
+              -o /dev/null -w "API 调用状态: %{http_code}\n" || true
+          fi
+
+      - name: Log Time
+        run: echo "心跳发送完成: $(date -u)"

app/providers/zai_provider.py

@@ -705,6 +705,7 @@ class ZAIProvider(BaseProvider):
             transformed = await self.transform_request(request)
             self.logger.debug(f"[chat_completion] 转换后的请求: {transformed['url'][:100]}...")
 
+
             # 根据请求类型返回响应
             if request.stream:
                 # 流式响应
@@ -713,8 +714,11 @@ class ZAIProvider(BaseProvider):
                 # Get proxy configuration
                 proxies = self._get_proxy_config()
 
-                # 非流式响应
-                async with httpx.AsyncClient(timeout=30.0, proxy=proxies) as client:
+                # 非流式响应 - 增加超时时间到90秒，Z.AI API 有时响应较慢
+                # 使用扩展的超时配置：连接5秒，读取85秒
+                extended_timeout = httpx.Timeout(5.0, read=85.0, connect=5.0)
+                async with httpx.AsyncClient(timeout=extended_timeout, proxy=proxies) as client:
+                    self.logger.info(f"🔄 发送非流式请求到 Z.AI (超时: 90秒): {transformed['url']}")
                     response = await client.post(
                         transformed["url"],
                         headers=transformed["headers"],
@@ -731,7 +735,13 @@ class ZAIProvider(BaseProvider):
                     # 记录响应状态
                     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)
+                        # 修正：立即调用正确的处理方法
+                        if request.stream:
+                            return self._create_stream_response(request, transformed)
+                        else:
+                            chat_id = transformed.get("chat_id", "unknown")
+                            model = transformed.get("model", "unknown")
+                            return await self._handle_non_stream_response(response, chat_id, model)
                     except Exception as transform_error:
                         self.logger.error(f"❌ transform_response 失败: {transform_error}")
                         body_text = response.text[:1000] if response.text else "无响应体"
@@ -827,21 +837,6 @@ class ZAIProvider(BaseProvider):
             yield "data: [DONE]\n\n"
             return
 
-    async def transform_response(
-        self, 
-        response: httpx.Response, 
-        request: OpenAIRequest,
-        transformed: Dict[str, Any]
-    ) -> Union[Dict[str, Any], AsyncGenerator[str, None]]:
-        """转换Z.AI响应为OpenAI格式"""
-        chat_id = transformed["chat_id"]
-        model = transformed["model"]
-        
-        if request.stream:
-            return self._handle_stream_response(response, chat_id, model, request, transformed)
-        else:
-            return await self._handle_non_stream_response(response, chat_id, model)
-    
     async def _handle_stream_response(
         self,
         response: httpx.Response,
@@ -1122,15 +1117,27 @@ class ZAIProvider(BaseProvider):
         self.logger.info(f"[_handle_non_stream_response] 开始处理响应，Content-Type: {response.headers.get('content-type', '未知')}")
 
         all_lines = []
+        line_count = 0
+        max_lines = 1000  # 限制读取行数，防止无限读取
+        read_timeout_count = 0
+        max_timeout_retries = 2  # 最大超时重试次数
+
         try:
             async for line in response.aiter_lines():
                 if not line:
                     continue
 
                 line = line.strip()
+
+                # 数量限制：防止无限读取
+                line_count += 1
+                if line_count > max_lines:
+                    self.logger.warning(f"⚠️ 行数超过限制 {max_lines}，停止读取")
+                    break
+
                 # 收集所有行用于调试
                 if line:
-                    self.logger.debug(f"[_handle_non_stream_response] 原始行: {line[:200]}")
+                    self.logger.debug(f"[_handle_non_stream_response] 原始行 [{line_count}]: {line[:200]}")
                     all_lines.append(line)
 
                 # 仅处理以 data: 开头的 SSE 行，其余行尝试作为错误/JSON 忽略
@@ -1201,13 +1208,20 @@ class ZAIProvider(BaseProvider):
                         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)}")
+            self.logger.info(f"[_handle_non_stream_response] 处理完成 - 总行数: {line_count}, 有效SSE行: {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]}")
+                self.logger.warning(f"[_handle_non_stream_response] ⚠️ 未提取到内容，但收到 {len(all_lines)} 行数据")
+                self.logger.warning(f"[_handle_non_stream_response] 调试数据: {all_lines[:5]}")
 
         except Exception as e:
+            # 特殊处理超时异常，提供降级方案
+            if "ReadTimeout" in str(type(e).__name__) or "Timeout" in str(type(e).__name__):
+                self.logger.error(f"⏰ 读取超时异常 - 已处理 {line_count} 行数据，部分结果: {len(final_content)}字")
+                if final_content or reasoning_content:
+                    self.logger.warning(f"⚠️ 虽然超时，但返回已收集的内容，用户仍可获得部分响应")
+                    # 继续执行后续的清理返回逻辑，不立即返回错误
             self.logger.error(f"❌ 非流式响应处理错误: {e}")
             import traceback
             self.logger.error(traceback.format_exc())

uptime-heartbeat.py

@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Uptime Robot 心跳保活脚本
+使用方法：
+1. 在 Uptime Robot 创建监控，类型: HTTP(s)，URL: https://{your-space}.hf.space/hf/v1/models
+2. 间隔设置为 5-10 分钟
+3. 或者直接用此脚本本地运行
+"""
+
+import time
+import requests
+import os
+from datetime import datetime
+
+def send_heartbeat():
+    """发送心跳请求到 HuggingFace Space"""
+
+    # 你的 Space URL
+    # 实际的 HuggingFace Space 域名格式: https://sanbo1200-zai.hf.space
+    SPACE_URL = os.getenv("HF_SPACE_URL", "https://sanbo1200-zai.hf.space")
+
+    # 测试的健康检查端点（使用 /hf/v1/models 轻量级接口）
+    HEALTH_URL = f"{SPACE_URL}/hf/v1/models"
+
+    try:
+        start_time = datetime.now()
+        response = requests.get(
+            HEALTH_URL,
+            timeout=10,
+            headers={
+                "User-Agent": "UptimeMonitor/1.0"
+            }
+        )
+        end_time = datetime.now()
+        response_time = (end_time - start_time).total_seconds() * 1000
+
+        if response.status_code == 200:
+            print(f"✅ [{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 心跳成功 - {response_time:.0f}ms")
+            return True
+        else:
+            print(f"⚠️ [{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 心跳失败 - 状态码: {response.status_code}")
+            return False
+
+    except requests.exceptions.RequestException as e:
+        print(f"❌ [{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 连接错误: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("🚀 HuggingFace Space 保活服务启动")
+    print(f"目标空间: https://sanbo1200-zai.hf.space")
+    print("发送间隔: 每 5 分钟 (默认)\n")
+
+    while True:
+        send_heartbeat()
+        time.sleep(300)  # 5分钟 = 300秒