379 lines
16 KiB
Python
379 lines
16 KiB
Python
"""
|
||
llm/llm_engine.py
|
||
LLM 引擎：通过 Provider 接口调用真实 OpenAI API
|
||
支持 Function Calling 多步骤规划 + 工具结果整合回复
|
||
"""
|
||
|
||
import re
|
||
from dataclasses import dataclass
|
||
|
||
from config.settings import LLMConfig, settings
|
||
from llm.provider_factory import create_provider
|
||
from llm.providers.base_provider import BaseProvider
|
||
from mcp.mcp_protocol import ChainPlan, MCPMethod, MCPRequest, ToolSchema, ToolStep
|
||
from utils.logger import get_logger
|
||
|
||
|
||
@dataclass
|
||
class ToolDecision:
|
||
need_tool: bool
|
||
tool_name: str = ""
|
||
arguments: dict = None
|
||
reasoning: str = ""
|
||
|
||
def __post_init__(self):
|
||
self.arguments = self.arguments or {}
|
||
|
||
def to_mcp_request(self) -> MCPRequest | None:
|
||
if not self.need_tool:
|
||
return None
|
||
return MCPRequest(
|
||
method=MCPMethod.TOOLS_CALL,
|
||
params={"name": self.tool_name, "arguments": self.arguments},
|
||
)
|
||
|
||
|
||
class LLMEngine:
|
||
"""
|
||
LLM 推理引擎（Provider 模式）
|
||
|
||
核心流程:
|
||
1. plan_tool_chain()
|
||
构造 OpenAI 格式消息 + tools
|
||
→ Provider.plan_with_tools()
|
||
→ 解析 tool_calls → ChainPlan
|
||
|
||
2. generate_chain_reply()
|
||
构造含工具结果的完整消息历史
|
||
→ Provider.generate_reply()
|
||
→ 最终自然语言回复
|
||
|
||
降级策略:
|
||
API 调用失败 且 fallback_to_rules=true
|
||
→ 自动切换到规则引擎（保证系统可用性）
|
||
"""
|
||
|
||
# 规则引擎关键词（降级时使用）
|
||
_MULTI_STEP_KEYWORDS = [
|
||
"然后", "接着", "再", "并且", "同时", "之后",
|
||
"先.*再", "首先.*然后", "搜索.*计算", "读取.*执行",
|
||
"多个", "分别", "依次",
|
||
]
|
||
|
||
def __init__(self, cfg: LLMConfig | None = None):
|
||
self.cfg = cfg or settings.llm
|
||
self.logger = get_logger("LLM")
|
||
self.provider: BaseProvider = create_provider(self.cfg)
|
||
self._log_init()
|
||
|
||
def _log_init(self) -> None:
|
||
self.logger.info("🧠 LLM 引擎初始化完成")
|
||
self.logger.info(f" provider = {self.cfg.provider}")
|
||
self.logger.info(f" model_name = {self.cfg.model_name}")
|
||
self.logger.info(f" function_calling = {self.cfg.function_calling}")
|
||
self.logger.info(f" temperature = {self.cfg.temperature}")
|
||
self.logger.info(f" fallback_rules = {settings.agent.fallback_to_rules}")
|
||
|
||
def reconfigure(self, cfg: LLMConfig) -> None:
|
||
"""热更新配置并重建 Provider"""
|
||
self.cfg = cfg
|
||
self.provider = create_provider(cfg)
|
||
self.logger.info(f"🔄 LLM 配置已更新: model={cfg.model_name}")
|
||
|
||
# ════════════════════════════════════════════════════════════
|
||
# 核心接口
|
||
# ════════════════════════════════════════════════════════════
|
||
|
||
def plan_tool_chain(
|
||
self,
|
||
user_input: str,
|
||
tool_schemas: list[ToolSchema],
|
||
context: str = "",
|
||
history: list[dict] | None = None,
|
||
) -> ChainPlan:
|
||
"""
|
||
使用 OpenAI Function Calling 规划工具调用链
|
||
|
||
消息构造策略:
|
||
system → 规划器系统提示
|
||
history → 历史对话（可选）
|
||
user → 当前用户输入
|
||
|
||
Args:
|
||
user_input: 用户输入文本
|
||
tool_schemas: 可用工具列表
|
||
context: 对话历史摘要（文本格式，用于无 history 时）
|
||
history: 结构化对话历史（OpenAI 消息格式，优先使用）
|
||
|
||
Returns:
|
||
ChainPlan 实例
|
||
"""
|
||
self.logger.info(f"🗺 规划工具调用链: {user_input[:60]}...")
|
||
|
||
# 构造消息列表
|
||
messages = self._build_plan_messages(user_input, context, history)
|
||
|
||
if self.cfg.function_calling:
|
||
# ── 真实 OpenAI Function Calling ──────────────────
|
||
result = self.provider.plan_with_tools(messages, tool_schemas)
|
||
|
||
if result.success and result.plan is not None:
|
||
plan = result.plan
|
||
# 补充 goal 字段
|
||
if not plan.goal:
|
||
plan.goal = user_input
|
||
self.logger.info(f"📋 OpenAI 规划完成: {plan.step_count} 步")
|
||
for step in plan.steps:
|
||
self.logger.info(
|
||
f" Step {step.step_id}: [{step.tool_name}] "
|
||
f"args={step.arguments}"
|
||
)
|
||
return plan
|
||
|
||
# API 失败处理
|
||
self.logger.warning(f"⚠️ OpenAI 规划失败: {result.error}")
|
||
if settings.agent.fallback_to_rules:
|
||
self.logger.info("🔄 降级到规则引擎...")
|
||
return self._rule_based_plan(user_input)
|
||
return ChainPlan(goal=user_input, steps=[])
|
||
|
||
else:
|
||
# function_calling=false 时直接使用规则引擎
|
||
self.logger.info("⚙️ function_calling=false，使用规则引擎")
|
||
return self._rule_based_plan(user_input)
|
||
|
||
def think_and_decide(
|
||
self,
|
||
user_input: str,
|
||
tool_schemas: list[ToolSchema],
|
||
context: str = "",
|
||
) -> ToolDecision:
|
||
"""单步工具决策（代理到 plan_tool_chain）"""
|
||
plan = self.plan_tool_chain(user_input, tool_schemas, context)
|
||
if not plan.steps:
|
||
return ToolDecision(need_tool=False, reasoning="无需工具，直接回复")
|
||
first = plan.steps[0]
|
||
return ToolDecision(
|
||
need_tool=True,
|
||
tool_name=first.tool_name,
|
||
arguments=first.arguments,
|
||
reasoning=first.description,
|
||
)
|
||
|
||
def generate_chain_reply(
|
||
self,
|
||
user_input: str,
|
||
chain_summary: str,
|
||
context: str = "",
|
||
tool_messages: list[dict] | None = None,
|
||
) -> str:
|
||
"""
|
||
整合多步骤执行结果，调用 OpenAI 生成最终自然语言回复
|
||
|
||
消息构造（含工具执行结果）:
|
||
system → 回复生成系统提示
|
||
user → 原始用户输入
|
||
assistant → 工具调用决策（tool_calls）
|
||
tool → 工具执行结果
|
||
...（多轮工具调用）
|
||
|
||
Args:
|
||
user_input: 原始用户输入
|
||
chain_summary: 步骤摘要（API 失败时的降级内容）
|
||
context: 对话历史
|
||
tool_messages: 完整的工具调用消息序列（OpenAI 格式）
|
||
|
||
Returns:
|
||
最终回复字符串
|
||
"""
|
||
self.logger.info("✍️ 生成最终回复...")
|
||
|
||
if tool_messages:
|
||
# 构造含工具结果的完整消息历史
|
||
messages = self._build_reply_messages(user_input, tool_messages)
|
||
result = self.provider.generate_reply(messages)
|
||
|
||
if result.success and result.content:
|
||
self.logger.info(
|
||
f"✅ OpenAI 回复生成成功 ({len(result.content)} chars)"
|
||
)
|
||
return result.content
|
||
|
||
self.logger.warning(f"⚠️ OpenAI 回复生成失败: {result.error}")
|
||
|
||
# 降级：使用模板回复
|
||
return self._fallback_chain_reply(user_input, chain_summary)
|
||
|
||
def generate_final_reply(
|
||
self,
|
||
user_input: str,
|
||
tool_name: str,
|
||
tool_output: str,
|
||
context: str = "",
|
||
tool_call_id: str = "",
|
||
) -> str:
|
||
"""单步工具结果整合（调用 OpenAI 生成自然语言回复）"""
|
||
self.logger.info(f"✍️ 整合单步工具结果 [{tool_name}]...")
|
||
|
||
# 构造单步工具消息
|
||
tool_messages = []
|
||
if tool_call_id:
|
||
tool_messages = [
|
||
{
|
||
"role": "tool",
|
||
"content": tool_output,
|
||
"tool_call_id": tool_call_id,
|
||
}
|
||
]
|
||
|
||
return self.generate_chain_reply(
|
||
user_input=user_input,
|
||
chain_summary=tool_output,
|
||
context=context,
|
||
tool_messages=tool_messages,
|
||
)
|
||
|
||
def generate_direct_reply(self, user_input: str, context: str = "") -> str:
|
||
"""无需工具时直接调用 OpenAI 生成回复"""
|
||
self.logger.info("💬 直接生成回复（无需工具）...")
|
||
messages = [
|
||
{"role": "system", "content": "你是一个友好、专业的 AI 助手，请简洁准确地回答用户问题。"},
|
||
{"role": "user", "content": user_input},
|
||
]
|
||
result = self.provider.generate_reply(messages)
|
||
if result.success and result.content:
|
||
return result.content
|
||
# 降级
|
||
return (
|
||
f"[{self.cfg.model_name}] 您好！\n"
|
||
f"关于「{user_input}」，我已收到您的问题。\n"
|
||
f"（API 暂时不可用，请检查 API Key 配置）"
|
||
)
|
||
|
||
# ════════════════════════════════════════════════════════════
|
||
# 消息构造
|
||
# ════════════════════════════════════════════════════════════
|
||
|
||
@staticmethod
|
||
def _build_plan_messages(
|
||
user_input: str,
|
||
context: str,
|
||
history: list[dict] | None,
|
||
) -> list[dict]:
|
||
"""构造规划阶段的消息列表"""
|
||
from llm.providers.openai_provider import OpenAIProvider
|
||
messages: list[dict] = [
|
||
{"role": "system", "content": OpenAIProvider._PLANNER_SYSTEM_PROMPT},
|
||
]
|
||
# 注入结构化历史（优先）或文本摘要
|
||
if history:
|
||
messages.extend(history[-6:]) # 最近 3 轮
|
||
elif context and context != "（暂无对话历史）":
|
||
messages.append({
|
||
"role": "system",
|
||
"content": f"## 对话历史\n{context}",
|
||
})
|
||
messages.append({"role": "user", "content": user_input})
|
||
return messages
|
||
|
||
@staticmethod
|
||
def _build_reply_messages(
|
||
user_input: str,
|
||
tool_messages: list[dict],
|
||
) -> list[dict]:
|
||
"""构造回复生成阶段的消息列表（含工具执行结果）"""
|
||
from llm.providers.openai_provider import OpenAIProvider
|
||
messages: list[dict] = [
|
||
{"role": "system", "content": OpenAIProvider._REPLY_SYSTEM_PROMPT},
|
||
{"role": "user", "content": user_input},
|
||
]
|
||
messages.extend(tool_messages)
|
||
return messages
|
||
|
||
# ════════════════════════════════════════════════════════════
|
||
# 降级规则引擎
|
||
# ════════════════════════════════════════════════════════════
|
||
|
||
def _rule_based_plan(self, user_input: str) -> ChainPlan:
|
||
"""规则引擎（API 不可用时的降级方案）"""
|
||
self.logger.info("⚙️ 使用规则引擎规划...")
|
||
text = user_input.lower()
|
||
|
||
# 搜索 + 计算
|
||
if (any(k in text for k in ["搜索", "查询", "查一下"]) and
|
||
any(k in text for k in ["计算", "算", "等于", "结果"])):
|
||
return ChainPlan(
|
||
goal=user_input,
|
||
steps=[
|
||
ToolStep(1, "web_search",
|
||
{"query": user_input,
|
||
"max_results": settings.tools.web_search.max_results},
|
||
"搜索相关信息", []),
|
||
ToolStep(2, "calculator",
|
||
{"expression": self._extract_expression(user_input)},
|
||
"进行计算", [1]),
|
||
],
|
||
)
|
||
# 读取文件 + 执行代码
|
||
if (any(k in text for k in ["读取", "文件", "file"]) and
|
||
any(k in text for k in ["执行", "运行", "run"])):
|
||
fname = re.search(r"[\w\-\.]+\.\w+", user_input)
|
||
return ChainPlan(
|
||
goal=user_input,
|
||
steps=[
|
||
ToolStep(1, "file_reader",
|
||
{"path": fname.group() if fname else "script.py"},
|
||
"读取文件", []),
|
||
ToolStep(2, "code_executor",
|
||
{"code": "{{STEP_1_OUTPUT}}",
|
||
"timeout": settings.tools.code_executor.timeout},
|
||
"执行代码", [1]),
|
||
],
|
||
)
|
||
return self._rule_single_step(user_input)
|
||
|
||
def _rule_single_step(self, user_input: str) -> ChainPlan:
|
||
"""单步规则匹配"""
|
||
text = user_input.lower()
|
||
if any(k in text for k in ["计算", "等于", "×", "÷", "+", "-", "*", "/"]):
|
||
expr = self._extract_expression(user_input)
|
||
return ChainPlan(goal=user_input, is_single=True,
|
||
steps=[ToolStep(1, "calculator",
|
||
{"expression": expr}, "数学计算")])
|
||
if any(k in text for k in ["搜索", "查询", "天气", "新闻"]):
|
||
return ChainPlan(goal=user_input, is_single=True,
|
||
steps=[ToolStep(1, "web_search",
|
||
{"query": user_input,
|
||
"max_results": settings.tools.web_search.max_results},
|
||
"网络搜索")])
|
||
if any(k in text for k in ["文件", "读取", "file"]):
|
||
fname = re.search(r"[\w\-\.]+\.\w+", user_input)
|
||
return ChainPlan(goal=user_input, is_single=True,
|
||
steps=[ToolStep(1, "file_reader",
|
||
{"path": fname.group() if fname else "config.json"},
|
||
"读取文件")])
|
||
if any(k in text for k in ["执行", "运行", "代码", "python"]):
|
||
code_m = re.search(r"[`'\"](.+?)[`'\"]", user_input)
|
||
code = code_m.group(1) if code_m else 'print("Hello, Agent!")'
|
||
return ChainPlan(goal=user_input, is_single=True,
|
||
steps=[ToolStep(1, "code_executor",
|
||
{"code": code,
|
||
"timeout": settings.tools.code_executor.timeout},
|
||
"执行代码")])
|
||
return ChainPlan(goal=user_input, is_single=True, steps=[])
|
||
|
||
@staticmethod
|
||
def _fallback_chain_reply(user_input: str, chain_summary: str) -> str:
|
||
"""API 不可用时的模板回复"""
|
||
return (
|
||
f"✅ **任务已完成**\n\n"
|
||
f"针对您的需求「{user_input}」，执行结果如下：\n\n"
|
||
f"{chain_summary}"
|
||
)
|
||
|
||
@staticmethod
|
||
def _extract_expression(text: str) -> str:
|
||
cleaned = text.replace("×", "*").replace("÷", "/").replace("，", "")
|
||
match = re.search(r"[\d\s\+\-\*\/\(\)\.]+", cleaned)
|
||
expr = match.group().strip() if match else "1+1"
|
||
return expr if len(expr) > 1 else "1+1" |