LLM 工具调用与 Function Calling 工：评审时怎样发现隐性风险

LLM 工具调用与 Function Calling 工：评审时怎样发现隐性风险

1. 拿到了 API 权限，模型却陷入了 Tool Calling 死循环

在大型系统或复杂工作流场景中，当基于 Function Calling 的 Agent 面对格式异常的工具返回值时，若缺乏异常处理，容易陷入死循环调用。例如在节点健康度诊断场景中，若工具返回的 JSON 包含非标准转义字符（如 node-01\n），LLM 在解析失败后可能误判为工具未执行，进而连续发起相同的工具调用请求。

[LLM 发起 Tool Call] ---> [get_cluster_nodes 工具]
       ^                           |
       |                           v
[无限重复调用 120 次] <--- (返回带非法字符的 JSON)

当后端 Handler 未针对 Tool Calling 设立单次 Session 的硬性调用轮次关卡（Limit Gatekeeper）时，模型可能在短时间内频繁重试调用该工具，进而触发上游 API 速率限制，导致 Token 预算耗尽与调用中断。

在普通的文本问答场景中，模型生成格式的微小偏差通常仅影响前端展示；但在 Function Calling 与 Tool Agent 场景下，模型输出的参数需要直接传入底层系统代码或数据库执行。因此，在代码审查（Code Review）中必须对 Tool Calling 的 Schema 契约、防死循环 Hashing 机制以及预算上限配置建立硬性的质量门禁，以规避潜在的隐性风险。

2. Function Calling 安全拦截与质量门禁架构

为了确保 LLM 在执行 Tool Calling 时的安全性与确定性，可在 LLM 响应解析层与底层工具执行层之间部署带有动态 Schema 修正与死循环拦截功能的安全代理。

核心防线在质量门禁中明确了四条审查标准（Review Rules）：

1. Schema 强类型校验与自动修复：模型吐出的 JSON 参数须经由 jsonschema 或 Pydantic 严格校验。面对常见的末尾缺失括号或非标准转义，可以在内存中进行零延迟修复；若修复失败则直接拦截。
2. 基于状态 Hash 的死循环侦测：将 ToolName + ToolArguments 组合计算 SHA256 签名，若在单次 Session 中连续两次生成相同的签名且返回值一致，直接判定为死循环并中断调用。
3. 熔断与硬性预算闸门：单次用户请求引发的 Function Calling 嵌套调用轮次绝对不允许超过设定上限（如 5 次），总 Token 消费不得突破设定的物理阈值。
4. 副作用沙箱隔离：涉及写操作（如数据库 Update/Delete、发送邮件、发布部署）的工具调用，必须具备二次显式确认或只读预览契约。

3. Python Function Calling 安全护栏拦截器代码

下文展示的代码实现了全功能的 Function Calling 安全代理，内置 Schema 校验、死循环检测以及硬性 Token 预算拦截功能。

import hashlib
import json
import logging
from typing import Dict, Any, List, Optional, Callable
from pydantic import BaseModel, Field, ValidationError

logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")

# 1. 定义安全闸门配置与数据契约
class ToolCallPayload(BaseModel):
    call_id: str
    tool_name: str
    arguments: Dict[str, Any]

