传统串行循环：
  LLM思考 ──→ 调用API_A ──→ 等待800ms ──→ LLM思考 ──→ 调用API_B ──→ 等待600ms ──→ ...
  总耗时 = Σ(LLM推理 + 工具延迟)

# OpenAI Parallel Tool Calling 示例
response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages,
    tools=tools,
    # 默认 parallel_tool_calls=True
)

# 单次响应可能包含多个并行调用
for tool_call in response.choices[0].message.tool_calls:
    results.append(execute_tool(tool_call))

# 所有结果一次性喂回模型
messages.append({
    "role": "tool",
    "tool_call_id": tc.id,
    "content": result
})

PASTE架构：
  ┌─────────────┐     ┌──────────────────┐
  │  LLM推理线程 │────→│  工具调用决策      │
  └─────────────┘     └──────────────────┘
         │                    ↑
         │ 部分输出流         │ 预测匹配？
         ↓                    │
  ┌─────────────┐     ┌──────────────────┐
  │  模式预测器   │────→│  推测工具执行     │──→ 结果缓存
  │  (轻量模型)   │     │  (并行发起)       │
  └─────────────┘     └──────────────────┘
         ↑
  历史轨迹模式库

# PASTE 核心推测执行循环（简化版）
class PASTExecutor:
    def __init__(self, llm, tools, pattern_db):
        self.llm = llm
        self.tools = tools
        self.pattern_db = pattern_db  # 模式库
        self.spec_cache = {}          # 推测结果缓存

    async def run_step(self, messages):
        # 1. 启动LLM推理（流式）
        llm_task = asyncio.create_task(
            self.llm.stream(messages)
        )

        # 2. 并行启动推测执行
        predicted = self.pattern_db.predict_next(messages)
        if predicted and predicted.confidence > 0.7:
            spec_task = asyncio.create_task(
                self.tools.execute(predicted.tool_call)
            )
            self.spec_cache[predicted.id] = spec_task

        # 3. 等待LLM完成，检查推测是否命中
        actual_call = await llm_task
        if actual_call.id in self.spec_cache:
            result = await self.spec_cache[actual_call.id]
            # 验证推测参数与实际参数一致性
            if params_match(actual_call, predicted):
                return result  # 命中！零等待
            else:
                return await self.tools.execute(actual_call)  # 未命中
        return await self.tools.execute(actual_call)

# speculative-tools 使用示例
from speculative_tools import SpeculativeExecutor, HistoryPredictor

executor = SpeculativeExecutor(
    predictor=HistoryPredictor(window_size=50),
    sandbox=True,          # 在沙箱中执行推测调用
    max_speculations=3,    # 最多同时推测3个工具调用
    confidence_threshold=0.65
)

# 包装标准工具执行
async def agent_loop(messages, tools):
    for step in range(max_steps):
        # LLM决策与推测执行并行
        decision, spec_results = await executor.step(
            messages=messages,
            tools=tools
        )

        if decision.matches_speculation:
            # 推测命中，使用缓存结果
            messages.append(spec_results[decision.tool_call_id])
        else:
            # 推测未命中，执行实际调用
            result = await tools.execute(decision)
            executor.record(decision, result)  # 反馈给预测器
            messages.append(result)

# ReplyAnt 风格的模板预取
class TemplatePrefetch:
    def __init__(self):
        self.templates = {
            "refund_request": [
                {"tool": "get_order", "args": "{order_id}"},
                {"tool": "check_inventory", "args": "{item_id}"},
                {"tool": "calculate_refund", "args": "{order_id}"},
            ]
        }

    async def prefetch(self, task_type, params):
        """任务开始时，立即预取模板中所有步骤"""
        template = self.templates[task_type]
        prefetch_tasks = []
        for step in template:
            try:
                rendered_args = step["args"].format(**params)
                prefetch_tasks.append(
                    asyncio.create_task(
                        self.tools.call(step["tool"], rendered_args)
                    )
                )
            except KeyError:
                pass  # 参数缺失，跳过
        return await asyncio.gather(*prefetch_tasks, return_exceptions=True)

投机-验证双轨架构：

主轨道（慢但准）：  LLM推理 ──→ 工具A ──→ LLM推理 ──→ 工具B ──→ ...
                        │                                      │
                        │  并行                                 │
                        ↓                                      ↓
投机轨道（快但粗）：  小模型 ──→ 工具A'──→ 小模型 ──→ 工具B'──→ ...
                                    │                    │
                                    └──→ 结果缓存 ←──────┘
                                              │
验证器：  主轨道结果 == 投机轨道结果？  → 是：跳过后续步骤
                                    → 否：回滚到分歧点

graph TB
    subgraph 传统串行
        A1[LLM思考] -->|800ms| B1[调用工具A]
        B1 -->|600ms| C1[LLM思考]
        C1 -->|800ms| D1[调用工具B]
        D1 -->|500ms| E1[LLM思考]
        E1 -->|800ms| F1[调用工具C]
        F1 -->|400ms| G1[完成]
    end

    subgraph 并行调用
        A2[LLM思考] -->|1次推理| B2[工具A + 工具B 并行]
        B2 -->|max 600ms| C2[LLM思考]
        C2 -->|1次推理| D2[工具C]
        D2 --> G2[完成]
    end

    subgraph PASTE推测
        A3[LLM思考] -.->|流式预测| S1[推测:工具A]
        A3 -->|实际决策| V1{匹配?}
        S1 -->|缓存结果| V1
        V1 -->|命中| C3[LLM思考]
        V1 -->|未命中| B3[实际调用A] --> C3
        C3 -.->|流式预测| S2[推测:工具B]
        C3 -->|实际决策| V2{匹配?}
        S2 -->|缓存结果| V2
        V2 -->|命中| G3[完成]
    end

    style A1 fill:#ff9999
    style A2 fill:#99ff99
    style A3 fill:#9999ff

graph TD
    Start[工具调用需要加速] --> Q1{工具间有依赖吗?}
    Q1 -->|无依赖| A1[用模型原生并行调用]
    Q1 -->|有依赖| Q2{工具链模式固定吗?}
    Q2 -->|固定模板| Q3{工具都是读操作吗?}
    Q3 -->|是| A2[模板预取 + 原生并行]
    Q3 -->|有写操作| Q4{写操作可回滚吗?}
    Q4 -->|是| A3[speculative-tools 沙箱模式]
    Q4 -->|否| A4[仅对读操作启用模板预取]
    Q2 -->|不固定| Q5{有历史轨迹数据吗?}
    Q5 -->|有>100条| A5[PASTE 模式挖掘]
    Q5 -->|无| Q6{能接受双倍Token消耗吗?}
    Q6 -->|能| A6[双轨投机架构]
    Q6 -->|不能| A7[先积累轨迹 再启用推测]

    style A1 fill:#90EE90
    style A2 fill:#90EE90
    style A5 fill:#87CEEB
    style A7 fill:#FFD700