feat: 实现流式消息处理支持

pkg/provider/entities.py

@@ -125,6 +125,89 @@ class Message(pydantic.BaseModel):
             return platform_message.MessageChain(mc)
 
 
+class MessageChunk(pydantic.BaseModel):
+    """消息"""
+
+    role: str  # user, system, assistant, tool, command, plugin
+    """消息的角色"""
+
+    name: typing.Optional[str] = None
+    """名称，仅函数调用返回时设置"""
+
+    all_content: typing.Optional[str] = None
+    """所有内容"""
+
+    content: typing.Optional[list[ContentElement]] | typing.Optional[str] = None
+    """内容"""
+
+    # tool_calls: typing.Optional[list[ToolCall]] = None
+    """工具调用"""
+
+    tool_call_id: typing.Optional[str] = None
+
+    tool_calls: typing.Optional[list[ToolCallChunk]] = None
+    
+    is_final: bool = False
+
+    def readable_str(self) -> str:
+        if self.content is not None:
+            return str(self.role) + ': ' + str(self.get_content_platform_message_chain())
+        elif self.tool_calls is not None:
+            return f'调用工具: {self.tool_calls[0].id}'
+        else:
+            return '未知消息'
+
+    def get_content_platform_message_chain(self, prefix_text: str = '') -> platform_message.MessageChain | None:
+        """将内容转换为平台消息 MessageChain 对象
+
+        Args:
+            prefix_text (str): 首个文字组件的前缀文本
+        """
+
+        if self.content is None:
+            return None
+        elif isinstance(self.content, str):
+            return platform_message.MessageChain([platform_message.Plain(prefix_text + self.content)])
+        elif isinstance(self.content, list):
+            mc = []
+            for ce in self.content:
+                if ce.type == 'text':
+                    mc.append(platform_message.Plain(ce.text))
+                elif ce.type == 'image_url':
+                    if ce.image_url.url.startswith('http'):
+                        mc.append(platform_message.Image(url=ce.image_url.url))
+                    else:  # base64
+                        b64_str = ce.image_url.url
+
+                        if b64_str.startswith('data:'):
+                            b64_str = b64_str.split(',')[1]
+
+                        mc.append(platform_message.Image(base64=b64_str))
+
+            # 找第一个文字组件
+            if prefix_text:
+                for i, c in enumerate(mc):
+                    if isinstance(c, platform_message.Plain):
+                        mc[i] = platform_message.Plain(prefix_text + c.text)
+                        break
+                else:
+                    mc.insert(0, platform_message.Plain(prefix_text))
+
+            return platform_message.MessageChain(mc)
+
+
+class ToolCallChunk(pydantic.BaseModel):
+    """工具调用"""
+
+    id: str
+    """工具调用ID"""
+
+    type: str
+    """工具调用类型"""
+
+    function: FunctionCall
+    """函数调用"""
+
 class Prompt(pydantic.BaseModel):
     """供AI使用的Prompt"""
 

pkg/provider/modelmgr/requester.py

@@ -83,8 +83,9 @@ class ProviderAPIRequester(metaclass=abc.ABCMeta):
         model: 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.Message:
+    ) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
         """调用API
 
         Args:
@@ -94,7 +95,7 @@ class ProviderAPIRequester(metaclass=abc.ABCMeta):
             extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
 
         Returns:
-            llm_entities.Message: 返回消息对象
+            llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]: 返回消息对象
         """
         pass
 

pkg/provider/modelmgr/requesters/chatcmpl.py

@@ -57,13 +57,35 @@ class OpenAIChatCompletions(requester.ProviderAPIRequester):
         message = llm_entities.Message(**chatcmpl_message)
 
         return message
+    
+    async def _make_msg_chunk(
+        self,
+        chat_completion: chat_completion.ChatCompletion,
+    ) -> llm_entities.MessageChunk:
+        choice = chat_completion.choices[0]
+        delta = choice.delta.model_dump()
+        # 确保 role 字段存在且不为 None
+        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
+
+        # deepseek的reasoner模型
+        if reasoning_content is not None:
+            delta['content'] = '<think>\n' + reasoning_content + '\n</think>\n' + delta['content']
+
+        message = llm_entities.MessageChunk(**delta)
+
+        return message
+    
     async def _closure(
         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] = {},
     ) -> llm_entities.Message:
         self.client.api_key = use_model.token_mgr.get_token()
@@ -91,13 +113,42 @@ class OpenAIChatCompletions(requester.ProviderAPIRequester):
 
         args['messages'] = messages
 
-        # 发送请求
-        resp = await self._req(args, extra_body=extra_args)
+        if stream:
+            current_content = ''
+            async for chunk in await self._req(args, extra_body=extra_args):
 
-        # 处理请求结果
-        message = await self._make_msg(resp)
+                # 处理流式消息
+                delta_message = await self._make_msg_chunk(
+                    chat_completion=chunk,
+                )
+                if delta_message.content:
+                    current_content += delta_message.content
+                    delta_message.all_content = current_content
+                
+                # 检查是否为最后一个块
+                if chunk.choices[0].finish_reason is not None:
+                    delta_message.is_final = True
 
-        return message
+                yield delta_message  
+            return 
+        
+        else:
+
+            # 非流式请求
+            resp = await self._req(args, extra_body=extra_args)
+            # 处理请求结果
+            # 发送请求
+            resp = await self._req(args, extra_body=extra_args)
+
+            # 处理请求结果
+            message = await self._make_msg(resp)
+
+            return message
+           
+
+         
+
+    
 
     async def invoke_llm(
         self,
@@ -105,8 +156,9 @@ class OpenAIChatCompletions(requester.ProviderAPIRequester):
         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.Message:
+    ) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
         req_messages = []  # req_messages 仅用于类内，外部同步由 query.messages 进行
         for m in messages:
             msg_dict = m.dict(exclude_none=True)
