Update app/providers/notion_provider.py

app/providers/notion_provider.py

@@ -4,13 +4,10 @@ import time
 import logging
 import uuid
 import re
-import random
+import cloudscraper
 from typing import Dict, Any, AsyncGenerator, List, Optional, Tuple
 from datetime import datetime
 
-import requests
-import cloudscraper
-
 from fastapi import HTTPException
 from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.concurrency import run_in_threadpool
@@ -22,172 +19,30 @@ from app.utils.sse_utils import create_sse_data, create_chat_completion_chunk, D
 # 设置日志记录器
 logger = logging.getLogger(__name__)
 
-# --- 会话/重试常量 ---
-SCRAPER_LIFETIME_SEC = 45 * 60                 # Scraper 最长存活 45 分钟（超时后自动重建）
-HTTP_MAX_RETRIES      = 3                      # 单个 HTTP 请求最大重试次数
-RETRYABLE_STATUS      = {401, 403, 429, 502, 503, 504}
-BASE_BACKOFF_SEC      = 1.0                    # 指数退避初始秒
-BACKOFF_JITTER_SEC    = 0.25                   # 退避抖动
-API_REQUEST_TIMEOUT   = getattr(settings, "API_REQUEST_TIMEOUT", 60)
-
-
 class NotionAIProvider(BaseProvider):
     def __init__(self):
-        # 仅校验三件套；**不读取 NOTION_THREAD_ID**
-        if not all([settings.NOTION_COOKIE, settings.NOTION_SPACE_ID, settings.NOTION_USER_ID]):
-            raise ValueError("配置错误: NOTION_COOKIE, NOTION_SPACE_ID 和 NOTION_USER_ID 必须在 .env 中全部设置。")
-
         self.scraper = cloudscraper.create_scraper()
-        self._scraper_born_at = time.time()
-
         self.api_endpoints = {
             "runInference": "https://www.notion.so/api/v3/runInferenceTranscript",
-            "saveTransactionsFanout": "https://www.notion.so/api/v3/saveTransactionsFanout",
-            "saveTransactions": "https://www.notion.so/api/v3/saveTransactions",
+            "saveTransactions": "https://www.notion.so/api/v3/saveTransactionsFanout"
         }
+        
+        if not all([settings.NOTION_COOKIE, settings.NOTION_SPACE_ID, settings.NOTION_USER_ID]):
+            raise ValueError("配置错误: NOTION_COOKIE, NOTION_SPACE_ID 和 NOTION_USER_ID 必须在 .env 文件中全部设置。")
 
-        # 预热可失败，不阻塞启动；请求阶段还有兜底重试
-        try:
-            self._warmup_session()
-        except Exception as e:
-            logger.warning("会话预热失败但不影响启动：%s", e)
+        self._warmup_session()
 
-    # ----------------------------------------------------------------------
-    # Scraper 生命周期与预热
-    # ----------------------------------------------------------------------
-    def _refresh_scraper(self, reason: str = "") -> None:
-        """重建 cloudscraper（应对 CF 验证失败/会话过期）。"""
+    def _warmup_session(self):
         try:
