fix: align image generation with current Grok website behavior

- Accept all cardAttachment image types: render_generated_image,
  render_edited_image, AND render_searched_image (Grok now returns
  searched images when it decides not to generate)
- Remove ws_imagine (WebSocket) fallback — deprecated endpoint,
  always returns 401
- Fix loguru format strings (%s → {}) for proper error logging
- Add on-demand CF clearance refresh on 403 with 60s debounce

Author: JinchengGao-Infty

app/services/grok/services/image.py

@@ -107,36 +107,16 @@ async def _stream_retry() -> AsyncGenerator[str, None]:
                     tried_tokens.add(current_token)
                     yielded = False
                     try:
-                        try:
-                            result = await self._stream_app_chat(
-                                token_mgr=token_mgr,
-                                token=current_token,
-                                model_info=model_info,
-                                prompt=prompt,
-                                n=n,
-                                response_format=response_format,
-                                enable_nsfw=enable_nsfw,
-                                chat_format=chat_format,
-                            )
-                        except UpstreamException as app_chat_error:
-                            if rate_limited(app_chat_error):
-                                raise
-                            logger.warning(
-                                "App-chat image stream failed, falling back to ws_imagine: %s",
-                                app_chat_error,
-                            )
-                            result = await self._stream_ws(
-                                token_mgr=token_mgr,
-                                token=current_token,
-                                model_info=model_info,
-                                prompt=prompt,
-                                n=n,
-                                response_format=response_format,
-                                size=size,
-                                aspect_ratio=aspect_ratio,
-                                enable_nsfw=enable_nsfw,
-                                chat_format=chat_format,
-                            )
+                        result = await self._stream_app_chat(
+                            token_mgr=token_mgr,
+                            token=current_token,
+                            model_info=model_info,
+                            prompt=prompt,
+                            n=n,
+                            response_format=response_format,
+                            enable_nsfw=enable_nsfw,
+                            chat_format=chat_format,
+                        )
                         async for chunk in result.data:
                             yielded = True
                             yield chunk
@@ -186,34 +166,15 @@ async def _stream_retry() -> AsyncGenerator[str, None]:
 
             tried_tokens.add(current_token)
             try:
-                try:
-                    return await self._collect_app_chat(
-                        token_mgr=token_mgr,
-                        token=current_token,
-                        model_info=model_info,
-                        prompt=prompt,
-                        n=n,
-                        response_format=response_format,
-                        enable_nsfw=enable_nsfw,
-                    )
-                except UpstreamException as app_chat_error:
-                    if rate_limited(app_chat_error):
-                        raise
-                    logger.warning(
-                        "App-chat image collect failed, falling back to ws_imagine: %s",
-                        app_chat_error,
-                    )
-                    return await self._collect_ws(
-                        token_mgr=token_mgr,
-                        token=current_token,
-                        model_info=model_info,
-                        tried_tokens=tried_tokens,
-                        prompt=prompt,
-                        n=n,
-                        response_format=response_format,
-                        aspect_ratio=aspect_ratio,
-                        enable_nsfw=enable_nsfw,
-                    )
+                return await self._collect_app_chat(
+                    token_mgr=token_mgr,
+                    token=current_token,
+                    model_info=model_info,
+                    prompt=prompt,
+                    n=n,
+                    response_format=response_format,
+                    enable_nsfw=enable_nsfw,
+                )
             except UpstreamException as e:
                 last_error = e
                 if rate_limited(e):

app/services/grok/services/image_edit.py