@@ -119,13 +171,25 @@ class OpenAIChatCompletions(requester.ProviderAPIRequester):
             req_messages.append(msg_dict)
 
         try:
-            return await self._closure(
-                query=query,
-                req_messages=req_messages,
-                use_model=model,
-                use_funcs=funcs,
-                extra_args=extra_args,
-            )
+            if stream:
+                async for item in self._closure(
+                    query=query,
+                    req_messages=req_messages,
+                    use_model=model,
+                    use_funcs=funcs,
+                    stream=stream,
+                    extra_args=extra_args,
+                ):
+                    yield item
+                return
+            else:
+                return await self._closure(
+                    query=query,
+                    req_messages=req_messages,
+                    use_model=model,
+                    use_funcs=funcs,
+                    extra_args=extra_args,
+                )
         except asyncio.TimeoutError:
             raise errors.RequesterError('请求超时')
         except openai.BadRequestError as e:

pkg/provider/runners/localagent.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import copy
+from ssl import ALERT_DESCRIPTION_BAD_CERTIFICATE_HASH_VALUE
 import typing
 from .. import runner
 from ...core import entities as core_entities
@@ -27,7 +28,13 @@ Respond in the same language as the user's input.
 class LocalAgentRunner(runner.RequestRunner):
     """本地Agent请求运行器"""
 
-    async def run(self, query: core_entities.Query) -> typing.AsyncGenerator[llm_entities.Message, None]:
+    class ToolCallTracker:
+        """工具调用追踪器"""
+        def __init__(self):
+            self.active_calls: dict[str,dict] = {}
+            self.completed_calls: list[llm_entities.ToolCall] = []
+
+    async def run(self, query: core_entities.Query) -> typing.AsyncGenerator[llm_entities.Message | llm_entities.MessageChunk, None]:
         """运行请求"""
         pending_tool_calls = []
 
@@ -80,20 +87,57 @@ class LocalAgentRunner(runner.RequestRunner):
 
         req_messages = query.prompt.messages.copy() + query.messages.copy() + [user_message]
 
-        # 首次请求
-        msg = await query.use_llm_model.requester.invoke_llm(
-            query,
-            query.use_llm_model,
-            req_messages,
-            query.use_funcs,
-            extra_args=query.use_llm_model.model_entity.extra_args,
-        )
+        is_stream = query.adapter.is_stream_output_supported()
+        # while True:
+        #     pass
+        if not is_stream:
+            # 非流式输出，直接请求
+            msg = await query.use_llm_model.requester.invoke_llm(
+                query,
+                query.use_llm_model,
+                req_messages,
+                query.use_funcs,
+                extra_args=query.use_llm_model.model_entity.extra_args,
+            )
+            yield msg
+            final_msg = msg
+        else:
+            # 流式输出，需要处理工具调用
+            tool_calls_map: dict[str, llm_entities.ToolCall] = {}
+            async for msg in await query.use_llm_model.requester.invoke_llm(
+                query,
+                query.use_llm_model,
+                req_messages,
+                query.use_funcs,
+                stream=is_stream,
+                extra_args=query.use_llm_model.model_entity.extra_args,
+            ):  
+                assert isinstance(msg, llm_entities.MessageChunk)
+                yield msg
+                if msg.tool_calls:
+                    for tool_call in msg.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
+            final_msg = llm_entities.Message(
+                role=msg.role,
+                content=msg.all_content,
+                tool_calls=list(tool_calls_map.values()),
+            )
 
-        yield msg
+        
+        pending_tool_calls = final_msg.tool_calls
 
-        pending_tool_calls = msg.tool_calls
-
-        req_messages.append(msg)
+        req_messages.append(final_msg)
 
         # 持续请求，只要还有待处理的工具调用就继续处理调用
         while pending_tool_calls:
@@ -122,17 +166,50 @@ class LocalAgentRunner(runner.RequestRunner):
 
                     req_messages.append(err_msg)
 
-            # 处理完所有调用，再次请求
-            msg = await query.use_llm_model.requester.invoke_llm(
-                query,
-                query.use_llm_model,
-                req_messages,
-                query.use_funcs,
-                extra_args=query.use_llm_model.model_entity.extra_args,
-            )
+            if is_stream:
+                tool_calls_map = {}
+                async for msg in await query.use_llm_model.requester.invoke_llm(
+                    query,
+                    query.use_llm_model,
+                    req_messages,
+                    query.use_funcs,
+                    stream=is_stream,
+                    extra_args=query.use_llm_model.model_entity.extra_args, 
+                ):  
+                    assert isinstance(msg, llm_entities.MessageChunk)
+                    yield msg
+                if msg.tool_calls:
+                    for tool_call in msg.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
+                final_msg = llm_entities.Message(
+                    role=msg.role,
+                    content=msg.all_content,
+                    tool_calls=list(tool_calls_map.values()),
+                )
+            else:
+                # 处理完所有调用，再次请求
+                msg = await query.use_llm_model.requester.invoke_llm(
+                    query,
+                    query.use_llm_model,
+                    req_messages,
+                    query.use_funcs,
+                    extra_args=query.use_llm_model.model_entity.extra_args,
+                )
 
-            yield msg
+                yield msg
+                final_msg = msg
 
-            pending_tool_calls = msg.tool_calls
+            pending_tool_calls = final_msg.tool_calls
 
-            req_messages.append(msg)
+            req_messages.append(final_msg)