-            self.scraper.close()
-        except Exception:
-            pass
-        self.scraper = cloudscraper.create_scraper()
-        self._scraper_born_at = time.time()
-        logger.info("重建 cloudscraper 会话。原因：%s", reason or "未指定")
-
-    def _get_scraper(self):
-        if time.time() - self._scraper_born_at > SCRAPER_LIFETIME_SEC:
-            self._refresh_scraper("生命周期已到")
-        return self.scraper
-
-    def _normalize_cookie(self, raw: str) -> str:
-        c = (raw or "").strip()
-        if not c:
-            return ""
-        # 若仅填了 token_v2 的值，这里补齐键名
-        if "token_v2=" not in c:
-            c = f"token_v2={c}"
-        return c
-
-    def _prepare_headers(self) -> Dict[str, str]:
-        cookie_header = self._normalize_cookie(settings.NOTION_COOKIE)
-        return {
-            "Content-Type": "application/json",
-            "Accept": "application/x-ndjson",
-            "Cookie": cookie_header,
-            "x-notion-space-id": settings.NOTION_SPACE_ID,
-            "x-notion-active-user-header": settings.NOTION_USER_ID,
-            "x-notion-client-version": getattr(settings, "NOTION_CLIENT_VERSION", "23.13.20251011.2037"),
-            "notion-audit-log-platform": "web",
-            "Origin": "https://www.notion.so",
-            "Referer": "https://www.notion.so/",
-            "User-Agent": (
-                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
-                "AppleWebKit(537.36) (KHTML, like Gecko) "
-                "Chrome/125.0.0.0 Safari/537.36"
-            ),
-        }
-
-    def _warmup_session(self) -> None:
-        """轻量预热；遭遇 429 采用退避，不抛异常。"""
-        s = self._get_scraper()
-        headers = self._prepare_headers().copy()
-        headers.pop("Accept", None)  # 预热不要 ndjson
-        url = "https://www.notion.so/"
-        for attempt in range(2):
-            try:
-                r = s.get(url, headers=headers, timeout=20)
-                if r.status_code == 429:
-                    retry_after = r.headers.get("Retry-After")
-                    if retry_after and retry_after.isdigit():
-                        sleep_sec = int(retry_after)
-                    else:
-                        sleep_sec = BASE_BACKOFF_SEC * (2 ** attempt) + random.random() * BACKOFF_JITTER_SEC
-                    logger.warning("预热命中 429，退避 %.2fs 后再试（第 %d 次）", sleep_sec, attempt + 1)
-                    time.sleep(sleep_sec)
-                    continue
-                r.raise_for_status()
-                logger.info("会话预热成功。")
-                return
-            except Exception as e:
-                logger.warning("会话预热失败（第 %d 次）：%s", attempt + 1, e)
-        # 不抛异常
-
-    # ----------------------------------------------------------------------
-    # HTTP POST（自动重试/退避/重建）
-    # ----------------------------------------------------------------------
-    def _post_with_retry(
-        self,
-        url: str,
-        *,
-        headers: Dict[str, str],
-        payload: Dict[str, Any],
-        stream: bool = False,
-        max_retries: int = HTTP_MAX_RETRIES,
-    ) -> requests.Response:
-        for attempt in range(max_retries):
-            try:
-                s = self._get_scraper()
-                resp = s.post(url, headers=headers, json=payload, stream=stream, timeout=API_REQUEST_TIMEOUT)
-
-                if resp.status_code in RETRYABLE_STATUS:
-                    # 429：遵循 Retry-After 或指数退避
-                    if resp.status_code == 429:
-                        retry_after = resp.headers.get("Retry-After")
-                        if retry_after and retry_after.isdigit():
-                            sleep_sec = int(retry_after)
-                        else:
-                            sleep_sec = BASE_BACKOFF_SEC * (2 ** attempt) + random.random() * BACKOFF_JITTER_SEC
-                        logger.warning("POST %s 命中 429，退避 %.2fs 后重试（第 %d/%d 次）",
-                                       url, sleep_sec, attempt + 1, max_retries)
-                        time.sleep(sleep_sec)
-                        continue
-
-                    # 401/403：重建会话 + 预热
-                    if resp.status_code in (401, 403):
-                        logger.warning("POST %s 返回 %s，重建会话并预热（第 %d/%d 次）",
-                                       url, resp.status_code, attempt + 1, max_retries)
-                        self._refresh_scraper(f"HTTP {resp.status_code}")
-                        self._warmup_session()
-                        continue
-
-                    # 5xx：指数退避
-                    if resp.status_code in (502, 503, 504):
-                        sleep_sec = BASE_BACKOFF_SEC * (2 ** attempt) + random.random() * BACKOFF_JITTER_SEC
-                        logger.warning("POST %s 返回 %s，退避 %.2fs 后重试（第 %d/%d 次）",
-                                       url, resp.status_code, sleep_sec, attempt + 1, max_retries)
-                        time.sleep(sleep_sec)
-                        continue
-
-                resp.raise_for_status()
-                return resp
-
-            except requests.RequestException as e:
-                sleep_sec = BASE_BACKOFF_SEC * (2 ** attempt) + random.random() * BACKOFF_JITTER_SEC
-                logger.warning("POST %s 网络异常：%s，退避 %.2fs 后重试（第 %d/%d 次）",
-                               url, e, sleep_sec, attempt + 1, max_retries)
-                self._refresh_scraper("网络异常后重建")
-                time.sleep(sleep_sec)
-
-        raise HTTPException(status_code=502, detail=f"调用 {url} 多次重试仍失败。")
-
-    def _open_stream_with_retry(self, url: str, headers: Dict[str, str], payload: Dict[str, Any]):
-        resp = self._post_with_retry(url, headers=headers, payload=payload, stream=True)
-        return resp.iter_lines()
-
-    # ----------------------------------------------------------------------
-    # 动态创建线程（不依赖固定会话 ID）
-    # ----------------------------------------------------------------------
+            logger.info("正在进行会话预热 (Session Warm-up)...")
+            headers = self._prepare_headers()
+            headers.pop("Accept", None)
+            response = self.scraper.get("https://www.notion.so/", headers=headers, timeout=30)
+            response.raise_for_status()
+            logger.info("会话预热成功。")
+        except Exception as e:
+            logger.error(f"会话预热失败: {e}", exc_info=True)
+            
     async def _create_thread(self, thread_type: str) -> str:
         thread_id = str(uuid.uuid4())
         payload = {
@@ -209,161 +64,156 @@ class NotionAIProvider(BaseProvider):
                 }]
             }]
         }
