perf: ruff format & remove stream params in requester

pkg/provider/entities.py

@@ -127,6 +127,7 @@ class Message(pydantic.BaseModel):
 
 class MessageChunk(pydantic.BaseModel):
     """消息"""
+
     resp_message_id: typing.Optional[str] = None
     """消息id"""
 
@@ -148,7 +149,7 @@ class MessageChunk(pydantic.BaseModel):
     tool_call_id: typing.Optional[str] = None
 
     # tool_calls: typing.Optional[list[ToolCallChunk]] = None
-    
+
     is_final: bool = False
 
     def readable_str(self) -> str:
@@ -210,6 +211,7 @@ class ToolCallChunk(pydantic.BaseModel):
     function: FunctionCall
     """函数调用"""
 
+
 class Prompt(pydantic.BaseModel):
     """供AI使用的Prompt"""
 

pkg/provider/modelmgr/requester.py

@@ -71,19 +71,18 @@ class LLMAPIRequester(metaclass=abc.ABCMeta):
             extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
 
         Returns:
-            llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk]: 返回消息对象
+            llm_entities.Message: 返回消息对象
         """
         pass
 
     @abc.abstractmethod
     async def invoke_llm_stream(
-            self,
-            query: core_entities.Query,
-            model: RuntimeLLMModel,
-            messages: typing.List[llm_entities.Message],
-            funcs: typing.List[tools_entities.LLMFunction] = None,
-            stream: bool = False,
-            extra_args: dict[str, typing.Any] = {},
+        self,
+        query: core_entities.Query,
+        model: RuntimeLLMModel,
+        messages: typing.List[llm_entities.Message],
+        funcs: typing.List[tools_entities.LLMFunction] = None,
+        extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.MessageChunk:
         """调用API
 
@@ -94,6 +93,6 @@ class LLMAPIRequester(metaclass=abc.ABCMeta):
             extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
 
         Returns:
