Bump OpenAI version to 2.6.1; improve dependency constrain resolution (#255)

bxyu-nvidia · lbliii · commit 23395ff26915 · 2025-11-03T11:33:30.000-05:00
Signed-off-by: Brian Yu &lt;bxyu@nvidia.com&gt;
diff --git a/nemo_gym/cli.py b/nemo_gym/cli.py
@@ -14,13 +14,11 @@
 import asyncio
 import json
 import shlex
-import subprocess
 import tomllib
 from glob import glob
 from os import environ, makedirs
 from os.path import exists
 from pathlib import Path
-from platform import python_version
 from subprocess import Popen
 from threading import Thread
 from time import sleep
@@ -29,7 +27,7 @@
 import rich
 import uvicorn
 from devtools import pprint
-from omegaconf import DictConfig, OmegaConf, open_dict
+from omegaconf import DictConfig, OmegaConf
 from pydantic import BaseModel, Field
 from tqdm.auto import tqdm
 
@@ -40,6 +38,7 @@
     NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME,
     NEMO_GYM_CONFIG_PATH_ENV_VAR_NAME,
     NEMO_GYM_RESERVED_TOP_LEVEL_KEYS,
+    PYTHON_VERSION_KEY_NAME,
     GlobalConfigDictParserConfig,
     get_global_config_dict,
 )
@@ -52,45 +51,13 @@
 )
 
 