-        headers = self._prepare_headers()
-
-        # 先尝试 Fanout，不行再回退至 saveTransactions
-        for ep_key in ("saveTransactionsFanout", "saveTransactions"):
-            url = self.api_endpoints[ep_key]
-            try:
-                logger.info("创建线程：尝试 %s", ep_key)
-                await run_in_threadpool(lambda: self._post_with_retry(url, headers=headers, payload=payload))
-                logger.info("对话线程创建成功, Thread ID: %s", thread_id)
-                return thread_id
-            except HTTPException as he:
-                status = getattr(he, "status_code", None)
-                if status in (404, 405) and ep_key == "saveTransactionsFanout":
-                    logger.warning("Fanout 接口不可用，回退到 saveTransactions。")
-                    continue
-                raise
-            except Exception as e:
-                if ep_key == "saveTransactionsFanout":
-                    logger.warning("Fanout 创建线程失败（%s），尝试旧接口。", e)
-                    continue
-                logger.error("创建线程失败：%s", e, exc_info=True)
-                raise HTTPException(status_code=502, detail="无法创建新的对话线程。")
-
-        raise HTTPException(status_code=502, detail="创建线程失败：所有接口均不可用。")
+        try:
+            logger.info(f"正在创建新的对话线程 (type: {thread_type})...")
+            response = await run_in_threadpool(
+                lambda: self.scraper.post(
+                    self.api_endpoints["saveTransactions"],
+                    headers=self._prepare_headers(),
+                    json=payload,
+                    timeout=20
+                )
+            )
+            response.raise_for_status()
+            logger.info(f"对话线程创建成功, Thread ID: {thread_id}")
+            return thread_id
+        except Exception as e:
+            logger.error(f"创建对话线程失败: {e}", exc_info=True)
+            raise Exception("无法创建新的对话线程。")
 
-    # ----------------------------------------------------------------------
-    # Chat Completions（流式 + 自动重试）
-    # ----------------------------------------------------------------------
     async def chat_completion(self, request_data: Dict[str, Any]):
         stream = request_data.get("stream", True)
-        if not stream:
-            raise HTTPException(status_code=400, detail="此端点当前仅支持流式响应 (stream=true)。")
 
         async def stream_generator() -> AsyncGenerator[bytes, None]:
             request_id = f"chatcmpl-{uuid.uuid4()}"
