xinyin025/LangBot
1
0
Fork 0
mirror of https://github.com/langbot-app/LangBot.git synced 2026-06-10 15:56:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

流式基本流程已通过修改了yield和return的冲突导致的问题

Browse Source
This commit is contained in:
Dong_master
2025-07-04 03:26:44 +08:00
parent 4005a8a3e2
commit 68cdd163d3
8 changed files with 323 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
pkg/provider/entities.py
View File

@@ -140,12 +140,12 @@ class MessageChunk(pydantic.BaseModel):
content: typing.Optional[list[ContentElement]] | typing.Optional[str] = None
"""内容"""
# tool_calls: typing.Optional[list[ToolCall]] = None
tool_calls: typing.Optional[list[ToolCall]] = None
"""工具调用"""
tool_call_id: typing.Optional[str] = None
tool_calls: typing.Optional[list[ToolCallChunk]] = None
# tool_calls: typing.Optional[list[ToolCallChunk]] = None
is_final: bool = False

27
pkg/provider/modelmgr/requester.py
View File

@@ -62,7 +62,7 @@ class LLMAPIRequester(metaclass=abc.ABCMeta):
funcs: typing.List[tools_entities.LLMFunction] = None,
stream: bool = False,
extra_args: dict[str, typing.Any] = {},
) -> llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
) -> llm_entities.Message:
"""调用API
Args:
@@ -72,6 +72,29 @@ class LLMAPIRequester(metaclass=abc.ABCMeta):
extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
Returns:
llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk, None]: 返回消息对象
llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk]: 返回消息对象
"""
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] = {},
) -> llm_entities.MessageChunk:
"""调用API
Args:
model (RuntimeLLMModel): 使用的模型信息
messages (typing.List[llm_entities.Message]): 消息对象列表
funcs (typing.List[tools_entities.LLMFunction], optional): 使用的工具函数列表. Defaults to None.
extra_args (dict[str, typing.Any], optional): 额外的参数. Defaults to {}.
Returns:
llm_entities.Message | typing.AsyncGenerator[llm_entities.MessageChunk]: 返回消息对象
"""
pass

167
pkg/provider/modelmgr/requesters/chatcmpl.py
View File