class FunctionCallingSafetyGatekeeper:
    def __init__(self, max_allowed_rounds: int = 5, max_token_budget: int = 4000):
        self.max_allowed_rounds = max_allowed_rounds
        self.max_token_budget = max_token_budget
        self.call_history_hashes: List[str] = []
        self.current_rounds = 0
        self.consumed_tokens = 0
        self.registered_tools: Dict[str, Callable] = {}

    def register_tool(self, tool_name: str, handler: Callable):
        self.registered_tools[tool_name] = handler

    def _compute_call_hash(self, tool_name: str, args: Dict[str, Any]) -> str:
        """根据工具名与标准化参数字典计算哈希签名"""
        normalized_str = f"{tool_name}:{sorted(args.items())}"
        return hashlib.sha256(normalized_str.encode('utf-8')).hexdigest()[:16]

    def _attempt_json_autofix(self, raw_json_str: str) -> Optional[Dict[str, Any]]:
        """简单的 JSON 自动修复逻辑，防范 LLM 生成常见尾部缺少括号问题"""
        try:
            return json.loads(raw_json_str)
        except json.JSONDecodeError:
            # 尝试补全末尾的括号
            fixed_str = raw_json_str.strip()
            if not fixed_str.endswith("}"):
                fixed_str += "}"
            try:
                logging.warning(f"Successfully auto-fixed raw JSON string: {raw_json_str} -> {fixed_str}")
                return json.loads(fixed_str)
            except Exception:
                return None

    def execute_tool_call_safely(self, raw_call_id: str, tool_name: str, raw_args_str: str, estimated_tokens: int) -> Dict[str, Any]:
        self.current_rounds += 1
        self.consumed_tokens += estimated_tokens

        # 检查 1: 预算闸门
        if self.current_rounds > self.max_allowed_rounds:
            logging.error(f"Gatekeeper Intercept: Exceeded max allowed rounds ({self.max_allowed_rounds})")
            return {"success": False, "error": "HARD_LIMIT_REACHED: Function calling rounds limit exceeded"}

        if self.consumed_tokens > self.max_token_budget:
            logging.error(f"Gatekeeper Intercept: Exceeded max token budget ({self.max_token_budget})")
            return {"success": False, "error": "HARD_LIMIT_REACHED: Token budget exhausted"}

        # 检查 2: JSON 格式校验与自动修复
        parsed_args = self._attempt_json_autofix(raw_args_str)
        if parsed_args is None:
            logging.error(f"Schema Error: Could not parse arguments for Tool [{tool_name}]")
            return {"success": False, "error": "SCHEMA_ERROR: Malformed JSON arguments from LLM"}

        # 检查 3: 死循环 Hashing 侦测
        call_hash = self._compute_call_hash(tool_name, parsed_args)
        if self.call_history_hashes.count(call_hash) >= 2:
            logging.error(f"Loop Detected! Tool [{tool_name}] invoked repeatedly with identical arguments. Hash: {call_hash}")
            return {"success": False, "error": "LOOP_DETECTED: Identical tool call repeated endlessly"}

        self.call_history_hashes.append(call_hash)

        # 检查 4: 工具存在性校验与执行
        handler = self.registered_tools.get(tool_name)
        if not handler:
            return {"success": False, "error": f"NOT_FOUND: Tool [{tool_name}] is not registered in runtime"}

        try:
            logging.info(f"[Round {self.current_rounds}] Executing Tool [{tool_name}] with args: {parsed_args}")
            result = handler(**parsed_args)
            return {"success": True, "result": result}
        except TypeError as te:
            logging.error(f"Execution Signature Mismatch for Tool [{tool_name}]: {te}")
            return {"success": False, "error": f"SIGNATURE_MISMATCH: {te}"}
        except Exception as e:
            logging.error(f"Tool Execution Exception [{tool_name}]: {e}")
            return {"success": False, "error": f"RUNTIME_EXCEPTION: {str(e)}"}

# 测试运行
if __name__ == "__main__":
    gatekeeper = FunctionCallingSafetyGatekeeper(max_allowed_rounds=4, max_token_budget=2000)

    # 注册实际 Tool 函数
    def get_cluster_status(cluster_name: str) -> str:
        return f"Cluster [{cluster_name}]: 12 Nodes Healthy, 0 Degraded"

    gatekeeper.register_tool("get_cluster_status", get_cluster_status)

    print("--- 场景 1: 正常 Tool Calling 执行 ---")
    res1 = gatekeeper.execute_tool_call_safely(
        raw_call_id="call_001",
        tool_name="get_cluster_status",
        raw_args_str='{"cluster_name": "prod-us-east"}',
        estimated_tokens=300
    )
    print("Result 1:", res1)

    print("\n--- 场景 2: 畸形 JSON 自动修复并成功执行 ---")
    res2 = gatekeeper.execute_tool_call_safely(
        raw_call_id="call_002",
        tool_name="get_cluster_status",
        raw_args_str='{"cluster_name": "prod-asia-south"', # 缺右括号
        estimated_tokens=250
    )
    print("Result 2:", res2)

    print("\n--- 场景 3: 重复触发死循环拦截器 ---")
    # 第一次重复
    gatekeeper.execute_tool_call_safely("call_003", "get_cluster_status", '{"cluster_name": "prod-us-east"}', 200)
    # 第二次重复 -> 应该触发死循环拦截
    res3 = gatekeeper.execute_tool_call_safely("call_004", "get_cluster_status", '{"cluster_name": "prod-us-east"}', 200)
    print("Result 3:", res3)

4. Code Review 清单与落地 Trade-offs

在审查涉及 Function Calling 的 Pull Request 时，需要关注其动态调用的边界限制与容错防线。

在代码审查门禁中严格把关，通过确定性的 Python 代理拦截器约束 LLM Function Calling 的执行流程，能够保障 Agent 系统在拥有工具调用灵活性同时，具备工业级的稳定性底线。

5. 写操作要把确认放在服务端

模型给出的 tool_name 和参数只是一份候选意图，不能直接成为写库、发消息或变更配置的授权。服务端应根据当前用户、资源范围和工具白名单重新构造请求；需要二次确认的动作由业务接口保存确认状态，而不是依赖提示词里的“已确认”。审计日志记录调用者、参数摘要、授权结果和执行结果即可，不应把完整敏感内容写入日志。评审时可专门准备越权资源、重复提交和参数中夹带无关字段的用例，验证代理会拒绝而不是悄悄忽略。