async def generate_tool_call_chunks(
        tool_calls: list,
        answer_id: str,
        created: int,
        model: str,
        system_fingerprint: Optional[str] = None,
        finish_reason: str = "tool_calls"
):
    """
    异步生成器，模拟流式发送工具调用数据
    Args:
        tool_calls: 工具调用列表，每个元素应包含：
                    {
                        "id": "call_xxx",
                        "function": {
                            "name": "function_name",
                            "arguments": '{"param1": "value1"}'  # JSON字符串
                        }
                    }
        answer_id: 回答ID
        created: 创建时间戳
        model: 模型名称
        system_fingerprint: 系统指纹
        finish_reason: 完成原因，默认为 "tool_calls"
    """
    # 第一步：流式发送每个工具调用的初始信息和参数
    for idx, tool_call in enumerate(tool_calls):
        tool_id = tool_call.get("id", f"call_{idx}")
        function_name = tool_call["function"]["name"]
        arguments_str = tool_call["function"]["arguments"]

        # 如果 arguments 是 dict，转换为 JSON 字符串
        if isinstance(arguments_str, dict):
            arguments_str = json.dumps(arguments_str, ensure_ascii=False)

        # 发送工具调用的开始 chunk（包含 id 和 function name）
        chunk_start = {
            "id": answer_id,
            "object": "chat.completion.chunk",
            "created": created,
            "model": model,
            "system_fingerprint": system_fingerprint,
            "choices": [{
                "index": 0,
                "delta": {
                    "tool_calls": [{
                        "index": idx,
                        "id": tool_id,
                        "type": "function",
                        "function": {
                            "name": function_name,
                            "arguments": ""  # 开始为空
                        }
                    }]
                },
                "logprobs": None,
                "finish_reason": None
            }]
        }
        yield f"data: {json.dumps(chunk_start, ensure_ascii=False)}\n\n"
        await asyncio.sleep(random.uniform(0.01, 0.03))

        # 第二步：逐个字符流式发送参数
        for char in arguments_str:
            chunk_arg = {
                "id": answer_id,
                "object": "chat.completion.chunk",
                "created": created,
                "model": model,
                "system_fingerprint": system_fingerprint,
                "choices": [{
                    "index": 0,
                    "delta": {
                        "tool_calls": [{
                            "index": idx,
                            "function": {
                                "arguments": char
                            }
                        }]
                    },
                    "logprobs": None,
                    "finish_reason": None
                }]
            }
            yield f"data: {json.dumps(chunk_arg, ensure_ascii=False)}\n\n"
            await asyncio.sleep(random.uniform(0.005, 0.015))

    # 第三步：发送 finish_reason 为 tool_calls 的完成 chunk
    completion_data = {
        "id": answer_id,
        "object": "chat.completion.chunk",
        "created": created,
        "model": model,
        "system_fingerprint": system_fingerprint,
        "choices": [{
            "index": 0,
            "delta": {},
            "logprobs": None,
            "finish_reason": finish_reason  # "tool_calls"
        }]
    }
    yield f"data: {json.dumps(completion_data, ensure_ascii=False)}\n\n"

    # 第四步：发送流结束标记
    yield "data: [DONE]\n\n"

# 首先需要一些必须的全局变量标识状态和一个异步的定时器(长时间得不到tool响应，就重置tools_use)
tools_use = False  # 标识有没有使用过工具，true标识已经调用过工具了
tools_answer = 'no' # 这是单独对tools和问题进行判断的回答， no说明不需要调用工具，对其进行处理

question = None # 不一定需要，最好有一个，方便全局标记用户的问题

async def start_timer():
    """启动定时器"""
    global tools_use
    await asyncio.sleep(30)
    if tools_use:  # 60秒后如果还是True
        tools_use = False
        logger.debug("tools_use 超时未重置，已自动重置为 False")

# 首先要接收存储请求中的tools和tool_choice  根据tool_choice进行处理
tools_json = data.get("tools", None)
tool_choice = data.get("tool_choice", 'Auto')
# 工具选择 我根据openai api文档总结的
    # 默认情况下，模型将决定何时以及使用多少工具。您可以使用 tool_choice 参数强制特定行为。
    #
    # 自动：（默认）调用零个、一个或多个函数。 tool_choice: "auto"
    # 需要：调用一个或多个函数。 tool_choice: "required"
    # 强制函数：精确调用一个特定函数。 tool_choice: {"type": "function", "name": "get_weather"}
    # 允许的工具：将模型可以调用的工具限制为模型可用工具的子集。
    # "tool_choice": {
    #     "type": "allowed_tools",
    #     "mode": "auto",
    #     "tools": [
    #         {"type": "function", "name": "get_weather"},
    #         {"type": "function", "name": "search_docs"}
    #     ]
    # }
    # }
    # None不传递函数
