Method execute_tools

src/tools/tool_executor.cpp:68–113

}

std::vector<ToolResult> ToolExecutor::execute_tools(
    const std::vector<ToolCall>& tool_calls,
    const ToolSet& tools,
    const Messages& messages,
    bool parallel,
    const GenerateOptions* options) {
  std::vector<ToolResult> results;
  results.reserve(tool_calls.size());

  if (!parallel) {
    // Execute sequentially
    for (const auto& tool_call : tool_calls) {
      // Call the on_tool_call_start callback if provided
      if (options && options->on_tool_call_start.has_value()) {
        options->on_tool_call_start.value()(tool_call);
      }

      auto result = execute_tool(tool_call, tools, messages);

      // Call the on_tool_call_finish callback if provided
      if (options && options->on_tool_call_finish.has_value()) {
        options->on_tool_call_finish.value()(result);
      }

      results.push_back(result);
    }
  } else {
    // Execute in parallel using futures
    std::vector<std::future<ToolResult>> futures;
    futures.reserve(tool_calls.size());

    for (const auto& tool_call : tool_calls) {
      futures.emplace_back(
          std::async(std::launch::async, [&tool_call, &tools, &messages]() {
            return execute_tool(tool_call, tools, messages);
          }));
    }

    // Collect results
    for (auto& future : futures) {
      results.push_back(future.get());
    }
  }

  return results;
}

std::vector<ToolResult> ToolExecutor::execute_tools_with_options(
    const std::vector<ToolCall>& tool_calls,