-            model_name = request_data.get("model", settings.DEFAULT_MODEL)
-
-            # 先下发一次 role，避免重试带来重复角色片段
-            role_chunk = create_chat_completion_chunk(request_id, model_name, role="assistant")
-            yield create_sse_data(role_chunk)
-
-            last_error: Optional[Exception] = None
-
-            # 整体最多重试 2 轮（每轮都将重建线程/刷新会话）
-            for outer_try in range(2):
-                try:
-                    mapped_model = settings.MODEL_MAP.get(model_name, "anthropic-sonnet-alt")
-                    thread_type = "markdown-chat" if mapped_model.startswith("vertex-") else "workflow"
-
-                    # 每轮都新建线程，避免上下文串扰
-                    thread_id = await self._create_thread(thread_type)
-                    payload = self._prepare_payload(request_data, thread_id, mapped_model, thread_type)
-                    headers = self._prepare_headers()
-
-                    logger.info("请求 Notion AI（第 %d 轮）：%s", outer_try + 1, self.api_endpoints["runInference"])
-                    logger.info("请求体：%s", json.dumps(payload, ensure_ascii=False, indent=2))
-
-                    lines_iter = await run_in_threadpool(
-                        lambda: self._open_stream_with_retry(self.api_endpoints["runInference"], headers, payload)
-                    )
-
-                    incremental_fragments: List[str] = []
-                    final_message: Optional[str] = None
-
-                    while True:
-                        line = await run_in_threadpool(lambda: next(lines_iter, None))
-                        if line is None:
-                            break
-
-                        parsed_results = self._parse_ndjson_line_to_texts(line)
-                        for text_type, content in parsed_results:
-                            if text_type == 'final':
-                                final_message = content
-                            elif text_type == 'incremental':
-                                incremental_fragments.append(content)
-
-                    full_response = final_message if final_message else "".join(incremental_fragments)
-
-                    if full_response:
-                        cleaned_response = self._clean_content(full_response)
-                        logger.info("清洗后的最终响应: %s", cleaned_response)
-                        chunk = create_chat_completion_chunk(request_id, model_name, content=cleaned_response)
-                        yield create_sse_data(chunk)
-
-                        final_chunk = create_chat_completion_chunk(request_id, model_name, finish_reason="stop")
-                        yield create_sse_data(final_chunk)
-                        yield DONE_CHUNK
-                        return
-
-                    # 内容为空：重建会话并再预热，进入下一轮
-                    logger.warning("警告（第 %d 轮）：流数据为空，尝试重建会话/再预热后重试。", outer_try + 1)
-                    last_error = Exception("空响应")
-                    self._refresh_scraper("空响应后重建")
-                    await run_in_threadpool(self._warmup_session)
-                    continue
-
-                except Exception as e:
-                    last_error = e
-                    logger.error("处理 Notion AI 流时发生错误（第 %d 轮）：%s", outer_try + 1, e, exc_info=True)
-                    if outer_try == 0:
-                        self._refresh_scraper("处理异常后重建")
-                        await run_in_threadpool(self._warmup_session)
-                        continue
-                    break
-
-            # 重试用尽
-            error_message = f"处理 Notion AI 流失败（自动重试已用尽）：{str(last_error)}"
-            logger.error(error_message)
-            error_chunk = {"error": {"message": error_message, "type": "internal_server_error"}}
-            yield create_sse_data(error_chunk)
-            yield DONE_CHUNK
-
-        return StreamingResponse(stream_generator(), media_type="text/event-stream")
-
-    # ----------------------------------------------------------------------
-    # Header & Payload
-    # ----------------------------------------------------------------------
+            incremental_fragments: List[str] = []
+            final_message: Optional[str] = None
+            
+            try:
+                model_name = request_data.get("model", settings.DEFAULT_MODEL)
+                mapped_model = settings.MODEL_MAP.get(model_name, "anthropic-sonnet-alt")
+                
+                thread_type = "markdown-chat" if mapped_model.startswith("vertex-") else "workflow"
+                
+                thread_id = await self._create_thread(thread_type)
+                payload = self._prepare_payload(request_data, thread_id, mapped_model, thread_type)
+                headers = self._prepare_headers()
+
+                role_chunk = create_chat_completion_chunk(request_id, model_name, role="assistant")
+                yield create_sse_data(role_chunk)
+
+                def sync_stream_iterator():
+                    try:
+                        logger.info(f"请求 Notion AI URL: {self.api_endpoints['runInference']}")
+                        logger.info(f"请求体: {json.dumps(payload, indent=2, ensure_ascii=False)}")
+                        
+                        response = self.scraper.post(
+                            self.api_endpoints['runInference'], headers=headers, json=payload, stream=True,
+                            timeout=settings.API_REQUEST_TIMEOUT
+                        )
+                        response.raise_for_status()
+                        for line in response.iter_lines():
+                            if line:
+                                yield line
+                    except Exception as e:
+                        yield e
+
+                sync_gen = sync_stream_iterator()
+              
+                while True:
+                    line = await run_in_threadpool(lambda: next(sync_gen, None))
+                    if line is None:
+                        break
+                    if isinstance(line, Exception):
+                        raise line
+
+                    parsed_results = self._parse_ndjson_line_to_texts(line)
+                    for text_type, content in parsed_results:
+                        if text_type == 'final':
+                            final_message = content
+                        elif text_type == 'incremental':
+                            incremental_fragments.append(content)
+              
+                full_response = ""
+                if final_message:
+                    full_response = final_message
+                    logger.info(f"成功从 record-map 或 Gemini patch/event 中提取到最终消息。")
+                else:
+                    full_response = "".join(incremental_fragments)
+                    logger.info(f"使用拼接所有增量片段的方式获得最终消息。")
+
+                if full_response:
+                    cleaned_response = self._clean_content(full_response)
+                    logger.info(f"清洗后的最终响应: {cleaned_response}")
+                    chunk = create_chat_completion_chunk(request_id, model_name, content=cleaned_response)
+                    yield create_sse_data(chunk)
+                else:
+                    logger.warning("警告: Notion 返回的数据流中未提取到任何有效文本。请检查您的 .env 配置是否全部正确且凭证有效。")
+
+                final_chunk = create_chat_completion_chunk(request_id, model_name, finish_reason="stop")
+                yield create_sse_data(final_chunk)
+                yield DONE_CHUNK
+
+            except Exception as e:
+                error_message = f"���理 Notion AI 流时发生意外错误: {str(e)}"
+                logger.error(error_message, exc_info=True)
+                error_chunk = {"error": {"message": error_message, "type": "internal_server_error"}}
+                yield create_sse_data(error_chunk)
+                yield DONE_CHUNK
+
+        if stream:
+            return StreamingResponse(stream_generator(), media_type="text/event-stream")
+        else:
+            raise HTTPException(status_code=400, detail="此端点当前仅支持流式响应 (stream=true)。")
+
+    def _prepare_headers(self) -> Dict[str, str]:
+        cookie_source = (settings.NOTION_COOKIE or "").strip()
+        cookie_header = cookie_source if "=" in cookie_source else f"token_v2={cookie_source}"
+
+        return {
+            "Content-Type": "application/json",
+            "Accept": "application/x-ndjson",
+            "Cookie": cookie_header,
+            "x-notion-space-id": settings.NOTION_SPACE_ID,
+            "x-notion-active-user-header": settings.NOTION_USER_ID,
+            "x-notion-client-version": settings.NOTION_CLIENT_VERSION,
+            "notion-audit-log-platform": "web",
+            "Origin": "https://www.notion.so",
+            "Referer": "https://www.notion.so/",
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36",
+        }
+
     def _normalize_block_id(self, block_id: str) -> str:
-        if not block_id:
-            return block_id
+        if not block_id: return block_id
         b = block_id.replace("-", "").strip()
         if len(b) == 32 and re.fullmatch(r"[0-9a-fA-F]{32}", b):
             return f"{b[0:8]}-{b[8:12]}-{b[12:16]}-{b[16:20]}-{b[20:]}"
         return block_id
 
     def _prepare_payload(self, request_data: Dict[str, Any], thread_id: str, mapped_model: str, thread_type: str) -> Dict[str, Any]:
-        req_block_id = request_data.get("notion_block_id") or getattr(settings, "NOTION_BLOCK_ID", None)
+        req_block_id = request_data.get("notion_block_id") or settings.NOTION_BLOCK_ID
         normalized_block_id = self._normalize_block_id(req_block_id) if req_block_id else None
 
         context_value: Dict[str, Any] = {
             "timezone": "Asia/Shanghai",
             "spaceId": settings.NOTION_SPACE_ID,
             "userId": settings.NOTION_USER_ID,
-            "userEmail": getattr(settings, "NOTION_USER_EMAIL", None),
+            "userEmail": settings.NOTION_USER_EMAIL,
             "currentDatetime": datetime.now().astimezone().isoformat(),
         }
         if normalized_block_id:
             context_value["blockId"] = normalized_block_id
 
-        # Vertex / Gemini 的特殊上下文与配置（不再硬编码 spaceViewId，可从环境变量传入）
+        config_value: Dict[str, Any]
+        
         if mapped_model.startswith("vertex-"):