@@ -38,6 +38,15 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
) -> chat_completion.ChatCompletion:
return await self.client.chat.completions.create(**args, extra_body=extra_body)
async def _req_stream(
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
async def _make_msg(
self,
chat_completion: chat_completion.ChatCompletion,
@@ -62,9 +71,19 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
self,
chat_completion: chat_completion.ChatCompletion,
) -> llm_entities.MessageChunk:
choice = chat_completion.choices[0]
delta = choice.delta.model_dump()
# 处理流式chunk和完整响应的差异
# print(chat_completion.choices[0])
if hasattr(chat_completion, 'choices'):
# 完整响应模式
choice = chat_completion.choices[0]
delta = choice.delta.model_dump() if hasattr(choice, 'delta') else choice.message.model_dump()
else:
# 流式chunk模式
delta = chat_completion.delta.model_dump() if hasattr(chat_completion, 'delta') else {}
# 确保 role 字段存在且不为 None
# print(delta)
if 'role' not in delta or delta['role'] is None:
delta['role'] = 'assistant'
@@ -78,8 +97,8 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
message = llm_entities.MessageChunk(**delta)
return message
async def _closure(
async def _closure_stream(
self,
query: core_entities.Query,
req_messages: list[dict],
@@ -87,7 +106,7 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
use_funcs: 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]:
self.client.api_key = use_model.token_mgr.get_token()
args = {}
@@ -115,36 +134,76 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
if stream:
current_content = ''
async for chunk in await self._req(args, extra_body=extra_args):
args["stream"] = True
async for chunk in self._req_stream(args, extra_body=extra_args):
# print(chunk)
# 处理流式消息
delta_message = await self._make_msg_chunk(
chat_completion=chunk,
)
delta_message = await self._make_msg_chunk(chunk)
if delta_message.content:
current_content += delta_message.content
delta_message.content = current_content
print(current_content)
delta_message.all_content = current_content
# 检查是否为最后一个块
if chunk.choices[0].finish_reason is not None:
# # 检查是否为最后一个块
# if chunk.finish_reason is not None:
# delta_message.is_final = True
#
# yield delta_message
# 检查结束标志
chunk_choices = getattr(chunk, 'choices', None)
if chunk_choices and getattr(chunk_choices[0], 'finish_reason', None):
delta_message.is_final = True
yield delta_message
return
else:
yield delta_message
# return
# 非流式请求
resp = await self._req(args, extra_body=extra_args)
# 处理请求结果
# 发送请求
resp = await self._req(args, extra_body=extra_args)
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 | typing.AsyncGenerator[llm_entities.MessageChunk, None]:
self.client.api_key = use_model.token_mgr.get_token()
# 处理请求结果
message = await self._make_msg(resp)
args = {}
args['model'] = use_model.model_entity.name
return message
if use_funcs:
tools = await self.ap.tool_mgr.generate_tools_for_openai(use_funcs)
if tools:
args['tools'] = tools
# 设置此次请求中的messages
messages = req_messages.copy()
# 检查vision
for msg in messages:
if 'content' in msg and isinstance(msg['content'], list):
for me in msg['content']:
if me['type'] == 'image_base64':
me['image_url'] = {'url': me['image_base64']}
me['type'] = 'image_url'
del me['image_base64']
args['messages'] = messages
# 发送请求
resp = await self._req(args, extra_body=extra_args)
# 处理请求结果
message = await self._make_msg(resp)
return message
@@ -171,8 +230,9 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
req_messages.append(msg_dict)
try:
if stream:
async for item in self._closure(
async for item in self._closure_stream(
query=query,
req_messages=req_messages,
use_model=model,
@@ -180,16 +240,17 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
stream=stream,
extra_args=extra_args,
):
yield item
return
return item
else:
return await self._closure(
print(req_messages)
msg = await self._closure(
query=query,
req_messages=req_messages,
use_model=model,
use_funcs=funcs,
extra_args=extra_args,
)
return msg
except asyncio.TimeoutError:
raise errors.RequesterError('请求超时')
except openai.BadRequestError as e:
@@ -205,3 +266,51 @@ class OpenAIChatCompletions(requester.LLMAPIRequester):
raise errors.RequesterError(f'请求过于频繁或余额不足: {e.message}')
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:
req_messages = [] # req_messages 仅用于类内，外部同步由 query.messages 进行
for m in messages:
msg_dict = m.dict(exclude_none=True)
content = msg_dict.get('content')
if isinstance(content, list):
# 检查 content 列表中是否每个部分都是文本
if all(isinstance(part, dict) and part.get('type') == 'text' for part in content):
# 将所有文本部分合并为一个字符串
msg_dict['content'] = '\n'.join(part['text'] for part in content)
req_messages.append(msg_dict)
try:
if stream:
async for item in self._closure_stream(
query=query,
req_messages=req_messages,
use_model=model,
use_funcs=funcs,
stream=stream,
extra_args=extra_args,
):
yield item
except asyncio.TimeoutError:
raise errors.RequesterError('请求超时')
except openai.BadRequestError as e:
if 'context_length_exceeded' in e.message:
raise errors.RequesterError(f'上文过长，请重置会话: {e.message}')
else:
raise errors.RequesterError(f'请求参数错误: {e.message}')
except openai.AuthenticationError as e:
raise errors.RequesterError(f'无效的 api-key: {e.message}')
except openai.NotFoundError as e:
raise errors.RequesterError(f'请求路径错误: {e.message}')
except openai.RateLimitError as e:
raise errors.RequesterError(f'请求过于频繁或余额不足: {e.message}')
except openai.APIError as e:
raise errors.RequesterError(f'请求错误: {e.message}')

44
pkg/provider/runners/localagent.py
View File

@@ -24,25 +24,30 @@ class LocalAgentRunner(runner.RequestRunner):
pending_tool_calls = []
req_messages = query.prompt.messages.copy() + query.messages.copy() + [query.user_message]
is_stream = query.adapter.is_stream_output_supported()
try:
is_stream = query.adapter.is_stream
except AttributeError:
is_stream = False
# while True:
# pass
if not is_stream:
# 非流式输出，直接请求
# print(123)
msg = await query.use_llm_model.requester.invoke_llm(
query,
query.use_llm_model,
req_messages,
query.use_funcs,
is_stream,
extra_args=query.use_llm_model.model_entity.extra_args,
)
yield msg
final_msg = msg
print(final_msg)
else:
# 流式输出，需要处理工具调用
tool_calls_map: dict[str, llm_entities.ToolCall] = {}
async for msg in await query.use_llm_model.requester.invoke_llm(
async for msg in query.use_llm_model.requester.invoke_llm_stream(
query,
query.use_llm_model,
req_messages,
@@ -51,20 +56,20 @@ class LocalAgentRunner(runner.RequestRunner):
extra_args=query.use_llm_model.model_entity.extra_args,
):
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
# 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,
@@ -105,7 +110,7 @@ class LocalAgentRunner(runner.RequestRunner):
if is_stream:
tool_calls_map = {}
async for msg in await query.use_llm_model.requester.invoke_llm(
async for msg in await query.use_llm_model.requester.invoke_llm_stream(
query,
query.use_llm_model,
req_messages,
@@ -130,10 +135,11 @@ class LocalAgentRunner(runner.RequestRunner):
tool_calls_map[tool_call.id].function.arguments += tool_call.function.arguments
final_msg = llm_entities.Message(
role=msg.role,
content=all_content,
content=msg.all_content,
tool_calls=list(tool_calls_map.values()),
)
else:
print("非流式")
# 处理完所有调用，再次请求
msg = await query.use_llm_model.requester.invoke_llm(
query,