-            llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk]: 返回消息对象
+            typing.AsyncGenerator[llm_entities.MessageChunk]: 返回消息对象
         """
         pass

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -8,7 +8,7 @@ import openai.types.chat.chat_completion as chat_completion
 import httpx
 
 from .. import errors, requester
-from ....core import entities as core_entities, app
+from ....core import entities as core_entities
 from ... import entities as llm_entities
 from ...tools import entities as tools_entities
 
@@ -129,12 +129,10 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         req_messages: list[dict],
         use_model: requester.RuntimeLLMModel,
         use_funcs: list[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
-    ) ->llm_entities.MessageChunk:
+    ) -> llm_entities.MessageChunk:
         self.client.api_key = use_model.token_mgr.get_token()
 
-
         args = {}
         args['model'] = use_model.model_entity.name
 
@@ -158,43 +156,42 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
 
         args['messages'] = messages
 
-        if stream:
-            current_content = ''
-            args['stream'] = True
-            chunk_idx = 0
-            self.is_content = False
-            tool_calls_map: dict[str, llm_entities.ToolCall] = {}
-            pipeline_config = query.pipeline_config
-            async for chunk in self._req_stream(args, extra_body=extra_args):
-                # 处理流式消息
-                delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
-                if delta_message.content:
-                    current_content += delta_message.content
-                    delta_message.content = current_content
-                    # delta_message.all_content = current_content
-                if delta_message.tool_calls:
-                    for tool_call in delta_message.tool_calls:
-                        if tool_call.id not in tool_calls_map:
-                            tool_calls_map[tool_call.id] = llm_entities.ToolCall(
-                                id=tool_call.id,
-                                type=tool_call.type,
-                                function=llm_entities.FunctionCall(
-                                    name=tool_call.function.name if tool_call.function else '', arguments=''
-                                ),
-                            )
-                        if tool_call.function and tool_call.function.arguments:
-                            # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
-                            tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
+        current_content = ''
+        args['stream'] = True
+        chunk_idx = 0
+        self.is_content = False
+        tool_calls_map: dict[str, llm_entities.ToolCall] = {}
+        pipeline_config = query.pipeline_config
+        async for chunk in self._req_stream(args, extra_body=extra_args):
+            # 处理流式消息
+            delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
+            if delta_message.content:
+                current_content += delta_message.content
+                delta_message.content = current_content
+                # delta_message.all_content = current_content
+            if delta_message.tool_calls:
+                for tool_call in delta_message.tool_calls:
+                    if tool_call.id not in tool_calls_map:
+                        tool_calls_map[tool_call.id] = llm_entities.ToolCall(
+                            id=tool_call.id,
+                            type=tool_call.type,
+                            function=llm_entities.FunctionCall(
+                                name=tool_call.function.name if tool_call.function else '', arguments=''
+                            ),
+                        )
+                    if tool_call.function and tool_call.function.arguments:
+                        # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
+                        tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
 
-                chunk_idx += 1
-                chunk_choices = getattr(chunk, 'choices', None)
-                if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
-                    delta_message.is_final = True
-                    delta_message.content = current_content
+            chunk_idx += 1
+            chunk_choices = getattr(chunk, 'choices', None)
+            if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
+                delta_message.is_final = True
+                delta_message.content = current_content
 
-                if chunk_idx % 64 == 0 or delta_message.is_final:
-                    yield delta_message
-                # return
+            if chunk_idx % 64 == 0 or delta_message.is_final:
+                yield delta_message
+            # return
 
     async def _closure(
         self,
@@ -202,7 +199,6 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         req_messages: list[dict],
         use_model: requester.RuntimeLLMModel,
         use_funcs: list[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
@@ -289,7 +285,6 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
         model: requester.RuntimeLLMModel,
         messages: typing.List[llm_entities.Message],
         funcs: typing.List[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.MessageChunk:
         req_messages = []  # req_messages 仅用于类内，外部同步由 query.messages 进行
@@ -309,7 +304,6 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
                 req_messages=req_messages,
                 use_model=model,
                 use_funcs=funcs,
-                stream=stream,
                 extra_args=extra_args,
             ):
                 yield item

pkg/provider/modelmgr/requesters/giteeaichatcmpl.py

@@ -12,7 +12,6 @@ import re
 import openai.types.chat.chat_completion as chat_completion
 
 
-
 class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
     """Gitee AI ChatCompletions API 请求器"""
 
@@ -20,7 +19,7 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
         'base_url': 'https://ai.gitee.com/v1',
         'timeout': 120,
     }
-    is_think:bool = False
+    is_think: bool = False
 
     async def _closure(
         self,
@@ -52,15 +51,14 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         pipeline_config = query.pipeline_config
 
-        message = await self._make_msg(resp,pipeline_config)
+        message = await self._make_msg(resp, pipeline_config)
 
         return message
 
-
     async def _make_msg(
-            self,
-            chat_completion: chat_completion.ChatCompletion,
-            pipeline_config: dict[str, typing.Any] = {'trigger': {'misc': {'remove_think': False}}},
+        self,
+        chat_completion: chat_completion.ChatCompletion,
+        pipeline_config: dict[str, typing.Any] = {'trigger': {'misc': {'remove_think': False}}},
     ) -> llm_entities.Message:
         chatcmpl_message = chat_completion.choices[0].message.model_dump()
         # print(chatcmpl_message.keys(), chatcmpl_message.values())
@@ -73,23 +71,25 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         # deepseek的reasoner模型
         if pipeline_config['trigger'].get('misc', '').get('remove_think'):
-            chatcmpl_message['content'] = re.sub(r'<think>.*?</think>', '', chatcmpl_message['content'], flags=re.DOTALL)
+            chatcmpl_message['content'] = re.sub(
+                r'<think>.*?</think>', '', chatcmpl_message['content'], flags=re.DOTALL
+            )
         else:
             if reasoning_content is not None:
-                chatcmpl_message['content'] = '<think>\n' + reasoning_content + '\n</think>\n' + chatcmpl_message['content']
+                chatcmpl_message['content'] = (
+                    '<think>\n' + reasoning_content + '\n</think>\n' + chatcmpl_message['content']
+                )
 
         message = llm_entities.Message(**chatcmpl_message)
 
         return message
 
-
     async def _make_msg_chunk(
         self,
         pipeline_config: dict[str, typing.Any],
         chat_completion: chat_completion.ChatCompletion,
         idx: int,
     ) -> llm_entities.MessageChunk:
-
         # 处理流式chunk和完整响应的差异
         # print(chat_completion.choices[0])
         if hasattr(chat_completion, 'choices'):
@@ -104,7 +104,6 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
         if 'role' not in delta or delta['role'] is None:
             delta['role'] = 'assistant'
 
-
         reasoning_content = delta['reasoning_content'] if 'reasoning_content' in delta else None
 
         delta['content'] = '' if delta['content'] is None else delta['content']
@@ -115,7 +114,7 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
             if delta['content'] == '<think>':
                 self.is_think = True
                 delta['content'] = ''
-            if delta['content'] == rf'</think>':
+            if delta['content'] == r'</think>':
                 self.is_think = False
                 delta['content'] = ''
             if not self.is_think:
@@ -126,7 +125,6 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
             if reasoning_content is not None:
                 delta['content'] += reasoning_content
 
-
         message = llm_entities.MessageChunk(**delta)
 
         return message
@@ -137,7 +135,6 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
         req_messages: list[dict],
         use_model: requester.RuntimeLLMModel,
         use_funcs: list[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
         self.client.api_key = use_model.token_mgr.get_token()
@@ -165,44 +162,38 @@ class GiteeAIChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         args['messages'] = messages
 
-        if stream:
-            current_content = ''
-            args["stream"] = True
-            chunk_idx = 0
-            self.is_content = False
-            tool_calls_map: dict[str, llm_entities.ToolCall] = {}
-            pipeline_config = query.pipeline_config
-            async for chunk in self._req_stream(args, extra_body=extra_args):
-                # 处理流式消息
-                delta_message = await self._make_msg_chunk(pipeline_config,chunk,chunk_idx)
-                if delta_message.content:
-                    current_content += delta_message.content
-                    delta_message.content = current_content
-                    # delta_message.all_content = current_content
-                if delta_message.tool_calls:
-                    for tool_call in delta_message.tool_calls:
-                        if tool_call.id not in tool_calls_map:
-                            tool_calls_map[tool_call.id] = llm_entities.ToolCall(
-                                id=tool_call.id,
-                                type=tool_call.type,
-                                function=llm_entities.FunctionCall(
-                                    name=tool_call.function.name if tool_call.function else '',
-                                    arguments=''
-                                ),
-                            )
-                        if tool_call.function and tool_call.function.arguments:
-                            # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
-                            tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
-
-
-                chunk_idx += 1
-                chunk_choices = getattr(chunk, 'choices', None)
-                if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
-                    delta_message.is_final = True
-                    delta_message.content = current_content
-
-                if chunk_idx % 64 == 0 or delta_message.is_final:
-
-                    yield delta_message
+        current_content = ''
+        args['stream'] = True
+        chunk_idx = 0
+        self.is_content = False
+        tool_calls_map: dict[str, llm_entities.ToolCall] = {}
+        pipeline_config = query.pipeline_config
+        async for chunk in self._req_stream(args, extra_body=extra_args):
+            # 处理流式消息
+            delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
+            if delta_message.content:
+                current_content += delta_message.content
+                delta_message.content = current_content
+                # delta_message.all_content = current_content
+            if delta_message.tool_calls:
+                for tool_call in delta_message.tool_calls:
+                    if tool_call.id not in tool_calls_map:
+                        tool_calls_map[tool_call.id] = llm_entities.ToolCall(
+                            id=tool_call.id,
+                            type=tool_call.type,
+                            function=llm_entities.FunctionCall(
+                                name=tool_call.function.name if tool_call.function else '', arguments=''
+                            ),
+                        )
+                    if tool_call.function and tool_call.function.arguments:
+                        # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
+                        tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
 
+            chunk_idx += 1
+            chunk_choices = getattr(chunk, 'choices', None)
+            if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
+                delta_message.is_final = True
+                delta_message.content = current_content
 
+            if chunk_idx % 64 == 0 or delta_message.is_final:
+                yield delta_message

pkg/provider/modelmgr/requesters/modelscopechatcmpl.py

@@ -165,11 +165,10 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         return message
 
     async def _req_stream(
-            self,
-            args: dict,
-            extra_body: dict = {},
+        self,
+        args: dict,
+        extra_body: dict = {},
     ) -> chat_completion.ChatCompletion:
-
         async for chunk in await self.client.chat.completions.create(**args, extra_body=extra_body):
             yield chunk
 
@@ -179,7 +178,6 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         chat_completion: chat_completion.ChatCompletion,
         idx: int,
     ) -> llm_entities.MessageChunk:
-
         # 处理流式chunk和完整响应的差异
         # print(chat_completion.choices[0])
         if hasattr(chat_completion, 'choices'):
@@ -195,7 +193,6 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         if 'role' not in delta or delta['role'] is None:
             delta['role'] = 'assistant'
 
-
         reasoning_content = delta['reasoning_content'] if 'reasoning_content' in delta else None
 
         delta['content'] = '' if delta['content'] is None else delta['content']
@@ -203,13 +200,13 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
 
         # deepseek的reasoner模型
         if pipeline_config['trigger'].get('misc', '').get('remove_think'):
-            if reasoning_content is not None :
+            if reasoning_content is not None:
                 pass
             else:
                 delta['content'] = delta['content']
         else:
             if reasoning_content is not None and idx == 0:
-                delta['content']  += f'<think>\n{reasoning_content}'
+                delta['content'] += f'<think>\n{reasoning_content}'
             elif reasoning_content is None:
                 if self.is_content:
                     delta['content'] = delta['content']
@@ -219,7 +216,6 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
             else:
                 delta['content'] += reasoning_content
 
-
         message = llm_entities.MessageChunk(**delta)
 
         return message
@@ -230,7 +226,6 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         req_messages: list[dict],
         use_model: requester.RuntimeLLMModel,
         use_funcs: list[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
         self.client.api_key = use_model.token_mgr.get_token()
@@ -258,48 +253,42 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
 
         args['messages'] = messages
 
-        if stream:
-            current_content = ''
-            args["stream"] = True
-            chunk_idx = 0
-            self.is_content = False
-            tool_calls_map: dict[str, llm_entities.ToolCall] = {}
-            pipeline_config = query.pipeline_config
-            async for chunk in self._req_stream(args, extra_body=extra_args):
-                # 处理流式消息
-                delta_message = await self._make_msg_chunk(pipeline_config,chunk,chunk_idx)
-                if delta_message.content:
-                    current_content += delta_message.content
-                    delta_message.content = current_content
-                    # delta_message.all_content = current_content
-                if delta_message.tool_calls:
-                    for tool_call in delta_message.tool_calls:
-                        if tool_call.id not in tool_calls_map:
-                            tool_calls_map[tool_call.id] = llm_entities.ToolCall(
-                                id=tool_call.id,
-                                type=tool_call.type,
-                                function=llm_entities.FunctionCall(
-                                    name=tool_call.function.name if tool_call.function else '',
-                                    arguments=''
-                                ),
-                            )
-                        if tool_call.function and tool_call.function.arguments:
-                            # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
-                            tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
-
-
-                chunk_idx += 1
-                chunk_choices = getattr(chunk, 'choices', None)
-                if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
-                    delta_message.is_final = True
-                    delta_message.content = current_content
-
-                if chunk_idx % 64 == 0 or delta_message.is_final:
-
-                    yield delta_message
-                # return
+        current_content = ''
+        args['stream'] = True
+        chunk_idx = 0
+        self.is_content = False
+        tool_calls_map: dict[str, llm_entities.ToolCall] = {}
+        pipeline_config = query.pipeline_config
+        async for chunk in self._req_stream(args, extra_body=extra_args):
+            # 处理流式消息
+            delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
+            if delta_message.content:
+                current_content += delta_message.content
+                delta_message.content = current_content
+                # delta_message.all_content = current_content
+            if delta_message.tool_calls:
+                for tool_call in delta_message.tool_calls:
+                    if tool_call.id not in tool_calls_map:
+                        tool_calls_map[tool_call.id] = llm_entities.ToolCall(
+                            id=tool_call.id,
+                            type=tool_call.type,
+                            function=llm_entities.FunctionCall(
+                                name=tool_call.function.name if tool_call.function else '', arguments=''
+                            ),
+                        )
+                    if tool_call.function and tool_call.function.arguments:
+                        # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
+                        tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
 
+            chunk_idx += 1
+            chunk_choices = getattr(chunk, 'choices', None)
+            if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
+                delta_message.is_final = True
+                delta_message.content = current_content
 
+            if chunk_idx % 64 == 0 or delta_message.is_final:
+                yield delta_message
+            # return
 
     async def invoke_llm(
         self,
@@ -340,16 +329,14 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         except openai.APIError as e:
             raise errors.RequesterError(f'请求错误: {e.message}')
 
-
     async def invoke_llm_stream(
         self,
         query: core_entities.Query,
         model: requester.RuntimeLLMModel,
         messages: typing.List[llm_entities.Message],
         funcs: typing.List[tools_entities.LLMFunction] = None,
-        stream: bool = False,
         extra_args: dict[str, typing.Any] = {},
-    ) ->  llm_entities.MessageChunk:
+    ) -> llm_entities.MessageChunk:
         req_messages = []  # req_messages 仅用于类内，外部同步由 query.messages 进行
         for m in messages:
             msg_dict = m.dict(exclude_none=True)
@@ -367,7 +354,6 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
                 req_messages=req_messages,
                 use_model=model,
                 use_funcs=funcs,
-                stream=stream,
                 extra_args=extra_args,
             ):
                 yield item
@@ -386,4 +372,4 @@ class ModelScopeChatCompletions(requester.LLMAPIRequester):
         except openai.RateLimitError as e:
             raise errors.RequesterError(f'请求过于频繁或余额不足: {e.message}')
         except openai.APIError as e:
-            raise errors.RequesterError(f'请求错误: {e.message}')
+            raise errors.RequesterError(f'请求错误: {e.message}')

pkg/provider/modelmgr/requesters/ppiochatcmpl.py

@@ -5,8 +5,8 @@ import typing
 
 from . import chatcmpl
 import openai.types.chat.chat_completion as chat_completion
-from .. import errors, requester
-from ....core import entities as core_entities, app
+from .. import requester
+from ....core import entities as core_entities
 from ... import entities as llm_entities
 from ...tools import entities as tools_entities
 import re
@@ -25,9 +25,9 @@ class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
     is_think: bool = False
 
     async def _make_msg(
-            self,
-            chat_completion: chat_completion.ChatCompletion,
-            pipeline_config: dict[str, typing.Any] = {'trigger': {'misc': {'remove_think': False}}},
+        self,
+        chat_completion: chat_completion.ChatCompletion,
+        pipeline_config: dict[str, typing.Any] = {'trigger': {'misc': {'remove_think': False}}},
     ) -> llm_entities.Message:
         chatcmpl_message = chat_completion.choices[0].message.model_dump()
         # print(chatcmpl_message.keys(), chatcmpl_message.values())
@@ -40,21 +40,24 @@ class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         # deepseek的reasoner模型
         if pipeline_config['trigger'].get('misc', '').get('remove_think'):
-            chatcmpl_message['content'] = re.sub(r'<think>.*?</think>', '', chatcmpl_message['content'], flags=re.DOTALL)
+            chatcmpl_message['content'] = re.sub(
+                r'<think>.*?</think>', '', chatcmpl_message['content'], flags=re.DOTALL
+            )
         else:
             if reasoning_content is not None:
-                chatcmpl_message['content'] = '<think>\n' + reasoning_content + '\n</think>\n' + chatcmpl_message['content']
+                chatcmpl_message['content'] = (
+                    '<think>\n' + reasoning_content + '\n</think>\n' + chatcmpl_message['content']
+                )
 
         message = llm_entities.Message(**chatcmpl_message)
 
         return message
 
-
     async def _make_msg_chunk(
-            self,
-            pipeline_config: dict[str, typing.Any],
-            chat_completion: chat_completion.ChatCompletion,
-            idx: int,
+        self,
+        pipeline_config: dict[str, typing.Any],
+        chat_completion: chat_completion.ChatCompletion,
+        idx: int,
     ) -> llm_entities.MessageChunk:
         # 处理流式chunk和完整响应的差异
         # print(chat_completion.choices[0])
@@ -80,7 +83,7 @@ class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
             if '<think>' in delta['content']:
                 self.is_think = True
                 delta['content'] = ''
-            if rf'</think>' in delta['content']:
+            if r'</think>' in delta['content']:
                 self.is_think = False
                 delta['content'] = ''
             if not self.is_think:
@@ -95,15 +98,13 @@ class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         return message
 
-
     async def _closure_stream(
-            self,
-            query: core_entities.Query,
-            req_messages: list[dict],
-            use_model: requester.RuntimeLLMModel,
-            use_funcs: list[tools_entities.LLMFunction] = None,
-            stream: bool = False,
-            extra_args: dict[str, typing.Any] = {},
+        self,
+        query: core_entities.Query,
+        req_messages: list[dict],
+        use_model: requester.RuntimeLLMModel,
+        use_funcs: list[tools_entities.LLMFunction] = None,
+        extra_args: dict[str, typing.Any] = {},
     ) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
         self.client.api_key = use_model.token_mgr.get_token()
 
@@ -130,40 +131,38 @@ class PPIOChatCompletions(chatcmpl.OpenAIChatCompletions):
 
         args['messages'] = messages
 
-        if stream:
-            current_content = ''
-            args["stream"] = True
-            chunk_idx = 0
-            self.is_content = False
-            tool_calls_map: dict[str, llm_entities.ToolCall] = {}
-            pipeline_config = query.pipeline_config
-            async for chunk in self._req_stream(args, extra_body=extra_args):
-                # 处理流式消息
-                delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
-                if delta_message.content:
-                    current_content += delta_message.content
-                    delta_message.content = current_content
-                    # delta_message.all_content = current_content
-                if delta_message.tool_calls:
-                    for tool_call in delta_message.tool_calls:
-                        if tool_call.id not in tool_calls_map:
-                            tool_calls_map[tool_call.id] = llm_entities.ToolCall(
-                                id=tool_call.id,
-                                type=tool_call.type,
-                                function=llm_entities.FunctionCall(
-                                    name=tool_call.function.name if tool_call.function else '',
-                                    arguments=''
-                                ),
-                            )
-                        if tool_call.function and tool_call.function.arguments:
-                            # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
-                            tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
+        current_content = ''
+        args['stream'] = True
+        chunk_idx = 0
+        self.is_content = False
+        tool_calls_map: dict[str, llm_entities.ToolCall] = {}
+        pipeline_config = query.pipeline_config
+        async for chunk in self._req_stream(args, extra_body=extra_args):
+            # 处理流式消息
+            delta_message = await self._make_msg_chunk(pipeline_config, chunk, chunk_idx)
+            if delta_message.content:
+                current_content += delta_message.content
+                delta_message.content = current_content
+                # delta_message.all_content = current_content
+            if delta_message.tool_calls:
+                for tool_call in delta_message.tool_calls:
+                    if tool_call.id not in tool_calls_map:
+                        tool_calls_map[tool_call.id] = llm_entities.ToolCall(
+                            id=tool_call.id,
+                            type=tool_call.type,
+                            function=llm_entities.FunctionCall(
+                                name=tool_call.function.name if tool_call.function else '', arguments=''
+                            ),
+                        )
+                    if tool_call.function and tool_call.function.arguments:
+                        # 流式处理中，工具调用参数可能分多个chunk返回，需要追加而不是覆盖
+                        tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
 
-                chunk_idx += 1
-                chunk_choices = getattr(chunk, 'choices', None)
-                if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
-                    delta_message.is_final = True
-                    delta_message.content = current_content
+            chunk_idx += 1
+            chunk_choices = getattr(chunk, 'choices', None)
+            if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
+                delta_message.is_final = True
+                delta_message.content = current_content
 
-                if chunk_idx % 64 == 0 or delta_message.is_final:
-                    yield delta_message
+            if chunk_idx % 64 == 0 or delta_message.is_final:
+                yield delta_message

pkg/provider/runners/difysvapi.py

@@ -348,7 +348,9 @@ class DifyServiceAPIRunner(runner.RequestRunner):
         except AttributeError:
             is_stream = False
 
-        batch_pending_index = 0
+        _ = is_stream
+
+        # batch_pending_index = 0
 
         plain_text, image_ids = await self._preprocess_user_message(query)
 

pkg/provider/runners/localagent.py

@@ -63,8 +63,7 @@ class LocalAgentRunner(runner.RequestRunner):
                                 id=tool_call.id,
                                 type=tool_call.type,
                                 function=llm_entities.FunctionCall(
-                                    name=tool_call.function.name if tool_call.function else '',
-                                    arguments=''
+                                    name=tool_call.function.name if tool_call.function else '', arguments=''
                                 ),
                             )
                         if tool_call.function and tool_call.function.arguments: