fix: 错误次数计数、调试配置持久化、用量统计计算、日志输出

src/api/admin.py

@@ -594,11 +594,11 @@ async def update_debug_config(
 ):
     """Update debug configuration"""
     try:
-        # Import config instance
-        from ..core.config import config
+        # Update debug config in database
+        await db.update_debug_config(enabled=request.enabled)
 
-        # Update in-memory config
-        config.set_debug_enabled(request.enabled)
+        # 🔥 Hot reload: sync database config to memory
+        await db.reload_config_to_memory()
 
         status = "enabled" if request.enabled else "disabled"
         return {"success": True, "message": f"Debug mode {status}", "enabled": request.enabled}

src/core/database.py

@@ -127,6 +127,27 @@ class Database:
                 VALUES (1, ?, ?, ?)
             """, (cache_enabled, cache_timeout, cache_base_url))
 
+        # Ensure debug_config has a row
+        cursor = await db.execute("SELECT COUNT(*) FROM debug_config")
+        count = await cursor.fetchone()
+        if count[0] == 0:
+            debug_enabled = False
+            log_requests = True
+            log_responses = True
+            mask_token = True
+
+            if config_dict:
+                debug_config = config_dict.get("debug", {})
+                debug_enabled = debug_config.get("enabled", False)
+                log_requests = debug_config.get("log_requests", True)
+                log_responses = debug_config.get("log_responses", True)
+                mask_token = debug_config.get("mask_token", True)
+
+            await db.execute("""
+                INSERT INTO debug_config (id, enabled, log_requests, log_responses, mask_token)
+                VALUES (1, ?, ?, ?, ?)
+            """, (debug_enabled, log_requests, log_responses, mask_token))
+
     async def check_and_migrate_db(self, config_dict: dict = None):
         """Check database integrity and perform migrations if needed
 
@@ -198,6 +219,7 @@ class Database:
                     ("today_video_count", "INTEGER DEFAULT 0"),
                     ("today_error_count", "INTEGER DEFAULT 0"),
                     ("today_date", "DATE"),
+                    ("consecutive_error_count", "INTEGER DEFAULT 0"),  # 🆕 连续错误计数
                 ]
 
                 for col_name, col_type in stats_columns_to_add:
@@ -273,6 +295,7 @@ class Database:
                     today_video_count INTEGER DEFAULT 0,
                     today_error_count INTEGER DEFAULT 0,
                     today_date DATE,
+                    consecutive_error_count INTEGER DEFAULT 0,
                     FOREIGN KEY (token_id) REFERENCES tokens(id)
                 )
             """)
@@ -355,6 +378,19 @@ class Database:
                 )
             """)
 
