构建跨平台AI Agent：多API集成与工具调用设计模式

AGI大模型与大数据研究院

166人浏览 · 2026-06-06 23:04:52

AGI大模型与大数据研究院 · 2026-06-06 23:04:52 发布

从0到1构建跨平台AI Agent：多API集成与工具调用设计模式实战指南

关键词

AI Agent、工具调用、多API集成、设计模式、跨平台、Function Calling、LLM应用开发

摘要

随着大语言模型(LLM)的普及，AI Agent已经成为下一代应用的核心载体，但当前绝大多数Agent开发都存在耦合度高、适配成本高、可维护性差的问题：切换LLM后端要重写一半代码、新增工具要改核心逻辑、对接微信/飞书/企业微信等多平台要做大量重复开发。本文将从核心概念解析、设计模式选型、技术原理实现、实战项目落地四个维度，系统讲解如何构建生产级跨平台AI Agent，通过适配器、策略、工厂、责任链等经典设计模式解耦平台、LLM、工具三层依赖，实现“一次开发，多端运行，多LLM兼容，工具插拔式扩展”的目标。全文包含10+可运行代码片段、5张架构流程图、3组核心对比表格，读完即可独立搭建支持多API集成的跨平台AI Agent系统。

1. 背景介绍

1.1 问题背景

2023年OpenAI推出Function Calling功能之后，AI Agent从概念落地到工业级应用的速度远超行业预期：从智能客服、个人助理到自动化运维、企业内部AI助手，几乎所有LLM应用都在往“具备工具调用能力的Agent”方向演进。但快速发展的背后，开发者面临的痛点也越来越突出：

多LLM适配成本极高：OpenAI、Anthropic Claude、百度文心一言、阿里通义千问等不同厂商的Function Calling格式完全不兼容，切换LLM后端往往要修改上千行代码，部分中小团队甚至因为适配成本问题被迫锁定单一LLM供应商，面临供应商涨价、服务不可用的风险。
工具管理混乱：很多团队的工具调用逻辑硬编码在业务代码里，新增一个工具要修改LLM提示词、参数校验、调用逻辑等多个模块，稍有不慎就会引入BUG，工具权限控制、调用监控更是无从谈起。
多API集成可靠性差：第三方API超时、限流、报错是常态，绝大多数开发者没有完善的重试、降级、熔断机制，一次API故障就会导致整个Agent服务不可用。
跨平台适配重复劳动：同一个Agent要对接Web端、微信小程序、飞书、企业微信等多个入口时，每个平台的消息格式、文件上传下载、回调逻辑都不一样，开发者要重复写多套适配代码，维护成本呈线性增长。

我们曾服务过一家电商客户，他们最初用OpenAI GPT-3.5做了一个Web端智能客服，集成了订单查询、快递查询两个工具，开发只用了2周。但后续要对接飞书端、新增工单创建工具、切换部分流量到文心一言降低成本，前前后后改了1个半月，还出现了3次线上故障，核心原因就是没有做解耦设计，所有逻辑耦合在一起，牵一发而动全身。

1.2 目标读者

本文适合以下人群阅读：

LLM应用开发者、AI Agent工程师，希望提升Agent系统的可维护性和扩展性
技术架构师，需要设计生产级多LLM、多工具、多平台的AI Agent系统
AI产品经理，希望了解AI Agent的技术边界和实现成本
计算机相关专业学生，希望入门AI Agent开发

1.3 核心挑战

构建跨平台AI Agent的核心挑战可以总结为“三个解耦”：

平台层与核心逻辑解耦：不管用户从哪个平台（飞书/企业微信/Web）进来，核心的Agent逻辑完全不用修改
LLM层与核心逻辑解耦：不管用哪个厂商的LLM（OpenAI/文心一言/Claude），工具调用的逻辑完全复用
工具层与核心逻辑解耦：新增/删除工具不需要修改核心逻辑，实现插拔式扩展

2. 核心概念解析

我们可以把跨平台AI Agent类比为一个全能私人助理，所有概念都可以用生活中的例子对应：