@@ -348,10 +348,16 @@ async def process(
                 if ca := resp.get("cardAttachment"):
                     try:
                         jd = orjson.loads(ca.get("jsonData", b"{}"))
-                        if jd.get("type") in ("render_generated_image", "render_edited_image"):
+                        card_type = jd.get("type", "")
+                        url = None
+                        if card_type in ("render_generated_image", "render_edited_image"):
                             chunk = jd.get("image_chunk", {})
                             if chunk.get("progress", 0) >= 100 and chunk.get("imageUrl"):
                                 url = f"https://assets.grok.com/{chunk['imageUrl']}"
+                        elif card_type == "render_searched_image":
+                            img = jd.get("image", {})
+                            url = img.get("original") or img.get("thumbnail")
+                        if url:
                                 if self.response_format == "url":
                                     processed = await self.process_url(url, "image")
                                     if processed:
@@ -536,10 +542,16 @@ async def process(self, response: AsyncIterable[bytes]) -> List[str]:
                 if ca := resp.get("cardAttachment"):
                     try:
                         jd = orjson.loads(ca.get("jsonData", b"{}"))
-                        if jd.get("type") in ("render_generated_image", "render_edited_image"):
+                        card_type = jd.get("type", "")
+                        url = None
+                        if card_type in ("render_generated_image", "render_edited_image"):
                             chunk = jd.get("image_chunk", {})
                             if chunk.get("progress", 0) >= 100 and chunk.get("imageUrl"):
                                 url = f"https://assets.grok.com/{chunk['imageUrl']}"
+                        elif card_type == "render_searched_image":
+                            img = jd.get("image", {})
+                            url = img.get("original") or img.get("thumbnail")
+                        if url:
                                 if self.response_format == "url":
                                     processed = await self.process_url(url, "image")
                                     if processed:
@@ -558,8 +570,8 @@ async def process(self, response: AsyncIterable[bytes]) -> List[str]:
                                         processed = await self.process_url(url, "image")
                                         if processed:
                                             images.append(processed)
-                    except Exception:
-                        pass
+                    except Exception as card_err:
+                        logger.warning(f"cardAttachment processing error: {card_err}")
 
                 if mr := resp.get("modelResponse"):
                     if urls := _collect_images(mr):

app/services/reverse/app_chat.py

@@ -2,7 +2,9 @@
 Reverse interface: app chat conversations.
 """
 
+import asyncio
 import inspect
+import time
 import orjson
 from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
@@ -19,6 +21,35 @@
 CHAT_API = "https://grok.com/rest/app-chat/conversations/new"
 _LAST_PROXY_LOG_STATE: tuple[str, str] | None = None
 
+# CF 刷新防抖：60 秒内不重复刷新
+_last_cf_refresh_time: float = 0.0
+_cf_refresh_lock = asyncio.Lock()
+_CF_REFRESH_COOLDOWN = 60.0
+
+
+async def _trigger_cf_refresh_on_403() -> bool:
+    """403 时触发一次 CF clearance 刷新（带防抖）"""
+    global _last_cf_refresh_time
+    now = time.monotonic()
+    if now - _last_cf_refresh_time < _CF_REFRESH_COOLDOWN:
+        logger.debug("CF refresh skipped (cooldown)")
+        return False
+    async with _cf_refresh_lock:
+        # 双重检查
+        now = time.monotonic()
+        if now - _last_cf_refresh_time < _CF_REFRESH_COOLDOWN:
+            return False
+        logger.info("403 detected, triggering on-demand CF refresh...")
+        try:
+            from app.services.cf_refresh.scheduler import refresh_once
+            success = await refresh_once()
+            _last_cf_refresh_time = time.monotonic()
+            return success
+        except Exception as e:
+            logger.error("On-demand CF refresh failed: {}", e)
+            _last_cf_refresh_time = time.monotonic()
+            return False
+
 
 def _normalize_chat_proxy(proxy_url: str) -> str:
     """Normalize proxy URL for curl-cffi app-chat requests."""
@@ -291,7 +322,7 @@ async def _do_request():
                     content_type = str(response.headers.get("content-type", ""))
 
                     logger.error(
-                        "AppChatReverse: Chat failed, %s, content_type=%s, body=%s",
+                        "AppChatReverse: Chat failed, {}, content_type={}, body={}",
                         response.status_code,
                         content_type,
                         content[:500],
@@ -313,6 +344,8 @@ def extract_status(e: Exception) -> Optional[int]:
             async def _on_retry(attempt: int, status_code: int, error: Exception, delay: float):
                 if active_proxy_key and should_rotate_proxy(status_code):
                     rotate_proxy(active_proxy_key)
+                if status_code == 403:
+                    await _trigger_cf_refresh_on_403()
 
             response = await retry_on_status(
                 _do_request,