-            logger.info(f"检测到 Gemini 模型 ({mapped_model})，应用特定的 config/context。")
-            gemini_context = {
-                "userName": f"{getattr(settings, 'NOTION_USER_NAME', '')}",
-                "spaceName": f"{getattr(settings, 'NOTION_USER_NAME', '')}的 Notion",
+            logger.info(f"检测到 Gemini 模型 ({mapped_model})，应用特定的 config 和 context。")
+            context_value.update({
+                "userName": f" {settings.NOTION_USER_NAME}",
+                "spaceName": f"{settings.NOTION_USER_NAME}的 Notion",
+                "spaceViewId": "29d2ea19-5923-80f2-9f44-00a9fed7bffe",
                 "surface": "ai_module"
-            }
-            space_view_id = getattr(settings, "NOTION_SPACE_VIEW_ID", None)
-            if space_view_id:
-                gemini_context["spaceViewId"] = space_view_id
-                logger.info(f"使用配置中的 spaceViewId: {space_view_id}")
-            else:
-                logger.warning("未配置 NOTION_SPACE_VIEW_ID，Gemini 模型可能无法正常工作。")
-            context_value.update(gemini_context)
-
+            })
             config_value = {
                 "type": thread_type,
                 "model": mapped_model,
@@ -379,7 +229,7 @@ class NotionAIProvider(BaseProvider):
             }
         else:
             context_value.update({
-                "userName": getattr(settings, "NOTION_USER_NAME", None),
+                "userName": settings.NOTION_USER_NAME,
                 "surface": "workflows"
             })
             config_value = {
@@ -392,7 +242,7 @@ class NotionAIProvider(BaseProvider):
             {"id": str(uuid.uuid4()), "type": "config", "value": config_value},
             {"id": str(uuid.uuid4()), "type": "context", "value": context_value}
         ]
-
+      
         for msg in request_data.get("messages", []):
             if msg.get("role") == "user":
                 transcript.append({
@@ -403,11 +253,7 @@ class NotionAIProvider(BaseProvider):
                     "createdAt": datetime.now().astimezone().isoformat()
                 })
             elif msg.get("role") == "assistant":
-                transcript.append({
-                    "id": str(uuid.uuid4()),
-                    "type": "agent-inference",
-                    "value": [{"type": "text", "content": msg.get("content")}]
-                })
+                transcript.append({"id": str(uuid.uuid4()), "type": "agent-inference", "value": [{"type": "text", "content": msg.get("content")}]})
 
         payload = {
             "traceId": str(uuid.uuid4()),
@@ -430,20 +276,17 @@ class NotionAIProvider(BaseProvider):
                 "annotationInferences": {},
                 "emitInferences": False
             }
-
+        
         return payload
 
-    # ----------------------------------------------------------------------
-    # 内容清洗（保持你的逻辑）
-    # ----------------------------------------------------------------------
     def _clean_content(self, content: str) -> str:
         if not content:
             return ""
-
+            
         content = re.sub(r'<lang primary="[^"]*"\s*/>\n*', '', content)
         content = re.sub(r'<thinking>[\s\S]*?</thinking>\s*', '', content, flags=re.IGNORECASE)
         content = re.sub(r'<thought>[\s\S]*?</thought>\s*', '', content, flags=re.IGNORECASE)