技术概念	生活化比喻	核心作用
AI Agent	全能私人助理	接收用户需求，自主决策用什么工具完成需求，最终给用户返回结果
工具调用（Function Calling）	助理会用手机、计算器、订票APP等工具	弥补LLM原生能力不足（实时信息获取、复杂计算、操作外部系统）
多API集成	助理能对接国航/东航/携程/美团等不同服务商的服务	扩展Agent的能力边界
跨平台适配	助理既能在微信上为你服务，也能在飞书、OA系统里为你服务	一次开发，多端运行
设计模式	培训助理的标准化工作流程	不管换哪个助理、加什么新工具、换什么服务场景，都能快速上手，不用重新培训

2.1 概念结构与核心要素组成

生产级跨平台AI Agent由5个核心层级组成：

感知层：负责对接各个平台的消息入口，将不同平台的消息格式统一转换成内部标准格式
大脑层：是Agent的核心，负责推理用户需求、决策是否需要调用工具、选择合适的工具、根据工具返回结果生成最终回答
记忆层：存储会话上下文、用户历史行为、用户画像等信息，让Agent具备上下文理解能力
工具层：集成各类API接口，包括内部业务API、第三方服务API、AI能力API等，是Agent能力的延伸
执行层：负责工具调用的参数校验、权限控制、重试、降级等逻辑，保证工具调用的可靠性

2.2 概念之间的关系

2.2.1 核心属性维度对比

首先我们对比主流LLM的工具调用规范差异，这是多LLM适配需要解决的核心问题：

LLM厂商	工具调用参数名称	工具描述格式	支持最大工具数	并行调用支持	流式调用支持
OpenAI	`function_call`	JSON Schema	128	支持	支持
Anthropic Claude	`tool_use`	JSON Schema	64	支持	支持
百度文心一言	`function_call`	JSON Schema	32	支持	支持
阿里通义千问	`functions`	JSON Schema	32	支持	支持
谷歌Gemini	`function_call`	JSON Schema	64	支持	支持

2.2.2 实体关系ER图

跨平台AI Agent的核心实体及关系如下：

2.2.3 交互关系流程图

用户请求到响应的完整交互流程如下：

3. 技术原理与实现

3.1 核心设计模式选型

我们用5种经典设计模式解决“三个解耦”的核心挑战：

设计模式	解决的问题	类比
适配器模式（Adapter）	解决多LLM、多平台的格式不兼容问题	出国旅游用的转换头，不用换充电器也不用换插座，就能在不同标准的插座上充电
策略模式（Strategy）	解决工具调度策略动态切换的问题	打车时可以选快车、专车、顺风车，根据需求动态选择，不用改打车的核心流程
工厂模式（Factory）	解决工具实例统一创建的问题	奶茶店的操作台，不管做什么奶茶，都用统一的流程调配，不用每次都重新准备工具
责任链模式（Chain of Responsibility）	解决工具调用的多层校验问题	公司的审批流程，请假申请依次经过部门经理、HR、行政，有一个不通过就直接返回
观察者模式（Observer）	解决可观测性的问题	小区的安保系统，有人闯门的时候自动通知保安、业主、物业，不用每个地方都装报警器

3.2 数学模型

3.2.1 工具选择概率模型

LLM选择工具的核心逻辑是基于匹配度的Softmax计算：
$P(t_i|Q,C,T) = \frac{exp(s(Q,C,t_i))}{\sum_{j=1}^n exp(s(Q,C,t_j))}$
其中：

$Q$ 是用户当前查询
$C$ 是历史会话上下文
$T = \{t_1, t_2, ..., t_n\}$ 是可用工具集合
$s(Q,C,t_i)$ 是LLM计算的工具 $t_i$ 与当前需求的匹配度得分
$P(t_i|Q,C,T)$ 是选择工具 $t_i$ 的概率，通常会设置一个阈值（比如0.7），只有概率超过阈值的工具才会被调用

3.2.2 工具调用收益模型

Agent会选择期望收益最高的工具组合：
$E(t_i) = P(t_i) * R(t_i) - C(t_i)$
其中：

$R(t_i)$ 是调用工具 $t_i$ 获得的信息增益，取值范围0~1
$C(t_i)$ 是调用工具的成本，包括Token成本、API调用成本、时间成本
Agent会选择 $E(t_i) > 0$ 的工具，优先选择 $E(t_i)$ 最高的工具