tools_prompt=xxxxx  #还是之前的系统提示词，这提示词偶尔给的json不正常,
                    # 不知道是我的模型问题还是参数或者提示词本身问题
if tools_use is False and tools_json is not None:
    #只有还没调用tool或者有tool情况下才处理
    finish_reason = "tool_calls" # tool的completion里的finish_reason一定要是这个
        if isinstance(tool_choice, dict):
            # 根据tool_choice的不同分别处理
            # 设置tools_json里的工具
            logger.debug('tool_choice is force or allowed_tools')
            if "type" in tool_choice:
                if tool_choice["type"] == "function":
                    # logger.debug('tool_choice is force')
                    force_tools_json = tool_choice
                    force_tools_dict = [force_tools_json]
                    # 强制调用，先调用存起来
                    question = messages[-1]["content"]
                    tools_question = str(force_tools_dict) + messages[-1]["content"]
                    tools_answer, prompt_tokens, completion_tokens, total_tokens, answer_id, system_fingerprint = await tools_chat(
                        tools_prompt, tools_question) # tools_chat根据自己的2api去写,就是用前面的提示词加tool和问题的组合去别的模型
                    if tools_answer != 'no':
                        logger.debug(f"tool_answer {tools_answer}")
                        tools_answer = re.sub(r"^\`\`\`json|^\`\`\`", "", tools_answer) # 偶尔出错,所以我加个正则增强稳定性
                        tool_call = json.loads(tools_answer)
                        tools_list.append(tool_call[0])
                elif tool_choice["type"] == "allowed_tools":
                    logger.debug('tool_choice is allowed_tools')
                    tools_json = tool_choice.get("tools", [])
                else:
                    logger.debug('tool_choice is auto or required')
            else:
                logger.debug(f'tool_choice is {tool_choice}')

# 这样写，会把所有的tool都拿去问，比较浪费时间，后续继续优化，做到和官网api一样按需调用模型
        # 接着处理tool_choice为auto或者require的情况，两者差别很小，更细分等后续优化
        # 转换为OpenAI标准格式  注意一定要是这样的标准格式，前面的提示词生成的是claude风格，不太会改，就写了个转换的
          openai_tool = {
              "id": f"call_{call_id}",
              "type": "function",
              "function": {
                  "name": item.get("name", ""),
                  "arguments": item.get("arguments", "{}")
              }
          }
        tools_list = openai_tools_list
        # 然后发送给客户端，不管是流式还是非流，一定记得finish_reason要是tool_calls
        completion = {
            "id": f"{answer_id}",
            "object": "chat.completion",
            "created": created,
            "model": model,
            "system_fingerprint": system_fingerprint,
            "choices": [{
                "index": 0,
                "message": {
                    "role": "assistant",
                    "tool_calls": tools_list
                },
                "logprobs": None,
                "finish_reason": finish_reason
            }],
            "usage": {
                "prompt_tokens": prompt_tokens,
                "completion_tokens": completion_tokens,
                "total_tokens": total_tokens
            }
        }
# 记得重置tools_use的状态为下一次的tool调用做准备
# 第二次请求的是tools_use是真了
if tools_use is True:
    # 把tool的响应和用户的问题一起打包去问大模型，处理工具响应的时候要注意可能会是文件  图片 音频以及文字这几种
# 最后一种就是和工具没有一点关系的纯文字chat了
# 整体代码结构就是
if tools_use is False and tools_json is not None:
if tools_use is True:
else:

31:    model_type: str = "aimv3"
76:    AutoConfig.register("aimv3", AIMv2Config)
# 原始是aimv2  修改成其他名字即可，两处名字要一样
# 最好指定一下--swap-space 0.5          太大也运行不了

# 我的判断是否需要使用工具的提示词
<system>
      你是一个专业的 AI 助手，擅长使用各种工具解决问题。你将以专业、友好的态度与用户交流，提供准确和有价值的帮助。
      </system>
<persona>

- 专业性：你具备丰富的技术知识和经验
- 思维方式：逻辑清晰，善于分析问题
- 沟通风格：友好、耐心，注重用户体验
- 工作态度：严谨认真，注重细节
  </persona>

<instructions>
  1. 分析用户需求：
     - 仔细理解json格式的工具列表和用户的问题
     - 确定需不需要调用工具,需要调用哪些工具以及调用该工具需要的参数

2. 工具使用规范：
   
   - 每次可调用多个工具，如果没有依赖关系，尽量同时返回全部工具的参数，如果有依赖关系，就依次调用
   - 如果用户明确要求依次调用才依次调用
   - 确保工具调用格式正确，参数完整
3. 回答质量要求：
   
   - 提供清晰、准确、结构化的答案
   - 承认知识限制，不随意猜测或编造
   - 如果需要使用工具,则返回结果必须严格使用json格式,返回结果不能有其他文字,只返回json格式
   - 如果不需要使用工具返回结果不能有其他文字,只返回"no"
     4.举例
     例子一
     用户输入以下内容:
     [
     {
     "type": "function",
     "function": {
     "name": "fd71edc4f65924613b9fd8330e78eb243",
     "description": "获取中国国内的天气预报",
     "parameters": {
     "type": "object",
     "properties": {
     "location": {
     "type": "string",
     "description": "逗号分隔的经纬度信息 (e.g., 116.40,39.90)"
     },
     "days": {
     "type": "string",
     "enum": [
     "now",
     "24h",
     "72h",
     "168h",
     "3d",
     "7d",
     "10d",
     "15d",
     "30d"
     ],
     "description": "预报天数，now为实时天气，24h为24小时预报，72h为72小时预报，168h为168小时预报，3d为3天预报，以此类推"
     }
     }
     }
     }
     }
     ]杭州的天气怎么样?
     你需要返回的内容是:
     [
     {
     "id": "call_M4eYNv6oPaLunpZLe1iWdfiK",
     "function": {
     "name": "fd71edc4f65924613b9fd8330e78eb243",
     "arguments": "{\"days\":\"now\",\"location\":\"121,31\"}"
     },
     "type": "function"
     }
     ]
     }

例子二
用户输入以下内容:
[
{
"type": "function",
"function": {
"name": "fd71edc4f65924613b9fd8330e78eb243",
"description": "获取中国国内的天气预报",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "逗号分隔的经纬度信息 (e.g., 116.40,39.90)"
},
"days": {
"type": "string",
"enum": [
"now",
"24h",
"72h",
"168h",
"3d",
"7d",
"10d",
"15d",
"30d"
],
"description": "预报天数，now为实时天气，24h为24小时预报，72h为72小时预报，168h为168小时预报，3d为3天预报，以此类推"
}
}
}
}
}
]你好
你需要返回的内容是:
no

tools_use = False
tools_answer = 'no'

tools_question = str(tools_json) + messages[-1]["content"] # 缓存用户问题

tools_json = data.get("tools", None) #提取tools参数
# 首先用tools_json和question以及提示词进行新的对话判断是否需要工具
# 需要的话返回的是结构化的调用参数，不需要就返回的no
# 这轮新的对话可以使用2api的模型也可以使用正规的官方api

# 只有tools_answer不是no且tools_use是false时才说需要mcp或者fc且之前没有进行过工具的调用
if tools_answer != 'no' and not tools_use:
    # 需要function call
    # 构造openai api格式的返回
    # 生成created
    current_timestamp = int(time.time())
    created = current_timestamp
    # 下面是告诉客户端需要调用mcp的返回值模板,看了L站n多关于mcp的帖子才知道
    completion = {
        "id": answer_id,
        "object": "chat.completion",
        "created": created,
        "model": model,
        "system_fingerprint": system_fingerprint,
        "choices": [{
            "index": 0,
            "message": {
                "role": "assistant",
                "tool_calls": json.loads(tools_answer) if tools_answer else None,
                "content": None, # 如果有提示词能达到claude使用MCP的思考过程的效果，可以把模拟的思考过程赋值到此处
            },
            "logprobs": None,
            "finish_reason": "tool_call"
        }],
        "usage": {
            "prompt_tokens": prompt_tokens,
            "completion_tokens": completion_tokens,
            "total_tokens": total_tokens
        }
    }
    tools_answer = 'no'  # 重置相关参数，便于下次正确使用



# 判断上下文最后的messages的role角色，如果是tools，说明这是客户端发回来的mcp或者fc调用的结果
elif messages[-1]["role"] == 'tool':

#需要从头到位遍历messages，把tool的role转成user，这样逆向的api才好使用
# tools的结果在content里的第一个的text里面
messages[-1]["content"][0]["text"]


# 同时判断tools_use是不是true,  是说明这就是本次tools的调用结果
if tools_use:
        # 这里需要保证对话的最后一条是用户起初提的问题，不同的逆向api这里的代码不一样比如
        chat_messages["content"] = question
        question = None# 恢复变量和标志位
        tools_use = False