Merge remote-tracking branch 'upstream/debug' into debug

src/plugins/models/utils_model.py

@@ -55,7 +55,7 @@ class LLM_request:
                             logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
                             await asyncio.sleep(wait_time)
                             continue
-                            
+
                         if response.status in [500, 503]:
                             logger.error(f"服务器错误: {response.status}")
                             raise RuntimeError("服务器负载过高，模型恢复失败QAQ")
@@ -69,10 +69,10 @@ class LLM_request:
                             think_match = None
                             reasoning_content = message.get("reasoning_content", "")
                             if not reasoning_content:
-                                think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
+                                think_match = re.search(r'(?:<think>)?(.*?)</think>', content, re.DOTALL)
                             if think_match:
                                 reasoning_content = think_match.group(1).strip()
-                            content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
+                            content = re.sub(r'(?:<think>)?.*?</think>', '', content, flags=re.DOTALL, count=1).strip()
                             return content, reasoning_content
                         return "没有返回结果", ""
 
@@ -119,7 +119,7 @@ class LLM_request:
                 ],
                 **self.params
             }
-        
+
 
         # 发送请求到完整的chat/completions端点
         api_url = f"{self.base_url.rstrip('/')}/chat/completions"
@@ -127,10 +127,9 @@ class LLM_request:
 
         max_retries = 3
         base_wait_time = 15
-        
+
         current_image_base64 = image_base64
         current_image_base64 = compress_base64_image_by_scale(current_image_base64)
-        
 
         for retry in range(max_retries):
             try:
@@ -147,7 +146,7 @@ class LLM_request:
                             logger.warning("图片太大(413)，尝试压缩...")
                             current_image_base64 = compress_base64_image_by_scale(current_image_base64)
                             continue
-                            
+
                         response.raise_for_status()  # 检查其他响应状态
 
                         result = await response.json()
@@ -157,10 +156,10 @@ class LLM_request:
                             think_match = None
                             reasoning_content = message.get("reasoning_content", "")
                             if not reasoning_content:
-                                think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
+                                think_match = re.search(r'(?:<think>)?(.*?)</think>', content, re.DOTALL)
                             if think_match:
                                 reasoning_content = think_match.group(1).strip()
-                            content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
+                            content = re.sub(r'(?:<think>)?.*?</think>', '', content, flags=re.DOTALL, count=1).strip()
                             return content, reasoning_content
                         return "没有返回结果", ""
 
@@ -183,7 +182,7 @@ class LLM_request:
             "Authorization": f"Bearer {self.api_key}",
             "Content-Type": "application/json"
         }
-        
+
         # 构建请求体
         data = {
             "model": self.model_name,
@@ -191,14 +190,14 @@ class LLM_request:
             "temperature": 0.5,
             **self.params
         }
-        
+
         # 发送请求到完整的 chat/completions 端点
         api_url = f"{self.base_url.rstrip('/')}/chat/completions"
         logger.info(f"Request URL: {api_url}")  # 记录请求的 URL
-        
+
         max_retries = 3
         base_wait_time = 15
-        
+
         async with aiohttp.ClientSession() as session:
             for retry in range(max_retries):
                 try:
@@ -208,16 +207,23 @@ class LLM_request:
                             logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
                             await asyncio.sleep(wait_time)
                             continue
-                            
+
                         response.raise_for_status()  # 检查其他响应状态
-                        
+
                         result = await response.json()
                         if "choices" in result and len(result["choices"]) > 0:
-                            content = result["choices"][0]["message"]["content"]
-                            reasoning_content = result["choices"][0]["message"].get("reasoning_content", "")
+                            message = result["choices"][0]["message"]
+                            content = message.get("content", "")
+                            think_match = None
+                            reasoning_content = message.get("reasoning_content", "")
+                            if not reasoning_content:
+                                think_match = re.search(r'(?:<think>)?(.*?)</think>', content, re.DOTALL)
+                            if think_match:
+                                reasoning_content = think_match.group(1).strip()
+                            content = re.sub(r'(?:<think>)?.*?</think>', '', content, flags=re.DOTALL, count=1).strip()
                             return content, reasoning_content
                         return "没有返回结果", ""