-
+        
         content = re.sub(r'^.*?Chinese whatmodel I am.*?Theyspecifically.*?requested.*?me.*?to.*?reply.*?in.*?Chinese\.\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
         content = re.sub(r'^.*?This.*?is.*?a.*?straightforward.*?question.*?about.*?my.*?identity.*?asan.*?AI.*?assistant\.\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
         content = re.sub(r'^.*?Idon\'t.*?need.*?to.*?use.*?any.*?tools.*?for.*?this.*?-\s*it\'s.*?asimple.*?informational.*?response.*?aboutwhat.*?I.*?am\.\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
@@ -452,22 +295,18 @@ class NotionAIProvider(BaseProvider):
         content = re.sub(r'^.*?This.*?is.*?a.*?question.*?about.*?my.*?identity.*?not requiring.*?any.*?tool.*?use.*?I.*?should.*?respond.*?directly.*?to.*?the.*?user.*?in.*?Chinese.*?as.*?requested\.\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
         content = re.sub(r'^.*?I.*?should.*?identify.*?myself.*?as.*?Notion.*?AI.*?as.*?mentioned.*?in.*?the.*?system.*?prompt.*?\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
         content = re.sub(r'^.*?I.*?should.*?not.*?make.*?specific.*?claims.*?about.*?the.*?underlying.*?model.*?architecture.*?since.*?that.*?information.*?is.*?not.*?provided.*?in.*?my.*?context\.\s*', '', content, flags=re.IGNORECASE | re.DOTALL)
-
+        
         return content.strip()
 
-    # ----------------------------------------------------------------------
-    # NDJSON 解析（保持并扩展）
-    # ----------------------------------------------------------------------
     def _parse_ndjson_line_to_texts(self, line: bytes) -> List[Tuple[str, str]]:
         results: List[Tuple[str, str]] = []
         try:
             s = line.decode("utf-8", errors="ignore").strip()
-            if not s:
-                return results
-
+            if not s: return results
+            
             data = json.loads(s)
             logger.debug(f"原始响应数据: {json.dumps(data, ensure_ascii=False)}")
-
+            
             # 格式1: Gemini 返回的 markdown-chat 事件
             if data.get("type") == "markdown-chat":
                 content = data.get("value", "")
@@ -475,52 +314,51 @@ class NotionAIProvider(BaseProvider):
                     logger.info("从 'markdown-chat' 直接事件中提取到内容。")
                     results.append(('final', content))
 
-            # 格式2: Claude/GPT/Gemini 的 patch
+            # 格式2: Claude 和 GPT 返回的补丁流，以及 Gemini 的 patch 格式
             elif data.get("type") == "patch" and "v" in data:
                 for operation in data.get("v", []):
-                    if not isinstance(operation, dict):
-                        continue
+                    if not isinstance(operation, dict): continue
+                    
                     op_type = operation.get("o")
                     path = operation.get("p", "")
                     value = operation.get("v")
-
-                    # Gemini 完整
+                    
+                    # 【修改】Gemini 的完整内容 patch 格式
                     if op_type == "a" and path.endswith("/s/-") and isinstance(value, dict) and value.get("type") == "markdown-chat":
                         content = value.get("value", "")
                         if content:
                             logger.info("从 'patch' (Gemini-style) 中提取到完整内容。")
                             results.append(('final', content))
-
-                    # Gemini 增量
+                    
+                    # 【修改】Gemini 的增量内容 patch 格式
                     elif op_type == "x" and "/s/" in path and path.endswith("/value") and isinstance(value, str):
                         content = value
                         if content:
                             logger.info(f"从 'patch' (Gemini增量) 中提取到内容: {content}")
                             results.append(('incremental', content))
-
-                    # Claude / GPT 增量
+                    
+                    # 【修改】Claude 和 GPT 的增量内容 patch 格式
                     elif op_type == "x" and "/value/" in path and isinstance(value, str):
                         content = value
                         if content:
                             logger.info(f"从 'patch' (Claude/GPT增量) 中提取到内容: {content}")
                             results.append(('incremental', content))
-
-                    # Claude / GPT 完整
+                    
+                    # 【修改】Claude 和 GPT 的完整内容 patch 格式
                     elif op_type == "a" and path.endswith("/value/-") and isinstance(value, dict) and value.get("type") == "text":
                         content = value.get("content", "")
                         if content:
                             logger.info("从 'patch' (Claude/GPT-style) 中提取到完整内容。")
                             results.append(('final', content))
 
-            # 格式3: record-map
+            # 格式3: 处理record-map类型的数据
             elif data.get("type") == "record-map" and "recordMap" in data:
                 record_map = data["recordMap"]
                 if "thread_message" in record_map:
-                    for _, msg_data in record_map["thread_message"].items():
+                    for msg_id, msg_data in record_map["thread_message"].items():
                         value_data = msg_data.get("value", {}).get("value", {})
                         step = value_data.get("step", {})
-                        if not step:
-                            continue
+                        if not step: continue
 
                         content = ""
                         step_type = step.get("type")
@@ -534,20 +372,17 @@ class NotionAIProvider(BaseProvider):
                                     if isinstance(item, dict) and item.get("type") == "text":
                                         content = item.get("content", "")
                                         break
-
+                        
                         if content and isinstance(content, str):
                             logger.info(f"从 record-map (type: {step_type}) 提取到最终内容。")
                             results.append(('final', content))
-                            break
-
+                            break 
+    
         except (json.JSONDecodeError, AttributeError) as e:
             logger.warning(f"解析NDJSON行失败: {e} - Line: {line.decode('utf-8', errors='ignore')}")
-
+        
         return results
 
-    # ----------------------------------------------------------------------
-    # 模型列表
-    # ----------------------------------------------------------------------
     async def get_models(self) -> JSONResponse:
         model_data = {
             "object": "list",
@@ -559,3 +394,4 @@ class NotionAIProvider(BaseProvider):
         return JSONResponse(content=model_data)
 
 
+