refactor

function_calls/llm.py

@@ -0,0 +1,263 @@
+"""LLM function-call orchestration utilities."""
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional
+
+from commands.context import MessageContext
+
+from .spec import FunctionResult, FunctionSpec
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class LLMRunResult:
+    """Result of the LLM routing pipeline."""
+
+    handled: bool
+    final_response: Optional[str] = None
+    error: Optional[str] = None
+
+
+class FunctionCallLLM:
+    """Coordinate function-call capable models with router handlers."""
+
+    def __init__(self, max_function_rounds: int = 5) -> None:
+        self.logger = logger
+        self.max_function_rounds = max_function_rounds
+
+    def run(
+        self,
+        ctx: MessageContext,
+        functions: Dict[str, FunctionSpec],
+        executor: Callable[[FunctionSpec, Dict[str, Any]], FunctionResult],
+        formatter: Callable[[FunctionResult], str],
+    ) -> LLMRunResult:
+        """Execute the function-call loop and return the final assistant response."""
+        if not ctx.text:
+            return LLMRunResult(handled=False)
+
+        chat_model = getattr(ctx, "chat", None)
+        if not chat_model and ctx.robot:
+            chat_model = getattr(ctx.robot, "chat", None)
+
+        if not chat_model:
+            self.logger.error("无可用的AI模型")
+            return LLMRunResult(handled=False, error="no_model")
+
+        try:
+            if hasattr(chat_model, "call_with_functions"):
+                return self._run_native_loop(ctx, chat_model, functions, executor, formatter)
+            return self._run_prompt_loop(ctx, chat_model, functions, executor)
+        except Exception as exc:  # pragma: no cover - safeguard
+            self.logger.error(f"LLM 调用失败: {exc}")
+            return LLMRunResult(handled=False, error=str(exc))
+
+    # ---------------------------------------------------------------------
+    # Native function-call workflow
+    # ---------------------------------------------------------------------
+
+    def _run_native_loop(
+        self,
+        ctx: MessageContext,
+        chat_model: Any,
+        functions: Dict[str, FunctionSpec],
+        executor: Callable[[FunctionSpec, Dict[str, Any]], FunctionResult],
+        formatter: Callable[[FunctionResult], str],
+    ) -> LLMRunResult:
+        openai_functions = self._build_functions_for_openai(functions)
+        messages: List[Dict[str, Any]] = []
+
+        system_prompt = (
+            "You are an assistant that can call tools. "
+            "When you invoke a function, wait for the tool response before replying to the user. "
+            "Only deliver a final answer once you have enough information."
+        )
+        messages.append({"role": "system", "content": system_prompt})
+        messages.append({"role": "user", "content": ctx.text})
+
+        for round_index in range(self.max_function_rounds):
+            response = chat_model.call_with_functions(
+                messages=messages,
+                functions=openai_functions,
+                wxid=ctx.get_receiver(),
+            )
+
+            if not getattr(response, "choices", None):
+                self.logger.warning("函数调用返回空响应")
+                return LLMRunResult(handled=False)
+
+            message = response.choices[0].message
+            assistant_entry = self._convert_assistant_message(message)
+            messages.append(assistant_entry)
+
+            tool_calls = getattr(message, "tool_calls", None) or []
+            if tool_calls:
+                for tool_call in tool_calls:
+                    function_name = tool_call.function.name
+                    if function_name not in functions:
+                        self.logger.warning(f"模型请求未知函数: {function_name}")
+                        tool_content = json.dumps(
+                            {
+                                "handled": False,
+                                "messages": [f"Unknown function: {function_name}"],
+                                "metadata": {"error": "unknown_function"},
+                            },
+                            ensure_ascii=False,
+                        )
+                    else:
+                        try:
+                            arguments = json.loads(tool_call.function.arguments or "{}")
+                        except json.JSONDecodeError:
+                            arguments = {}
+                        spec = functions[function_name]
+                        result = executor(spec, arguments)
+                        tool_content = formatter(result)
+                    messages.append(
+                        {
+                            "role": "tool",
+                            "tool_call_id": tool_call.id,
+                            "content": tool_content,
+                        }
+                    )
+                continue
+
+            # 没有工具调用，认为模型给出了最终回答
+            final_content = message.content or ""
+            return LLMRunResult(handled=True, final_response=final_content)
+
+        self.logger.warning("达到最大函数调用轮数，未得到最终回答")
+        return LLMRunResult(handled=False, error="max_rounds")
+
+    # ---------------------------------------------------------------------
+    # Prompt-based fallback workflow
+    # ---------------------------------------------------------------------
+
+    def _run_prompt_loop(
+        self,
+        ctx: MessageContext,
+        chat_model: Any,
+        functions: Dict[str, FunctionSpec],
+        executor: Callable[[FunctionSpec, Dict[str, Any]], FunctionResult],
+    ) -> LLMRunResult:
+        system_prompt = self._build_prompt_system_text(functions)
+        user_input = f"用户输入：{ctx.text}"
+
+        ai_response = chat_model.get_answer(
+            user_input,
+            wxid=ctx.get_receiver(),
+            system_prompt_override=system_prompt,
+        )
+
+        json_match = re.search(r"\{.*\}", ai_response, re.DOTALL)
+        if not json_match:
+            self.logger.warning(f"提示词模式下无法解析JSON: {ai_response}")
+            return LLMRunResult(handled=False)
+
+        try:
+            decision = json.loads(json_match.group(0))
+        except json.JSONDecodeError as exc:
+            self.logger.error(f"提示词模式 JSON 解析失败: {exc}")
+            return LLMRunResult(handled=False)
+
+        action_type = decision.get("action_type")
+        if action_type == "chat":
+            # 提示词模式下无法获得模型最终回答，交给上层兜底
+            return LLMRunResult(handled=False)
+
+        if action_type != "function":
+            self.logger.warning(f"未知的action_type: {action_type}")
+            return LLMRunResult(handled=False)
+
+        function_name = decision.get("function_name")
+        if function_name not in functions:
+            self.logger.warning(f"未知的功能名 - {function_name}")
+            return LLMRunResult(handled=False)
+
+        arguments = decision.get("arguments", {})
+        result = executor(functions[function_name], arguments)
+        if not result.handled:
+            return LLMRunResult(handled=False)
+
+        return LLMRunResult(handled=True, final_response="\n".join(result.messages))
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _convert_assistant_message(message: Any) -> Dict[str, Any]:
+        entry: Dict[str, Any] = {
+            "role": "assistant",
+            "content": message.content,
+        }
+        tool_calls = getattr(message, "tool_calls", None)
+        if tool_calls:
+            entry["tool_calls"] = []
+            for tool_call in tool_calls:
+                entry["tool_calls"].append(
+                    {
+                        "id": tool_call.id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_call.function.name,
+                            "arguments": tool_call.function.arguments,
+                        },
+                    }
+                )
+        return entry
+
+    @staticmethod
+    def _build_functions_for_openai(functions: Dict[str, FunctionSpec]) -> List[Dict[str, Any]]:
+        openai_functions = []
+        for spec in functions.values():
+            openai_functions.append(
+                {
+                    "name": spec.name,
+                    "description": spec.description,
+                    "parameters": spec.parameters_schema,
+                }
+            )
+        return openai_functions
+
+    @staticmethod
+    def _build_prompt_system_text(functions: Dict[str, FunctionSpec]) -> str:
+        prompt = """你是一个智能路由助手。根据用户输入判断是否需要调用以下函数之一。"""
+        for spec in functions.values():
+            prompt += f"\n- {spec.name}: {spec.description}"
+        prompt += """
+请严格输出JSON：{"action_type": "chat"} 或 {"action_type": "function", "function_name": "...", "arguments": {...}}
+"""
+        return prompt
+
+    def validate_arguments(self, arguments: Dict[str, Any], schema: Dict[str, Any]) -> bool:
+        try:
+            required_fields = schema.get("required", [])
+            properties = schema.get("properties", {})
+
+            for field in required_fields:
+                if field not in arguments:
+                    self.logger.warning(f"缺少必需参数: {field}")
+                    return False
+
+            for field, value in arguments.items():
+                if field not in properties:
+                    continue
+                expected_type = properties[field].get("type")
+                if expected_type == "string" and not isinstance(value, str):
+                    self.logger.warning(f"参数 {field} 类型不正确，期望 string，得到 {type(value)}")
+                    return False
+                if expected_type == "integer" and not isinstance(value, int):
+                    self.logger.warning(f"参数 {field} 类型不正确，期望 integer，得到 {type(value)}")
+                    return False
+                if expected_type == "number" and not isinstance(value, (int, float)):
+                    self.logger.warning(f"参数 {field} 类型不正确，期望 number，得到 {type(value)}")
+                    return False
+            return True
+        except Exception as exc:
+            self.logger.error(f"参数验证失败: {exc}")
+            return False