-                        
+
                 except Exception as e:
                     if retry < max_retries - 1:  # 如果还有重试机会
                         wait_time = base_wait_time * (2 ** retry)
@@ -227,7 +233,7 @@ class LLM_request:
                         logger.error(f"请求失败: {str(e)}")
                         logger.critical(f"请求头: {headers} 请求体: {data}")
                         return f"请求失败: {str(e)}", ""
-            
+
             logger.error("达到最大重试次数，请求仍然失败")
             return "达到最大重试次数，请求仍然失败", ""
 
@@ -291,10 +297,10 @@ class LLM_request:
                     think_match = None
                     reasoning_content = message.get("reasoning_content", "")
                     if not reasoning_content:
-                        think_match = re.search(r'<think>(.*?)</think>', content, re.DOTALL)
+                        think_match = re.search(r'(?:<think>)?(.*?)</think>', content, re.DOTALL)
                     if think_match:
                         reasoning_content = think_match.group(1).strip()
-                    content = re.sub(r'<think>.*?</think>', '', content, flags=re.DOTALL).strip()
+                    content = re.sub(r'(?:<think>)?.*?</think>', '', content, flags=re.DOTALL, count=1).strip()
                     return content, reasoning_content
                 return "没有返回结果", ""
 
@@ -424,3 +430,199 @@ class LLM_request:
 
         logger.error("达到最大重试次数，embedding请求仍然失败")
         return None