3.2.3 指数退避重试模型

API调用失败时采用指数退避重试，避免触发API限流：
$W_n = min(C, R * 2^n)$
其中：

$W_n$ 是第 $n$ 次重试的等待时间（毫秒）
$C$ 是最大等待时间，通常设置为10000毫秒
$R$ 是初始等待时间，通常设置为1000毫秒
$n$ 是重试次数，最大重试次数通常设置为3次

3.3 算法流程图

完整的工具调用流程如下：

3.4 核心代码实现

3.4.1 LLM适配器实现

首先定义LLM适配器基类，所有LLM提供商的适配器都实现这个统一接口：

from abc import ABC, abstractmethod
from typing import List, Dict, Any, Optional

class BaseLLMAdapter(ABC):
    """LLM适配器基类，所有LLM提供商的适配器都要实现这个接口"""
    
    @abstractmethod
    def __init__(self, api_key: str, api_endpoint: Optional[str] = None, **kwargs):
        """初始化适配器，传入API密钥和endpoint等配置"""
        pass
    
    @abstractmethod
    def format_tools(self, tools: List[Dict[str, Any]]) -> Any:
        """将内部统一的工具格式转换成对应LLM要求的工具格式"""
        pass
    
    @abstractmethod
    def parse_tool_call(self, llm_response: Any) -> List[Dict[str, Any]]:
        """将LLM返回的工具调用结果转换成内部统一的格式"""
        pass
    
    @abstractmethod
    def chat(self, messages: List[Dict[str, str]], tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> Dict[str, Any]:
        """统一的聊天接口，返回统一格式的结果，包括是否需要调用工具"""
        pass

OpenAI适配器实现：

import openai
from typing import List, Dict, Any, Optional

class OpenAIAdapter(BaseLLMAdapter):
    def __init__(self, api_key: str, api_endpoint: Optional[str] = None, model: str = "gpt-3.5-turbo-0125", **kwargs):
        self.client = openai.OpenAI(api_key=api_key, base_url=api_endpoint)
        self.model = model
    
    def format_tools(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """内部工具格式转OpenAI的Function Calling格式"""
        formatted_tools = []
        for tool in tools:
            formatted_tool = {
                "type": "function",
                "function": {
                    "name": tool["name"],
                    "description": tool["description"],
                    "parameters": tool["parameters"]
                }
            }
            formatted_tools.append(formatted_tool)
        return formatted_tools
    
    def parse_tool_call(self, llm_response: Any) -> List[Dict[str, Any]]:
        """OpenAI返回的工具调用转内部格式"""
        tool_calls = []
        if llm_response.choices[0].message.tool_calls:
            for tc in llm_response.choices[0].message.tool_calls:
                tool_calls.append({
                    "id": tc.id,
                    "tool_name": tc.function.name,
                    "parameters": eval(tc.function.arguments), # 生产环境请用json.loads
                    "provider": "openai"
                })
        return tool_calls
    
    def chat(self, messages: List[Dict[str, str]], tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> Dict[str, Any]:
        formatted_tools = self.format_tools(tools) if tools else None
        response = self.client.chat.completions.create(
            model=self.model,
            messages=messages,
            tools=formatted_tools,
            **kwargs
        )
        tool_calls = self.parse_tool_call(response)
        return {
            "content": response.choices[0].message.content,
            "tool_calls": tool_calls,
            "usage": response.usage.dict(),
            "raw_response": response
        }

文心一言适配器实现：

import erniebot
from typing import List, Dict, Any, Optional

class ErnieAdapter(BaseLLMAdapter):
    def __init__(self, api_key: str, api_endpoint: Optional[str] = None, model: str = "ernie-3.5", **kwargs):
        erniebot.api_type = "aistudio"
        erniebot.access_token = api_key
        self.model = model
    
    def format_tools(self, tools: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """内部工具格式转文心一言的工具格式"""
        formatted_tools = []
        for tool in tools:
            formatted_tool = {
                "name": tool["name"],
                "description": tool["description"],
                "parameters": tool["parameters"]
            }
            formatted_tools.append(formatted_tool)
        return formatted_tools
    
    def parse_tool_call(self, llm_response: Any) -> List[Dict[str, Any]]:
        """文心一言返回的工具调用转内部格式"""
        tool_calls = []
        if hasattr(llm_response, "function_call"):
            fc = llm_response.function_call
            tool_calls.append({
                "id": f"ernie_{hash(fc.name + str(fc.arguments))}",
                "tool_name": fc["name"],
                "parameters": fc["arguments"],
                "provider": "ernie"
            })
        return tool_calls
    
    def chat(self, messages: List[Dict[str, str]], tools: Optional[List[Dict[str, Any]]] = None, **kwargs) -> Dict[str, Any]:
        formatted_tools = self.format_tools(tools) if tools else None
        response = erniebot.ChatCompletion.create(
            model=self.model,
            messages=messages,
            functions=formatted_tools,
            **kwargs
        )
        tool_calls = self.parse_tool_call(response)
        return {
            "content": response.result,
            "tool_calls": tool_calls,
            "usage": response.usage,
            "raw_response": response
        }

3.4.2 工具基类与工厂实现

定义工具基类，所有工具都实现这个接口：

from abc import ABC, abstractmethod
from typing import Dict, Any
import requests
import json

class BaseTool(ABC):
    """工具基类，所有工具都要实现这个接口"""
    name: str
    description: str
    parameters: Dict[str, Any]
    timeout: int = 10000
    max_retry: int = 3
    
    @abstractmethod
    def __init__(self, config: Dict[str, Any]):
        """初始化工具，传入配置比如API密钥"""
        pass
    
    @abstractmethod
    def run(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
        """执行工具调用，传入参数，返回结果"""
        pass

天气工具实现：

class WeatherTool(BaseTool):
    name = "query_weather"
    description = "查询指定城市指定日期的天气信息，包括气温、降水、风力等，仅当用户明确询问天气时调用"
    parameters = {
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "要查询的城市名称，比如北京、上海"
            },
            "date": {
                "type": "string",
                "description": "要查询的日期，格式为YYYY-MM-DD，默认为当天"
            }
        },
        "required": ["city"]
    }
    
    def __init__(self, config: Dict[str, Any]):
        self.api_key = config["weather_api_key"]
        self.api_endpoint = "https://api.seniverse.com/v3/weather/daily.json"
    
    def run(self, parameters: Dict[str, Any]) -> Dict[str, Any]:
        city = parameters["city"]
        date = parameters.get("date", "")
        params = {
            "key": self.api_key,
            "location": city,
            "start": date if date else 0,
            "days": 1
        }
        try:
            response = requests.get(self.api_endpoint, params=params, timeout=self.timeout/1000)
            response.raise_for_status()
            data = response.json()
            if data["code"] != "200":
                return {"success": False, "error": data["message"]}
            weather_info = data["results"][0]["daily"][0]
            return {
                "success": True,
                "data": {
                    "city": city,
                    "date": weather_info["date"],
                    "high_temperature": weather_info["high"],
                    "low_temperature": weather_info["low"],
                    "weather": weather_info["text_day"],
                    "wind_direction": weather_info["wind_direction"],
                    "wind_speed": weather_info["wind_speed"]
                }
            }
        except Exception as e:
            return {"success": False, "error": str(e)}

工具工厂实现：

from typing import Dict, Type, List

class ToolFactory:
    """工具工厂，用来创建工具实例"""
    _tool_map: Dict[str, Type[BaseTool]] = {}
    
    @classmethod
    def register_tool(cls, tool_class: Type[BaseTool]):
        """注册工具"""
        cls._tool_map[tool_class.name] = tool_class
    
    @classmethod
    def get_tool(cls, tool_name: str, config: Dict[str, Any]) -> BaseTool:
        """根据工具名称获取工具实例"""
        if tool_name not in cls._tool_map:
            raise ValueError(f"工具{tool_name}未注册")
        return cls._tool_map[tool_name](config)
    
    @classmethod
    def get_available_tools(cls) -> List[Dict[str, Any]]:
        """获取所有可用工具的描述，传给LLM"""
        tools = []
        for tool_name, tool_class in cls._tool_map.items():
            tools.append({
                "name": tool_class.name,
                "description": tool_class.description,
                "parameters": tool_class.parameters
            })
        return tools

# 注册工具，新增工具只要在这里注册即可，无需修改其他代码
ToolFactory.register_tool(WeatherTool)

4. 实际应用：跨平台智能客服Agent实战

我们基于上述设计模式，实现一个支持飞书、企业微信、Web端三个平台，集成天气查询、订单查询、快递查询、工单创建四个工具，对接OpenAI和文心一言两个LLM的智能客服Agent。

4.1 项目介绍

项目名称：SmartCustomerService
核心功能：

多平台消息统一接入
多LLM动态切换与fallback
工具插拔式扩展
细粒度权限控制
全链路调用监控与日志
会话记忆与上下文管理

4.2 环境安装

# 环境要求 Python 3.10+
pip install fastapi uvicorn openai erniebot redis pydantic requests tenacity pybreaker python-multipart

requirements.txt：

fastapi==0.109.2
uvicorn==0.27.1
openai==1.12.0
erniebot==0.5.2
redis==5.0.1
pydantic==2.6.1
requests==2.31.0
tenacity==8.2.3
pybreaker==1.0.0
python-multipart==0.0.7

4.3 系统架构设计

4.4 系统接口设计

4.4.1 聊天接口

接口地址：POST /api/v1/chat
请求参数：

{
  "session_id": "sess_123456",
  "user_id": "user_7890",
  "platform": "feishu",
  "content": "明天北京天气怎么样？",
  "llm_config": {
    "provider": "openai",
    "model": "gpt-3.5-turbo"
  },
  "allowed_tools": ["query_weather", "query_order"]
}

返回参数：

{
  "code": 0,
  "message": "success",
  "data": {
    "session_id": "sess_123456",
    "content": "明天北京的天气是晴，气温18~28℃，西北风3级，适合出行哦~",
    "tool_calls": [
      {
        "tool_name": "query_weather",
        "parameters": {"city": "北京", "date": "2024-06-20"},
        "success": true,
        "cost_time": 234
      }
    ],
    "usage": {
      "prompt_tokens": 560,
      "completion_tokens": 120,
      "total_tokens": 680
    }
  }
}

4.5 核心实现代码

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Dict, Optional, Any
import redis
import json
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
import pybreaker

app = FastAPI(title="跨平台智能客服Agent", version="1.0.0")

# 初始化Redis（会话存储）
redis_client = redis.Redis(host="localhost", port=6379, db=0, decode_responses=True)

# 初始化熔断器
circuit_breaker = pybreaker.CircuitBreaker(fail_max=5, reset_timeout=30)

# 初始化LLM适配器池
LLM_ADAPTERS = {
    "openai": OpenAIAdapter(api_key="your-openai-api-key"),
    "ernie": ErnieAdapter(api_key="your-ernie-api-key")
}

# 工具配置
TOOL_CONFIG = {
    "weather_api_key": "your-seniverse-api-key"
}

class ChatRequest(BaseModel):
    session_id: str
    user_id: str
    platform: str
    content: str
    llm_config: Dict[str, str]
    allowed_tools: List[str]

class ChatResponse(BaseModel):
    session_id: str
    content: str
    tool_calls: List[Dict[str, Any]]
    usage: Dict[str, int]

@app.post("/api/v1/chat", response_model=ChatResponse)
async def chat(request: ChatRequest):
    # 1. 加载会话上下文
    session_key = f"session:{request.session_id}"
    session_context = redis_client.get(session_key)
    messages = json.loads(session_context) if session_context else []
    messages.append({"role": "user", "content": request.content})
    
    # 2. 过滤允许使用的工具
    available_tools = [t for t in ToolFactory.get_available_tools() if t["name"] in request.allowed_tools]
    
    # 3. 调用LLM
    llm_adapter = LLM_ADAPTERS.get(request.llm_config["provider"])
    if not llm_adapter:
        raise HTTPException(status_code=400, detail="不支持的LLM提供商")
    
    response = llm_adapter.chat(
        messages=messages,
        tools=available_tools,
        model=request.llm_config["model"]
    )
    
    tool_calls = []
    # 4. 处理工具调用
    while response["tool_calls"]:
        for tc in response["tool_calls"]:
            tool_name = tc["tool_name"]
            parameters = tc["parameters"]
            try:
                # 校验工具权限
                if tool_name not in request.allowed_tools:
                    result = {"success": False, "error": "无权限使用该工具"}
                else:
                    # 获取工具实例
                    tool = ToolFactory.get_tool(tool_name, TOOL_CONFIG)
                    # 调用工具（带重试和熔断）
                    @retry(
                        stop=stop_after_attempt(tool.max_retry),
                        wait=wait_exponential(multiplier=1, min=1, max=10),
                        retry=retry_if_exception_type((requests.exceptions.RequestException,))
                    )
                    @circuit_breaker
                    def run_tool():
                        return tool.run(parameters)
                    
                    result = run_tool()
                tool_calls.append({
                    "tool_name": tool_name,
                    "parameters": parameters,
                    "success": result["success"],
                    "cost_time": 0 # 实际生产环境统计耗时
                })
                # 将工具结果加入上下文
                messages.append({
                    "role": "function",
                    "name": tool_name,
                    "content": json.dumps(result, ensure_ascii=False)
                })
            except Exception as e:
                tool_calls.append({
                    "tool_name": tool_name,
                    "parameters": parameters,
                    "success": False,
                    "error": str(e)
                })
                messages.append({
                    "role": "function",
                    "name": tool_name,
                    "content": json.dumps({"success": False, "error": str(e)}, ensure_ascii=False)
                })
        # 再次调用LLM生成回答
        response = llm_adapter.chat(messages=messages, tools=available_tools)
    
    # 5. 保存会话上下文
    messages.append({"role": "assistant", "content": response["content"]})
    redis_client.setex(session_key, 3600*24, json.dumps(messages, ensure_ascii=False))
    
    return ChatResponse(
        session_id=request.session_id,
        content=response["content"],
        tool_calls=tool_calls,
        usage=response["usage"]
    )

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

4.6 最佳实践Tips

工具描述要精准：工具描述要明确说明使用场景，比如“仅当用户明确询问天气时调用”，避免LLM误调用
参数强校验：用Pydantic定义工具参数的Schema，非法参数直接拦截，不要传给第三方API
敏感工具二次确认：涉及支付、数据删除等敏感操作的工具，必须返回确认卡片给用户，用户确认后再执行调用
LLM fallback机制：主LLM调用失败时自动切换到备用LLM，提高系统可用性
成本控制：设置每个会话的最大工具调用次数、最大Token消耗，避免成本超支
可观测性：所有工具调用、LLM调用都要记录日志，包括耗时、成功率、Token消耗，便于排查问题和成本统计

5. 未来展望

5.1 工具调用发展历史

年份	事件	核心意义
2022年10月	Meta发布ToolFormer论文	奠定工具调用的理论基础，证明LLM可以学会自主调用外部工具
2023年3月	OpenAI推出原生Function Calling	工具调用从学术走向工业应用，开发者可以快速实现具备工具能力的LLM应用
2023年6月	国内主流LLM全部支持Function Calling	多LLM适配需求爆发，跨平台Agent成为行业刚需
2023年9月	OpenAI推出ChatGPT插件商店	工具生态开始形成，第三方工具可以接入主流Agent平台
2024年3月	OpenAI推出GPT-4o，支持多模态并行工具调用	工具调用能力升级，支持同时调用多个工具、处理多模态输入
2024年6月	各大厂相继推出跨平台Agent开发框架	工具调用设计模式标准化，开发门槛进一步降低

5.2 发展趋势

工具自动发现与对接：未来Agent不需要手动注册工具，会自动从工具市场发现需要的工具，自动完成对接，无需开发者介入
多Agent工具共享：不同Agent之间可以共享工具能力，比如销售Agent可以直接调用CRM Agent的工具，不需要重复集成API
端侧工具调用：端侧LLM普及后，Agent可以直接调用端侧的摄像头、通讯录、短信等能力，不需要经过云端，隐私性更好
工具编排自动化：Agent会自动组合多个工具完成复杂任务，比如“帮我安排下周去上海的出差行程”，Agent会自动调用订机票、订酒店、约会议室、发通知等多个工具，自动编排执行顺序