+            # Debug config table
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS debug_config (
+                    id INTEGER PRIMARY KEY DEFAULT 1,
+                    enabled BOOLEAN DEFAULT 0,
+                    log_requests BOOLEAN DEFAULT 1,
+                    log_responses BOOLEAN DEFAULT 1,
+                    mask_token BOOLEAN DEFAULT 1,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+
             # Create indexes
             await db.execute("CREATE INDEX IF NOT EXISTS idx_task_id ON tasks(task_id)")
             await db.execute("CREATE INDEX IF NOT EXISTS idx_token_st ON tokens(st)")
@@ -669,7 +705,13 @@ class Database:
             await db.commit()
 
     async def increment_error_count(self, token_id: int):
-        """Increment error count with daily reset"""
+        """Increment error count with daily reset
+
+        Updates two counters:
+        - error_count: Historical total errors (never reset)
+        - consecutive_error_count: Consecutive errors (reset on success/enable)
+        - today_error_count: Today's errors (reset on date change)
+        """
         from datetime import date
         async with aiosqlite.connect(self.db_path) as db:
             today = str(date.today())
@@ -682,16 +724,18 @@ class Database:
                 await db.execute("""
                     UPDATE token_stats
                     SET error_count = error_count + 1,
+                        consecutive_error_count = consecutive_error_count + 1,
                         today_error_count = 1,
                         today_date = ?,
                         last_error_at = CURRENT_TIMESTAMP
                     WHERE token_id = ?
                 """, (today, token_id))
             else:
-                # Same day, just increment both
+                # Same day, just increment all counters
                 await db.execute("""
                     UPDATE token_stats
                     SET error_count = error_count + 1,
+                        consecutive_error_count = consecutive_error_count + 1,
                         today_error_count = today_error_count + 1,
                         today_date = ?,
                         last_error_at = CURRENT_TIMESTAMP
@@ -699,6 +743,21 @@ class Database:
                 """, (today, token_id))
             await db.commit()
 
+    async def reset_error_count(self, token_id: int):
+        """Reset consecutive error count (only reset consecutive_error_count, keep error_count and today_error_count)
+
+        This is called when:
+        - Token is manually enabled by admin
+        - Request succeeds (resets consecutive error counter)
+
+        Note: error_count (total historical errors) is NEVER reset
+        """
+        async with aiosqlite.connect(self.db_path) as db:
+            await db.execute("""
+                UPDATE token_stats SET consecutive_error_count = 0 WHERE token_id = ?
+            """, (token_id,))
+            await db.commit()
+
     # Config operations
     async def get_admin_config(self) -> Optional[AdminConfig]:
         """Get admin configuration"""
@@ -876,6 +935,11 @@ class Database:
             config.set_image_timeout(generation_config.image_timeout)
             config.set_video_timeout(generation_config.video_timeout)
 
+        # Reload debug config
+        debug_config = await self.get_debug_config()
+        if debug_config:
+            config.set_debug_enabled(debug_config.enabled)
+
     # Cache config operations
     async def get_cache_config(self) -> CacheConfig:
         """Get cache configuration"""
@@ -924,3 +988,57 @@ class Database:
                 """, (new_enabled, new_timeout, new_base_url))
 
             await db.commit()
+
+    # Debug config operations
+    async def get_debug_config(self) -> 'DebugConfig':
+        """Get debug configuration"""
+        from .models import DebugConfig
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            cursor = await db.execute("SELECT * FROM debug_config WHERE id = 1")
+            row = await cursor.fetchone()
+            if row:
+                return DebugConfig(**dict(row))
+            # Return default if not found
+            return DebugConfig(enabled=False, log_requests=True, log_responses=True, mask_token=True)
+
+    async def update_debug_config(
+        self,
+        enabled: bool = None,
+        log_requests: bool = None,
+        log_responses: bool = None,
+        mask_token: bool = None
+    ):
+        """Update debug configuration"""
+        async with aiosqlite.connect(self.db_path) as db:
+            db.row_factory = aiosqlite.Row
+            # Get current values
+            cursor = await db.execute("SELECT * FROM debug_config WHERE id = 1")
+            row = await cursor.fetchone()
+
+            if row:
+                current = dict(row)
+                # Use new values if provided, otherwise keep existing
+                new_enabled = enabled if enabled is not None else current.get("enabled", False)
+                new_log_requests = log_requests if log_requests is not None else current.get("log_requests", True)
+                new_log_responses = log_responses if log_responses is not None else current.get("log_responses", True)
+                new_mask_token = mask_token if mask_token is not None else current.get("mask_token", True)
+
+                await db.execute("""
+                    UPDATE debug_config
+                    SET enabled = ?, log_requests = ?, log_responses = ?, mask_token = ?, updated_at = CURRENT_TIMESTAMP
+                    WHERE id = 1
+                """, (new_enabled, new_log_requests, new_log_responses, new_mask_token))
+            else:
+                # Insert default row if not exists
+                new_enabled = enabled if enabled is not None else False
+                new_log_requests = log_requests if log_requests is not None else True
+                new_log_responses = log_responses if log_responses is not None else True
+                new_mask_token = mask_token if mask_token is not None else True
+
+                await db.execute("""
+                    INSERT INTO debug_config (id, enabled, log_requests, log_responses, mask_token)
+                    VALUES (1, ?, ?, ?, ?)
+                """, (new_enabled, new_log_requests, new_log_responses, new_mask_token))
+
+            await db.commit()

src/core/logger.py

@@ -239,5 +239,14 @@ class DebugLogger:
         except Exception as e:
             self.logger.error(f"Error logging info: {e}")
 
+    def log_warning(self, message: str):
+        """Log warning message to log.txt"""
+        if not config.debug_enabled:
+            return
+        try:
+            self.logger.warning(f"⚠️  [{self._format_timestamp()}] {message}")
+        except Exception as e:
+            self.logger.error(f"Error logging warning: {e}")
+
 # Global debug logger instance
 debug_logger = DebugLogger()

src/core/models.py

@@ -64,6 +64,8 @@ class TokenStats(BaseModel):
     today_video_count: int = 0
     today_error_count: int = 0
     today_date: Optional[str] = None
+    # 连续错误计数 (用于自动禁用判断)
+    consecutive_error_count: int = 0
 
 
 class Task(BaseModel):
@@ -127,6 +129,17 @@ class CacheConfig(BaseModel):
     updated_at: Optional[datetime] = None
 
 
+class DebugConfig(BaseModel):
+    """Debug configuration"""
+    id: int = 1
+    enabled: bool = False
+    log_requests: bool = True
+    log_responses: bool = True
+    mask_token: bool = True
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+
 # OpenAI Compatible Request Models
 class ChatMessage(BaseModel):
     """Chat message"""

src/main.py

@@ -62,6 +62,10 @@ async def lifespan(app: FastAPI):
     config.set_image_timeout(generation_config.image_timeout)
     config.set_video_timeout(generation_config.video_timeout)
 
+    # Load debug configuration from database
+    debug_config = await db.get_debug_config()
+    config.set_debug_enabled(debug_config.enabled)
+
     # Initialize concurrency manager
     tokens = await token_manager.get_all_tokens()
     await concurrency_manager.initialize(tokens)

src/services/generation_handler.py

@@ -440,10 +440,17 @@ class GenerationHandler:
                         yield self._create_stream_chunk("缓存图片中...\n")
                     cached_filename = await self.file_cache.download_and_cache(image_url, "image")
                     local_url = f"{self._get_base_url()}/tmp/{cached_filename}"
+                    if stream:
+                        yield self._create_stream_chunk("✅ 图片缓存成功,准备返回缓存地址...\n")
                 except Exception as e:
                     debug_logger.log_error(f"Failed to cache image: {str(e)}")
                     # 缓存失败不影响结果返回,使用原始URL
                     local_url = image_url
+                    if stream:
+                        yield self._create_stream_chunk(f"⚠️ 缓存失败: {str(e)}\n正在返回源链接...\n")
+            else:
+                if stream:
+                    yield self._create_stream_chunk("缓存已关闭,正在返回源链接...\n")
 
             # 返回结果
             if stream:
@@ -689,13 +696,20 @@ class GenerationHandler:
                     if config.cache_enabled:
                         try:
                             if stream:
-                                yield self._create_stream_chunk("缓存视频中...\n")
+                                yield self._create_stream_chunk("正在缓存视频文件...\n")
                             cached_filename = await self.file_cache.download_and_cache(video_url, "video")
                             local_url = f"{self._get_base_url()}/tmp/{cached_filename}"
+                            if stream:
+                                yield self._create_stream_chunk("✅ 视频缓存成功,准备返回缓存地址...\n")
                         except Exception as e:
                             debug_logger.log_error(f"Failed to cache video: {str(e)}")
                             # 缓存失败不影响结果返回,使用原始URL
                             local_url = video_url
+                            if stream:
+                                yield self._create_stream_chunk(f"⚠️ 缓存失败: {str(e)}\n正在返回源链接...\n")
+                    else:
+                        if stream:
+                            yield self._create_stream_chunk("缓存已关闭,正在返回源链接...\n")
 
                     # 更新数据库
                     task_id = operation["operation"]["name"]

src/services/token_manager.py

@@ -37,17 +37,10 @@ class TokenManager:
 
     async def enable_token(self, token_id: int):
         """Enable a token and reset error count"""
+        # Enable the token
         await self.db.update_token(token_id, is_active=True)
-        # Reset error count when enabling
-        async with self.db._lock if hasattr(self.db, '_lock') else asyncio.Lock():
-            import aiosqlite
-            async with aiosqlite.connect(self.db.db_path) as db:
-                await db.execute("""
-                    UPDATE token_stats
-                    SET error_count = 0, today_error_count = 0
-                    WHERE token_id = ?
-                """, (token_id,))
-                await db.commit()
+        # Reset error count when enabling (only reset total error_count, keep today_error_count)
+        await self.db.reset_error_count(token_id)
 
     async def disable_token(self, token_id: int):
         """Disable a token"""
@@ -365,17 +358,25 @@ class TokenManager:
         """Record token error and auto-disable if threshold reached"""
         await self.db.increment_token_stats(token_id, "error")
 
-        # Check if should auto-disable token
+        # Check if should auto-disable token (based on consecutive errors)
         stats = await self.db.get_token_stats(token_id)
         admin_config = await self.db.get_admin_config()
 
-        if stats and stats.error_count >= admin_config.error_ban_threshold:
+        if stats and stats.consecutive_error_count >= admin_config.error_ban_threshold:
             debug_logger.log_warning(
-                f"[TOKEN_BAN] Token {token_id} error count ({stats.error_count}) "
+                f"[TOKEN_BAN] Token {token_id} consecutive error count ({stats.consecutive_error_count}) "
                 f"reached threshold ({admin_config.error_ban_threshold}), auto-disabling"
             )
             await self.disable_token(token_id)
 
+    async def record_success(self, token_id: int):
+        """Record successful request (reset consecutive error count)
+
+        This method resets error_count to 0, which is used for auto-disable threshold checking.
+        Note: today_error_count and historical statistics are NOT reset.
+        """
+        await self.db.reset_error_count(token_id)
+
     # ========== 余额刷新 ==========
 
     async def refresh_credits(self, token_id: int) -> int:

static/manage.html

@@ -287,7 +287,7 @@
                                 <input type="checkbox" id="cfgDebugEnabled" class="h-4 w-4 rounded border-input" onchange="toggleDebugMode()">
                                 <span class="text-sm font-medium">启用调试模式</span>
                             </label>
-                            <p class="text-xs text-muted-foreground mt-2">开启后，详细的上游API请求和响应日志将写入 <code class="bg-muted px-1 py-0.5 rounded">logs.txt</code> 文件，重启生效</p>
+                            <p class="text-xs text-muted-foreground mt-2">开启后，详细的上游API请求和响应日志将写入 <code class="bg-muted px-1 py-0.5 rounded">logs.txt</code> 文件</p>
                         </div>
                         <div class="rounded-md bg-yellow-50 dark:bg-yellow-900/20 p-3 border border-yellow-200 dark:border-yellow-800">
                             <p class="text-xs text-yellow-800 dark:text-yellow-200">