+
+    def rerank_sync(self, query: str, documents: list, top_k: int = 5) -> list:
+        """同步方法：使用重排序API对文档进行排序
+        
+        Args:
+            query: 查询文本
+            documents: 待排序的文档列表
+            top_k: 返回前k个结果
+            
+        Returns:
+            list: [(document, score), ...] 格式的结果列表
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "model": self.model_name,
+            "query": query,
+            "documents": documents,
+            "top_n": top_k,
+            "return_documents": True,
+        }
+
+        api_url = f"{self.base_url.rstrip('/')}/rerank"
+        logger.info(f"发送请求到URL: {api_url}")
+
+        max_retries = 2
+        base_wait_time = 6
+
+        for retry in range(max_retries):
+            try:
+                response = requests.post(api_url, headers=headers, json=data, timeout=30)
+
+                if response.status_code == 429:
+                    wait_time = base_wait_time * (2 ** retry)
+                    logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
+                    time.sleep(wait_time)
+                    continue
+                
+                if response.status_code in [500, 503]:
+                    wait_time = base_wait_time * (2 ** retry)
+                    logger.error(f"服务器错误({response.status_code})，等待{wait_time}秒后重试...")
+                    if retry < max_retries - 1:
+                        time.sleep(wait_time)
+                        continue
+                    else:
+                        # 如果是最后一次重试，尝试使用chat/completions作为备选方案
+                        return self._fallback_rerank_with_chat(query, documents, top_k)
+
+                response.raise_for_status()
+
+                result = response.json()
+                if 'results' in result:
+                    return [(item["document"], item["score"]) for item in result["results"]]
+                return []
+
+            except Exception as e:
+                if retry < max_retries - 1:
+                    wait_time = base_wait_time * (2 ** retry)
+                    logger.error(f"[rerank_sync]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}", exc_info=True)
+                    time.sleep(wait_time)
+                else:
+                    logger.critical(f"重排序请求失败: {str(e)}", exc_info=True)
+
+        logger.error("达到最大重试次数，重排序请求仍然失败")
+        return []
+
+    async def rerank(self, query: str, documents: list, top_k: int = 5) -> list:
+        """异步方法：使用重排序API对文档进行排序
+        
+        Args:
+            query: 查询文本
+            documents: 待排序的文档列表
+            top_k: 返回前k个结果
+            
+        Returns:
+            list: [(document, score), ...] 格式的结果列表
+        """
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        data = {
+            "model": self.model_name,
+            "query": query,
+            "documents": documents,
+            "top_n": top_k,
+            "return_documents": True,
+        }
+
+        api_url = f"{self.base_url.rstrip('/')}/v1/rerank"
+        logger.info(f"发送请求到URL: {api_url}")
+
+        max_retries = 3
+        base_wait_time = 15
+
+        for retry in range(max_retries):
+            try:
+                async with aiohttp.ClientSession() as session:
+                    async with session.post(api_url, headers=headers, json=data) as response:
+                        if response.status == 429:
+                            wait_time = base_wait_time * (2 ** retry)
+                            logger.warning(f"遇到请求限制(429)，等待{wait_time}秒后重试...")
+                            await asyncio.sleep(wait_time)
+                            continue
+
+                        if response.status in [500, 503]:
+                            wait_time = base_wait_time * (2 ** retry)
+                            logger.error(f"服务器错误({response.status})，等待{wait_time}秒后重试...")
+                            if retry < max_retries - 1:
+                                await asyncio.sleep(wait_time)
+                                continue
+                            else:
+                                # 如果是最后一次重试，尝试使用chat/completions作为备选方案
+                                return await self._fallback_rerank_with_chat_async(query, documents, top_k)
+
+                        response.raise_for_status()
+
+                        result = await response.json()
+                        if 'results' in result:
+                            return [(item["document"], item["score"]) for item in result["results"]]
+                        return []
+
+            except Exception as e:
+                if retry < max_retries - 1:
+                    wait_time = base_wait_time * (2 ** retry)
+                    logger.error(f"[rerank]请求失败，等待{wait_time}秒后重试... 错误: {str(e)}", exc_info=True)
+                    await asyncio.sleep(wait_time)
+                else:
+                    logger.critical(f"重排序请求失败: {str(e)}", exc_info=True)
+                    # 作为最后的备选方案，尝试使用chat/completions
+                    return await self._fallback_rerank_with_chat_async(query, documents, top_k)
+
+        logger.error("达到最大重试次数，重排序请求仍然失败")
+        return []
+
+    async def _fallback_rerank_with_chat_async(self, query: str, documents: list, top_k: int = 5) -> list:
+        """当rerank API失败时的备选方案，使用chat/completions异步实现重排序
+        
+        Args:
+            query: 查询文本
+            documents: 待排序的文档列表
+            top_k: 返回前k个结果
+            
+        Returns:
+            list: [(document, score), ...] 格式的结果列表
+        """
+        try:
+            logger.info("使用chat/completions作为重排序的备选方案")
+            
+            # 构建提示词
+            prompt = f"""请对以下文档列表进行重排序，按照与查询的相关性从高到低排序。
+查询: {query}
+
+文档列表:
+{documents}
+
+请以JSON格式返回排序结果，格式为：
+[{{"document": "文档内容", "score": 相关性分数}}, ...]
+只返回JSON，不要其他任何文字。"""
+
+            headers = {
+                "Authorization": f"Bearer {self.api_key}",
+                "Content-Type": "application/json"
+            }
+
+            data = {
+                "model": self.model_name,
+                "messages": [{"role": "user", "content": prompt}],
+                **self.params
+            }
+
+            api_url = f"{self.base_url.rstrip('/')}/v1/chat/completions"
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(api_url, headers=headers, json=data) as response:
+                    response.raise_for_status()
+                    result = await response.json()
+                    
+                    if "choices" in result and len(result["choices"]) > 0:
+                        message = result["choices"][0]["message"]
+                        content = message.get("content", "")
+                        try:
+                            import json
+                            parsed_content = json.loads(content)
+                            if isinstance(parsed_content, list):
+                                return [(item["document"], item["score"]) for item in parsed_content]
+                        except:
+                            pass
+            return []
+        except Exception as e:
+            logger.error(f"备选方案也失败了: {str(e)}")
+            return []