fix: tts/media

Author: Mag1cFall

src/media/imagen_controller.py

@@ -140,8 +140,8 @@ async def run_generation(self, check_client_disconnected: Callable):
                 await self.page.keyboard.press('Escape')
                 await asyncio.sleep(0.15)
                 run_btn = self.page.locator(IMAGEN_RUN_BUTTON_SELECTOR)
-                await expect_async(run_btn).to_be_visible(timeout=5000)
-                await expect_async(run_btn).to_be_enabled(timeout=5000)
+                await expect_async(run_btn).to_be_visible(timeout=10000)
+                await expect_async(run_btn).to_be_enabled(timeout=10000)
                 if not await safe_click(run_btn, 'Run 按钮', self.req_id):
                     if attempt < max_retries:
                         continue
@@ -154,7 +154,7 @@ async def run_generation(self, check_client_disconnected: Callable):
                     raise
                 self.logger.warning(f'[{self.req_id}] 点击 Run 失败 (尝试 {attempt}): {e}')
             if attempt < max_retries:
-                await asyncio.sleep(0.15)
+                await asyncio.sleep(0.5)
         raise Exception('点击 Run 按钮失败')
 
     async def wait_for_images(self, expected_count: int, check_client_disconnected: Callable, timeout_seconds: int = 180) -> List[GeneratedImage]:

src/media/media_processor.py

@@ -19,50 +19,65 @@ async def process_nano_request(
     req_id: str,
     check_client_disconnected: Callable
 ) -> Dict[str, Any]:
-    controller = NanoController(page, logger, req_id)
-    
-    await controller.navigate_to_nano_page(config.model, check_client_disconnected)
-    
-    if config.aspect_ratio and config.aspect_ratio != '1:1':
-        await controller.set_aspect_ratio(config.aspect_ratio, check_client_disconnected)
-    
-    if config.image_bytes:
-        await controller.upload_image(
-            config.image_bytes,
-            config.image_mime_type or 'image/png',
-            check_client_disconnected
-        )
-    
-    await controller.fill_prompt(config.prompt, check_client_disconnected)
-    await controller.run_generation(check_client_disconnected)
-    
-    content = await controller.wait_for_content(check_client_disconnected)
-    
-    response_parts = []
-    
-    if content.text:
-        response_parts.append({
-            'text': content.text
-        })
-    
-    for img in content.images:
-        response_parts.append({
-            'inlineData': {
-                'mimeType': img.mime_type,
-                'data': base64.b64encode(img.image_bytes).decode('utf-8')
+    max_retries = 3
+    last_error = None
+    
+    for attempt in range(1, max_retries + 1):
+        try:
+            controller = NanoController(page, logger, req_id)
+            
+            await controller.navigate_to_nano_page(config.model, check_client_disconnected)
+            
+            if config.aspect_ratio and config.aspect_ratio != '1:1':
+                await controller.set_aspect_ratio(config.aspect_ratio, check_client_disconnected)
+            
+            if config.image_bytes:
+                await controller.upload_image(
+                    config.image_bytes,
+                    config.image_mime_type or 'image/png',
+                    check_client_disconnected
+                )
+            
+            await controller.fill_prompt(config.prompt, check_client_disconnected)
+            await controller.run_generation(check_client_disconnected)
+            
+            content = await controller.wait_for_content(check_client_disconnected)
+            
+            response_parts = []
+            
+            if content.text:
+                response_parts.append({
+                    'text': content.text
+                })
+            
+            for img in content.images:
+                response_parts.append({
+                    'inlineData': {
+                        'mimeType': img.mime_type,
+                        'data': base64.b64encode(img.image_bytes).decode('utf-8')
+                    }
+                })
+            
+            return {
+                'candidates': [{
+                    'content': {
+                        'parts': response_parts,
+                        'role': 'model'
+                    },
+                    'finishReason': 'STOP'
+                }],
+                'modelVersion': config.model
             }
-        })
-    
-    return {
-        'candidates': [{
-            'content': {
-                'parts': response_parts,
-                'role': 'model'
-            },
-            'finishReason': 'STOP'
-        }],
-        'modelVersion': config.model
-    }
+        except Exception as e:
+            last_error = e
+            if 'ClientDisconnected' in str(type(e).__name__):
+                raise
+            logger.warning(f'[{req_id}] Nano 请求失败 (尝试 {attempt}/{max_retries}): {e}')
+            if attempt < max_retries:
+                import asyncio
+                await asyncio.sleep(1)
+    
+    raise last_error if last_error else Exception('Nano 请求失败')
 
 
 async def process_image_request(

src/media/nano_controller.py

@@ -146,8 +146,8 @@ async def run_generation(self, check_client_disconnected: Callable):
                 await self.page.keyboard.press('Escape')
                 await asyncio.sleep(0.15)
                 run_btn = self.page.locator(SUBMIT_BUTTON_SELECTOR)
-                await expect_async(run_btn).to_be_visible(timeout=5000)
-                await expect_async(run_btn).to_be_enabled(timeout=5000)
+                await expect_async(run_btn).to_be_visible(timeout=10000)
+                await expect_async(run_btn).to_be_enabled(timeout=10000)
                 if not await safe_click(run_btn, 'Run 按钮', self.req_id):
                     if attempt < max_retries:
                         continue
@@ -160,7 +160,7 @@ async def run_generation(self, check_client_disconnected: Callable):
                     raise
                 self.logger.warning(f'[{self.req_id}] 点击 Run 失败 (尝试 {attempt}): {e}')
             if attempt < max_retries:
-                await asyncio.sleep(0.15)
+                await asyncio.sleep(0.5)
         raise Exception('点击 Run 按钮失败')
 
     async def wait_for_content(self, check_client_disconnected: Callable, timeout_seconds: int = 120) -> GeneratedContent:
@@ -172,6 +172,7 @@ async def wait_for_content(self, check_client_disconnected: Callable, timeout_se
         result = GeneratedContent()
         last_chunk_count = 0
         stable_count = 0
+        no_progress_count = 0
 
         while True:
             elapsed = asyncio.get_event_loop().time() - start_time
@@ -183,6 +184,10 @@ async def wait_for_content(self, check_client_disconnected: Callable, timeout_se
             await self._check_disconnect(check_client_disconnected, f'等待内容 ({int(elapsed)}s)')
 
             try:
+                error_detected = await self._check_for_error()
+                if error_detected:
+                    self.logger.error(f'[{self.req_id}] ❌ 检测到生成错误: {error_detected}')
+                    raise Exception(f'生成失败: {error_detected}')
                 chunk_count = await image_chunk_locator.count()
                 self.logger.info(f'[{self.req_id}] 检测到图片块数量: {chunk_count}')
 
@@ -225,12 +230,41 @@ async def wait_for_content(self, check_client_disconnected: Callable, timeout_se
                     else:
                         stable_count = 0
                     last_chunk_count = chunk_count
+                elif not is_generating and chunk_count == 0 and not result.text:
+                    no_progress_count += 1
+                    if no_progress_count >= 40:
+                        self.logger.warning(f'[{self.req_id}] ⚠️ 长时间无进展，可能生成失败')
+                        raise Exception('生成无响应，可能失败')
+                else:
+                    no_progress_count = 0
 
             except Exception as e:
+                if 'ClientDisconnected' in str(type(e).__name__):
+                    raise
+                if '生成失败' in str(e) or '生成无响应' in str(e):
+                    raise
                 self.logger.warning(f'[{self.req_id}] 检查内容时出错: {e}')
 
             await asyncio.sleep(0.25)
 
+    async def _check_for_error(self):
+        error_selectors = [
+            'mat-snack-bar-container .mdc-snackbar__label',
+            '.error-toast span.content-text',
+            'ms-callout[severity="error"] .content-container',
+            '.mat-mdc-snack-bar-label'
+        ]
+        for sel in error_selectors:
+            try:
+                locator = self.page.locator(sel)
+                if await locator.count() > 0 and await locator.first.is_visible():
+                    text = await locator.first.inner_text(timeout=1000)
+                    if text and text.strip():
+                        return text.strip()
+            except:
+                pass
+        return None
+
     async def _extract_images_via_download(self, count: int) -> List[GeneratedImage]:
         import tempfile
         import os

src/media/veo_controller.py

@@ -165,17 +165,17 @@ async def upload_image(self, image_bytes: bytes, mime_type: str, check_client_di
                         'mimeType': mime_type,
                         'buffer': image_bytes
                     })
-                    await asyncio.sleep(0.8)
+                    await asyncio.sleep(0.3)
                     await self.page.keyboard.press('Escape')
-                    await asyncio.sleep(0.25)
+                    await asyncio.sleep(0.15)
                     self.logger.info(f'[{self.req_id}] ✅ 图片已上传')
                     return
             except Exception as e:
                 if isinstance(e, ClientDisconnectedError):
                     raise
                 self.logger.warning(f'[{self.req_id}] 上传图片失败 (尝试 {attempt}): {e}')
             if attempt < max_retries:
-                await asyncio.sleep(0.25)
+                await asyncio.sleep(0.15)
 
     async def fill_prompt(self, prompt: str, check_client_disconnected: Callable):
         self.logger.info(f'[{self.req_id}] 填充提示词 ({len(prompt)} chars)')
@@ -206,8 +206,8 @@ async def run_generation(self, check_client_disconnected: Callable):
                 await self.page.keyboard.press('Escape')
                 await asyncio.sleep(0.15)
                 run_btn = self.page.locator(VEO_RUN_BUTTON_SELECTOR)
-                await expect_async(run_btn).to_be_visible(timeout=5000)
-                await expect_async(run_btn).to_be_enabled(timeout=5000)
+                await expect_async(run_btn).to_be_visible(timeout=10000)
+                await expect_async(run_btn).to_be_enabled(timeout=10000)
                 if not await safe_click(run_btn, 'Run 按钮', self.req_id):
                     if attempt < max_retries:
                         continue
@@ -220,7 +220,7 @@ async def run_generation(self, check_client_disconnected: Callable):
                     raise
                 self.logger.warning(f'[{self.req_id}] 点击 Run 失败 (尝试 {attempt}): {e}')
             if attempt < max_retries:
-                await asyncio.sleep(0.15)
+                await asyncio.sleep(0.5)
         raise Exception('点击 Run 按钮失败')
 
     async def wait_for_videos(self, expected_count: int, check_client_disconnected: Callable, timeout_seconds: int = 300) -> List[GeneratedVideo]:

src/tts/tts_controller.py

@@ -111,18 +111,30 @@ async def set_voice(self, voice_name: str, speaker_index: int = 0, check_client_
                     continue
                 await asyncio.sleep(0.15)
                 option = self.page.locator(f'{TTS_SETTINGS_VOICE_OPTION_SELECTOR}:has-text("{voice_name}")')
-                if await option.count() > 0:
-                    if await safe_click(option.first, f'语音选项 {voice_name}', self.req_id):
-                        self.logger.info(f'[{self.req_id}] ✅ 语音已设置: {voice_name}')
-                        return
-                else:
-                    self.logger.warning(f'[{self.req_id}] 未找到语音选项: {voice_name}')
+                try:
+                    await expect_async(option.first).to_be_visible(timeout=3000)
+                except PlaywrightTimeoutError:
+                    self.logger.warning(f'[{self.req_id}] 语音选项 {voice_name} 未出现 (尝试 {attempt})')
                     await self.page.keyboard.press('Escape')
+                    await asyncio.sleep(0.2)
+                    continue
+                if await safe_click(option.first, f'语音选项 {voice_name}', self.req_id):
+                    await asyncio.sleep(0.15)
+                    self.logger.info(f'[{self.req_id}] ✅ 语音已设置: {voice_name}')
                     return
+                else:
+                    self.logger.warning(f'[{self.req_id}] 语音选项点击失败 (尝试 {attempt})')
+                    await self.page.keyboard.press('Escape')
+                    await asyncio.sleep(0.2)
+                    continue
             except Exception as e:
                 if isinstance(e, ClientDisconnectedError):
                     raise
                 self.logger.warning(f'[{self.req_id}] 设置语音失败 (尝试 {attempt}): {e}')
+                try:
+                    await self.page.keyboard.press('Escape')
+                except:
+                    pass
             if attempt < max_retries:
                 await asyncio.sleep(0.15)