-def _capture_head_server_dependencies(global_config_dict: DictConfig) -> None:  # pragma: no cover
-    """
-    Capture head server dependencies and store it in the global config dict.
-    These dependencies are used as constraints to ensure that other servers use the same dependency versions as the head server.
-    Note: This function will modify the global config dict - update `head_server_deps`
-    """
-
-    try:
-        result = subprocess.run(
-            ["uv", "pip", "freeze", "--exclude-editable"],
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-        head_server_deps = result.stdout
-    except Exception as e:
-        print(f"Warning: Could not capture head server dependencies: {e}")
-        head_server_deps = None
-
-    relevant_head_server_deps_list = []
-    for dep_line in head_server_deps.splitlines():
-        if "ray" in dep_line:
-            # The ray version is very sensitive. The children ray versions must exactly match those of the parent ray.
-            relevant_head_server_deps_list.append(dep_line)
-
-    relevant_head_server_deps = "\n".join(relevant_head_server_deps_list)
-
-    with open_dict(global_config_dict):
-        global_config_dict[HEAD_SERVER_DEPS_KEY_NAME] = relevant_head_server_deps
-
-
-def _setup_env_command(dir_path: Path, head_server_deps: Optional[str] = None) -> str:  # pragma: no cover
+def _setup_env_command(dir_path: Path, global_config_dict: DictConfig) -> str:  # pragma: no cover
     install_cmd = "uv pip install -r requirements.txt"
-    if head_server_deps:
-        install_cmd += f" --constraint <(cat << 'EOF'\n{head_server_deps}\nEOF\n)"
+    head_server_deps = global_config_dict[HEAD_SERVER_DEPS_KEY_NAME]
+    install_cmd += " " + " ".join(head_server_deps)
 
-    head_server_python_version = python_version()
     return f"""cd {dir_path} \\
-    && uv venv --allow-existing --python {head_server_python_version} \\
+    && uv venv --allow-existing --python {global_config_dict[PYTHON_VERSION_KEY_NAME]} \\
     && source .venv/bin/activate \\
     && {install_cmd} \\
    """
@@ -153,10 +120,6 @@ class RunHelper:  # pragma: no cover
     def start(self, global_config_dict_parser_config: GlobalConfigDictParserConfig) -> None:
         global_config_dict = get_global_config_dict(global_config_dict_parser_config=global_config_dict_parser_config)
 
-        # Capture head server dependencies and store in global config dict
-        # Note: This function will modify the global config dict - update `head_server_deps`
-        _capture_head_server_dependencies(global_config_dict)
-
         # Initialize Ray cluster in the main process
         # Note: This function will modify the global config dict - update `ray_head_node_address`
         initialize_ray()
@@ -196,9 +159,7 @@ def start(self, global_config_dict_parser_config: GlobalConfigDictParserConfig)
 
             dir_path = PARENT_DIR / Path(first_key, second_key)
 
-            head_server_deps = global_config_dict.get(HEAD_SERVER_DEPS_KEY_NAME)
-
-            command = f"""{_setup_env_command(dir_path, head_server_deps)} \\
+            command = f"""{_setup_env_command(dir_path, global_config_dict)} \\
     && {NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME}={escaped_config_dict_yaml_str} \\
     {NEMO_GYM_CONFIG_PATH_ENV_VAR_NAME}={shlex.quote(top_level_path)} \\
     python {str(entrypoint_fpath)}"""
@@ -423,17 +384,17 @@ def _validate_data_single(test_config: TestConfig) -> None:  # pragma: no cover
     print(f"The data for {test_config.dir_path} has been successfully validated!")
 
 
-def _test_single(test_config: TestConfig) -> Popen:  # pragma: no cover
+def _test_single(test_config: TestConfig, global_config_dict: DictConfig) -> Popen:  # pragma: no cover
     # Eventually we may want more sophisticated testing here, but this is sufficient for now.
-    command = f"""{_setup_env_command(test_config.dir_path)} && pytest"""
+    command = f"""{_setup_env_command(test_config.dir_path, global_config_dict)} && pytest"""
     return _run_command(command, test_config.dir_path)
 
 
 def test():  # pragma: no cover
-    config_dict = get_global_config_dict()
-    test_config = TestConfig.model_validate(config_dict)
+    global_config_dict = get_global_config_dict()
+    test_config = TestConfig.model_validate(global_config_dict)
 
-    proc = _test_single(test_config)
+    proc = _test_single(test_config, global_config_dict)
     return_code = proc.wait()
     if return_code != 0:
         print(f"You can run detailed tests via `cd {test_config.entrypoint} && source .venv/bin/activate && pytest`.")
@@ -482,7 +443,7 @@ def test_all():  # pragma: no cover
             entrypoint=str(dir_path),
             should_validate_data=True,  # Test all always validates data.
         )
-        proc = _test_single(test_config)
+        proc = _test_single(test_config, global_config_dict)
         return_code = proc.wait()
 
         match return_code:
diff --git a/nemo_gym/global_config.py b/nemo_gym/global_config.py
@@ -13,12 +13,15 @@
 # limitations under the License.
 from os import getenv
 from pathlib import Path
+from platform import python_version
 from socket import socket
 from typing import ClassVar, List, Optional, Tuple, Type
 
 import hydra
 from omegaconf import DictConfig, OmegaConf, open_dict
+from openai import __version__ as openai_version
 from pydantic import BaseModel, ConfigDict, TypeAdapter
+from ray import __version__ as ray_version
 
 from nemo_gym import PARENT_DIR
 from nemo_gym.config_types import (
@@ -37,13 +40,15 @@
 HEAD_SERVER_KEY_NAME = "head_server"
 DISALLOWED_PORTS_KEY_NAME = "disallowed_ports"
 HEAD_SERVER_DEPS_KEY_NAME = "head_server_deps"
+PYTHON_VERSION_KEY_NAME = "python_version"
 NEMO_GYM_RESERVED_TOP_LEVEL_KEYS = [
     CONFIG_PATHS_KEY_NAME,
     ENTRYPOINT_KEY_NAME,
     DEFAULT_HOST_KEY_NAME,
     HEAD_SERVER_KEY_NAME,
     DISALLOWED_PORTS_KEY_NAME,
     HEAD_SERVER_DEPS_KEY_NAME,
+    PYTHON_VERSION_KEY_NAME,
 ]
 
 POLICY_BASE_URL_KEY_NAME = "policy_base_url"
@@ -213,18 +218,28 @@ def parse(self, parse_config: Optional[GlobalConfigDictParserConfig] = None) ->
             server_instance_configs, default_host, initial_disallowed_ports
         )
 
-        # Populate head server defaults
-        if not global_config_dict.get(HEAD_SERVER_KEY_NAME):
-            with open_dict(global_config_dict):
+        with open_dict(global_config_dict):
+            # Populate head server defaults
+            if not global_config_dict.get(HEAD_SERVER_KEY_NAME):
                 global_config_dict[HEAD_SERVER_KEY_NAME] = {
                     "host": default_host,
                     "port": DEFAULT_HEAD_SERVER_PORT,
                 }
 
-        # Store final list of disallowed ports.
-        with open_dict(global_config_dict):
+            # Store final list of disallowed ports.
             global_config_dict[DISALLOWED_PORTS_KEY_NAME] = disallowed_ports
 
+            # Constrain sensitive package versions
+            global_config_dict[HEAD_SERVER_DEPS_KEY_NAME] = [
+                # The ray version is very sensitive. The children ray versions must exactly match those of the parent ray.
+                f"ray=={ray_version}",
+                # OpenAI version is also sensitive since it changes so often and may introduce subtle incompatibilities.
+                f"openai=={openai_version}",
+            ]
+
+            # Constrain python version since ray is sensitive to this.
+            global_config_dict[PYTHON_VERSION_KEY_NAME] = python_version()
+
         return global_config_dict
 
     def parse_no_environment(
diff --git a/pyproject.toml b/pyproject.toml
@@ -72,9 +72,10 @@ dependencies = [
     ########################################
 
     # OpenAI: We leverage OpenAI Responses, Chat Completions, and Completions schemas for Nemo Gym abstractions. It may also be used to directly query endpoints.
-    # Updated Fri Jul 25, 2025 with openai==1.97.1
+    # We specifically upper bound this OpenAI dependency since the version bumps so frequently.
+    # Updated Wed Oct 29, 2025 with openai==2.6.1
     # License: Apache 2.0 https://github.com/openai/openai-python/blob/a8258744cbecf51321587fc870e8920bd2c07809/LICENSE
-    "openai<=1.97.1",
+    "openai<=2.6.1",
 
     # tqdm: Use for progress tracking on batch operations.
     # Updated Fri Jul 25, 2025 with tqdm==4.67.1
diff --git a/responses_api_agents/simple_agent/tests/test_app.py b/responses_api_agents/simple_agent/tests/test_app.py
@@ -154,6 +154,9 @@ async def test_responses(self, monkeypatch: MonkeyPatch) -> None:
             "truncation": None,
             "usage": None,
             "user": None,
+            "conversation": None,
+            "prompt_cache_key": None,
+            "safety_identifier": None,
         }
         assert expected_responses_dict == actual_responses_dict
 
@@ -324,5 +327,8 @@ async def test_responses_continues_on_reasoning_only(self, monkeypatch: MonkeyPa
             "truncation": None,
             "usage": None,
             "user": None,
+            "conversation": None,
+            "prompt_cache_key": None,
+            "safety_identifier": None,
         }
         assert expected_responses_dict == actual_responses_dict
diff --git a/tests/unit_tests/test_global_config.py b/tests/unit_tests/test_global_config.py
@@ -11,6 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+from typing import Dict
 from unittest.mock import MagicMock
 
 from pytest import MonkeyPatch, raises
@@ -30,7 +31,21 @@
 
 
 class TestServerUtils:
+    def _mock_versions_for_testing(self, monkeypatch: MonkeyPatch) -> Dict[str, str]:
+        monkeypatch.setattr(nemo_gym.global_config, "openai_version", "test openai version")
+        monkeypatch.setattr(nemo_gym.global_config, "ray_version", "test ray version")
+
+        python_version_mock = MagicMock(return_value="test python version")
+        monkeypatch.setattr(nemo_gym.global_config, "python_version", python_version_mock)
+
+        return {
+            "head_server_deps": ["ray==test ray version", "openai==test openai version"],
+            "python_version": "test python version",
+        }
+
     def test_get_global_config_dict_sanity(self, monkeypatch: MonkeyPatch) -> None:
+        mock_versions_for_testing = self._mock_versions_for_testing(monkeypatch)
+
         # Clear any lingering env vars.
         monkeypatch.delenv(NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME, raising=False)
         monkeypatch.setattr(nemo_gym.global_config, "_GLOBAL_CONFIG_DICT", None)
@@ -52,7 +67,11 @@ def hydra_main_wrapper(fn):
         monkeypatch.setattr(nemo_gym.global_config.hydra, "main", hydra_main_mock)
 
         global_config_dict = get_global_config_dict()
-        assert {"head_server": {"host": "127.0.0.1", "port": 11000}, "disallowed_ports": [11000]} == global_config_dict
+        assert {
+            "head_server": {"host": "127.0.0.1", "port": 11000},
+            "disallowed_ports": [11000],
+            **mock_versions_for_testing,
+        } == global_config_dict
 
     def test_get_global_config_dict_global_exists(self, monkeypatch: MonkeyPatch) -> None:
         # Clear any lingering env vars.
@@ -70,6 +89,8 @@ def test_get_global_config_dict_global_env_var(self, monkeypatch: MonkeyPatch) -
         assert {"a": 2} == global_config_dict
 
     def test_get_global_config_dict_config_paths_sanity(self, monkeypatch: MonkeyPatch) -> None:
+        mock_versions_for_testing = self._mock_versions_for_testing(monkeypatch)
+
         # Clear any lingering env vars.
         monkeypatch.delenv(NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME, raising=False)
         monkeypatch.setattr(nemo_gym.global_config, "_GLOBAL_CONFIG_DICT", None)
@@ -103,9 +124,12 @@ def hydra_main_wrapper(fn):
             "extra_dot_env_key": 2,
             "head_server": {"host": "127.0.0.1", "port": 11000},
             "disallowed_ports": [11000],
+            **mock_versions_for_testing,
         } == global_config_dict
 
     def test_get_global_config_dict_config_paths_recursive(self, monkeypatch: MonkeyPatch) -> None:
+        mock_versions_for_testing = self._mock_versions_for_testing(monkeypatch)
+
         # Clear any lingering env vars.
         monkeypatch.delenv(NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME, raising=False)
         monkeypatch.setattr(nemo_gym.global_config, "_GLOBAL_CONFIG_DICT", None)
@@ -154,9 +178,12 @@ def omegaconf_load_mock_side_effect(path):
             "recursive_config_path_child_key": 3,
             "head_server": {"host": "127.0.0.1", "port": 11000},
             "disallowed_ports": [11000],
+            **mock_versions_for_testing,
         } == global_config_dict
 
     def test_get_global_config_dict_server_host_port_defaults(self, monkeypatch: MonkeyPatch) -> None:
+        mock_versions_for_testing = self._mock_versions_for_testing(monkeypatch)
+
         # Clear any lingering env vars.
         monkeypatch.delenv(NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME, raising=False)
         monkeypatch.setattr(nemo_gym.global_config, "_GLOBAL_CONFIG_DICT", None)
@@ -195,9 +222,12 @@ def hydra_main_wrapper(fn):
             "c": 2,
             "head_server": {"host": "127.0.0.1", "port": 11000},
             "disallowed_ports": [11000, 12345],
+            **mock_versions_for_testing,
         } == global_config_dict
 
     def test_get_global_config_dict_server_refs_sanity(self, monkeypatch: MonkeyPatch) -> None:
+        mock_versions_for_testing = self._mock_versions_for_testing(monkeypatch)
+
         # Clear any lingering env vars.
         monkeypatch.delenv(NEMO_GYM_CONFIG_DICT_ENV_VAR_NAME, raising=False)
         monkeypatch.setattr(nemo_gym.global_config, "_GLOBAL_CONFIG_DICT", None)
@@ -266,6 +296,7 @@ def hydra_main_wrapper(fn):
             },
             "head_server": {"host": "127.0.0.1", "port": 11000},
             "disallowed_ports": [11000, 12345, 123456],
+            **mock_versions_for_testing,
         } == global_config_dict
 
     def test_get_global_config_dict_server_refs_errors_on_missing(self, monkeypatch: MonkeyPatch) -> None:
diff --git a/uv.lock b/uv.lock
