mirror of
https://github.com/zhenxun-org/zhenxun_bot.git
synced 2026-10-07 04:40:00 +08:00
922d092650
* ♻️ refactor(core): 重构 AI 能力与定时任务调度系统 - 【AI 能力与工具】重构 Capability 注册与管理机制，引入 CapabilityManager 统一管理 - 移除全局能力注册表，改用声明式装饰器 `@capability` 进行解耦注册 - 重构工具解析器链，使用统一的 BaseToolResolver 代替原有的多个特定解析器 - 增强工具查询过滤，支持通配符匹配、工具箱过滤和排除标签 - 【定时任务调度】重构定时任务管理器，引入 SchedulerRegistry 统一管理任务元数据 - 引入 JobConfig 聚合定时任务配置，支持用户维度的定时任务调度 - 重构执行分发器，支持并发限制、串行间隔和随机延迟打散 - 【运行上下文】引入 ScheduledDeps 以支持后台和定时任务环境下的依赖注入 - 优化 RunContext，支持从定时任务上下文快速构造，并提供 emit 辅助方法 - 【日志与监控】引入 AILoggerProxy，实现 AI 各模块的专属日志输出 - 将各模块的全局 logger 替换为对应的模块专属日志代理 - 【其他优化】修复 Pydantic V1 兼容层中 model_validator 的装饰器兼容性问题 - 在非交互式环境（如定时任务）中自动隐藏 HITL 交互工具以节省 Token * ♻️ refactor(core): 优化内部导入路径并提升 Pydantic 兼容性 - 【重构】将 `services/ai` 模块内的绝对导入重构为相对导入，优化包结构 - 【重构】移除不必要的 `if TYPE_CHECKING` 保护，通过 `from __future__ import annotations` 直接导入类型 - 【清理】清理 `core/messages/types.py` 中未使用的 `AssistantContentUnion` 等联合类型定义 - 【优化】在 `utils/pydantic_compat.py` 中新增 `model_rebuild` 兼容函数，统一 Pydantic V1/V2 的模型重建逻辑 - 【优化】将部分函数内部的延迟导入提升至模块顶部，规范代码结构 * ♻️ refactor(imports): 优化导入路径为相对导入并清理冗余导入 - 【重构】将 AI 服务相关模块中的绝对导入路径修改为相对导入，提升模块内聚性与可移植性 - 【清理】移除多处函数内部或类方法中未使用的冗余导入，避免循环引用和资源浪费 - 【格式化】微调部分工具装饰器和返回语句的格式与尾随逗号 * 🚨 auto fix by pre-commit hooks --------- Co-authored-by: webjoin111 <455457521@qq.com> Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
238 lines
8.9 KiB
Python
238 lines
8.9 KiB
Python
import asyncio
|
|
from collections.abc import AsyncGenerator
|
|
from typing import Any
|
|
|
|
from zhenxun.services.ai.core.exceptions import (
|
|
AbortException,
|
|
ControlFlowExit,
|
|
LLMException,
|
|
)
|
|
from zhenxun.services.ai.core.messages import UsageInfo
|
|
from zhenxun.services.ai.flow.agent.models import AgentConfig
|
|
from zhenxun.services.ai.run import AgentRunResult, RunContext
|
|
from zhenxun.services.ai.run.models import AgentRunEnd
|
|
from zhenxun.services.ai.utils.logger import log_team as logger
|
|
from zhenxun.utils.pydantic_compat import model_construct
|
|
|
|
from .capabilities import TeamRoutingCapability
|
|
from .models import (
|
|
CallAction,
|
|
ConcurrentCallAction,
|
|
FinishAction,
|
|
)
|
|
from .strategy import BaseTeamStrategy, RouteStrategy
|
|
|
|
|
|
class TeamRunner:
|
|
"""
|
|
多智能体团队核心执行引擎。
|
|
"""
|
|
|
|
def __init__(self, team: Any, strategy: BaseTeamStrategy):
|
|
self.team = team
|
|
self.strategy = strategy
|
|
|
|
async def _execute_call_action_to_queue(
|
|
self,
|
|
index: int,
|
|
action: CallAction,
|
|
context: RunContext,
|
|
session_id: str,
|
|
queue: asyncio.Queue,
|
|
):
|
|
"""
|
|
辅助方法：执行单一 Agent 任务，
|
|
并将内部产生的 UI 事件与最终结果通过队列透传回主线程
|
|
"""
|
|
if isinstance(action.agent, str):
|
|
target_agent = next(
|
|
(m for m in self.team.members if m.name == action.agent), None
|
|
)
|
|
if not target_agent:
|
|
logger.error(f"❌ 找不到团队成员: {action.agent}")
|
|
await queue.put(
|
|
(
|
|
"result",
|
|
(
|
|
action.agent,
|
|
AgentRunResult(
|
|
output=f"Error: {action.agent} not found",
|
|
usage=UsageInfo(),
|
|
),
|
|
),
|
|
)
|
|
)
|
|
return
|
|
else:
|
|
target_agent = action.agent
|
|
|
|
sub_context = context.clone_for_member(target_agent.name)
|
|
sub_context.capabilities = list(sub_context.capabilities)
|
|
|
|
if isinstance(self.strategy, RouteStrategy):
|
|
routing_cap = TeamRoutingCapability(
|
|
team_name=self.team.name,
|
|
members=self.team.members,
|
|
state_flow=getattr(self.strategy, "state_flow", None),
|
|
max_handoffs=getattr(self.strategy, "max_handoffs", 3),
|
|
)
|
|
sub_context.capabilities.append(routing_cap)
|
|
|
|
logger.debug(f"🚀 **专员 👨💼`{target_agent.name}`** 开始执行子任务...")
|
|
|
|
agent_res = None
|
|
|
|
try:
|
|
async with target_agent.run_stream(
|
|
prompt=action.task,
|
|
context=sub_context,
|
|
config=AgentConfig(message_history=action.history),
|
|
**(action.kwargs or {}),
|
|
) as stream_result:
|
|
async for event in stream_result.stream_events():
|
|
if isinstance(event, AgentRunEnd):
|
|
agent_res = event.result
|
|
else:
|
|
await queue.put(("yield_event", event))
|
|
except ControlFlowExit as cfe:
|
|
if isinstance(cfe, AbortException):
|
|
await queue.put(("control_flow_error", cfe))
|
|
return
|
|
else:
|
|
logger.debug(
|
|
f"Agent {target_agent.name} 触发局部控制流: "
|
|
f"{type(cfe).__name__} - {cfe}"
|
|
)
|
|
agent_res = AgentRunResult(output=str(cfe), usage=UsageInfo())
|
|
except Exception as e:
|
|
logger.error(f"Agent {target_agent.name} 执行崩溃: {e}")
|
|
|
|
if isinstance(e, LLMException):
|
|
abort_msg = getattr(e, "user_friendly_message", str(e))
|
|
display_msg = (
|
|
f"❌ 智能体 {target_agent.name} 执行发生致命故障: {abort_msg}"
|
|
)
|
|
abort_err = AbortException(
|
|
reason=str(e),
|
|
display=display_msg,
|
|
)
|
|
await queue.put(("control_flow_error", abort_err))
|
|
return
|
|
|
|
agent_res = AgentRunResult(output=f"Error: {e}", usage=UsageInfo())
|
|
|
|
if agent_res and agent_res.handoff:
|
|
target_name = agent_res.handoff.target
|
|
reason = agent_res.handoff.reason
|
|
|
|
logger.info(
|
|
f"🛣️ **路由决策**: 委派给专员 👨💼`{target_name}` (理由: {reason})"
|
|
)
|
|
|
|
if not agent_res:
|
|
agent_res = AgentRunResult(
|
|
output="Error: No result returned", usage=UsageInfo()
|
|
)
|
|
|
|
logger.debug(f"✅ **专员 👨💼`{target_agent.name}`** 完成任务！")
|
|
|
|
await queue.put(("result", index, target_agent.name, agent_res))
|
|
|
|
async def run_stream(
|
|
self, prompt: Any, context: RunContext, **kwargs: Any
|
|
) -> AsyncGenerator[Any, None]:
|
|
session_id = context.session_id or "default_team_session"
|
|
task_desc = getattr(prompt, "description", str(prompt))
|
|
|
|
logger.info(f"🤝 **团队 [{self.team.name}] 开始协作**: `{task_desc}`")
|
|
|
|
plan_gen = self.strategy.generate_plan(self.team, prompt, context, **kwargs)
|
|
|
|
send_value = None
|
|
final_result = None
|
|
cumulative_usage = UsageInfo()
|
|
|
|
try:
|
|
while True:
|
|
try:
|
|
action = await plan_gen.asend(send_value)
|
|
except StopAsyncIteration:
|
|
break
|
|
|
|
if isinstance(action, CallAction):
|
|
queue = asyncio.Queue()
|
|
task = asyncio.create_task(
|
|
self._execute_call_action_to_queue(
|
|
0, action, context, session_id, queue
|
|
)
|
|
)
|
|
try:
|
|
while True:
|
|
msg_type, *payload = await queue.get()
|
|
if msg_type == "yield_event":
|
|
yield payload[0]
|
|
elif msg_type == "control_flow_error":
|
|
raise payload[0]
|
|
elif msg_type == "result":
|
|
idx, agent_name, agent_res = payload
|
|
send_value = agent_res
|
|
cumulative_usage += agent_res.usage
|
|
break
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
elif isinstance(action, ConcurrentCallAction):
|
|
queue = asyncio.Queue()
|
|
tasks = []
|
|
for i, act in enumerate(action.actions):
|
|
tasks.append(
|
|
asyncio.create_task(
|
|
self._execute_call_action_to_queue(
|
|
i, act, context, session_id, queue
|
|
)
|
|
)
|
|
)
|
|
|
|
results_dict = {}
|
|
try:
|
|
while len(results_dict) < len(action.actions):
|
|
msg_type, *payload = await queue.get()
|
|
if msg_type == "yield_event":
|
|
yield payload[0]
|
|
elif msg_type == "control_flow_error":
|
|
for t in tasks:
|
|
t.cancel()
|
|
raise payload[0]
|
|
elif msg_type == "result":
|
|
idx, agent_name, agent_res = payload
|
|
results_dict[idx] = (agent_name, agent_res)
|
|
cumulative_usage += agent_res.usage
|
|
send_value = [
|
|
results_dict[i] for i in range(len(action.actions))
|
|
]
|
|
finally:
|
|
for task in tasks:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
elif isinstance(action, FinishAction):
|
|
final_result = action.result
|
|
break
|
|
else:
|
|
raise ValueError(f"TeamRunner 遇到了未知的动作类型: {type(action)}")
|
|
|
|
except Exception as e:
|
|
raise e
|
|
|
|
logger.info(f"🏁 **团队 [{self.team.name}]** 协作圆满结束！")
|
|
|
|
if not isinstance(final_result, AgentRunResult):
|
|
final_result = model_construct(
|
|
AgentRunResult, output=final_result, usage=cumulative_usage
|
|
)
|
|
else:
|
|
final_result.usage += cumulative_usage
|
|
|
|
yield AgentRunEnd(result=final_result)
|