ag2 0.9.5__py3-none-any.whl → 0.9.6__py3-none-any.whl

{ag2-0.9.5.dist-info → ag2-0.9.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ag2
-Version: 0.9.5
+Version: 0.9.6
 Summary: A programming framework for agentic AI
 Project-URL: Homepage, https://ag2.ai/
 Project-URL: Documentation, https://docs.ag2.ai

{ag2-0.9.5.dist-info → ag2-0.9.6.dist-info}/RECORD

@@ -8,13 +8,13 @@ autogen/function_utils.py,sha256=YnzwNFA49Jbbe4riAY1sinYcKphg5lrHFCXx0POdYbw,481
 autogen/graph_utils.py,sha256=2dfGUHZCCF629vh0vMK9WMXIX-Zi-if9NbdC0KFcuw4,7904
 autogen/import_utils.py,sha256=byPlexRvu1bkGzEAtwwtJ2SQIm1IzModK9B5ONGkqJw,17634
 autogen/json_utils.py,sha256=_61k__3SS1-ffE2K5Mm9ZGHQJBRUbOL9kHGQGTAWRZk,1378
-autogen/llm_config.py,sha256=eFWSN9yR3w2R7d2CdDQ5ZpU2tUy8xBzEwGuq5K6QZLs,14172
+autogen/llm_config.py,sha256=lQPV3zXbLKL_7rJHi1fJAJn1NpNK7wZtqGUxHeapIZQ,14437
 autogen/math_utils.py,sha256=Ew9-I5chny9eAOnphGxKf6XCeW6Pepz5S-5touWrbYU,9546
 autogen/retrieve_utils.py,sha256=R3Yp5d8dH4o9ayLZrGn4rCjIaY4glOHIiyQjwClmdi8,20087
 autogen/runtime_logging.py,sha256=yCmZODvwqYR91m8lX3Q4SoPcY-DK48NF4m56CP6Om3c,4692
 autogen/token_count_utils.py,sha256=n4wTFVNHwrfjZkrErFr8kNig2K-YCGgMLWsjDRS9D6g,10797
 autogen/types.py,sha256=qu-7eywhakW2AxQ5lYisLLeIg45UoOW-b3ErIuyRTuw,1000
-autogen/version.py,sha256=THVipdL6_RedIuOtoczdX7_iJxpvPiU7gkSD-mvqhIo,193
+autogen/version.py,sha256=Gx2IBExx_OQsL98JzXZ9G56t2UljGjVfvrmaV4UzVp4,193
 autogen/_website/__init__.py,sha256=c8B9TpO07x9neD0zsJWj6AaEdlcP-WvxrvVOGWLtamk,143
 autogen/_website/generate_api_references.py,sha256=yKqyeSP_NE27wwLYWsZbTYRceEoxzNxPXqn6vsIzEvk,14789
 autogen/_website/generate_mkdocs.py,sha256=TkmLnUDv1Ms5cGClXPmenA8nxmwg4kR0E-FHCVjw_og,43246
@@ -212,7 +212,7 @@ autogen/cache/in_memory_cache.py,sha256=qeECs4UnN5FzuCSgiF-Ma11eLGSjJBgGlqLraWhD
 autogen/cache/redis_cache.py,sha256=XqUVObZRbD_kDL5vDD6H6xu_U-xcL8qKmsUq2Ix8xVo,4248
 autogen/coding/__init__.py,sha256=fN8UCm3RzJZ4OFMwlp3a0jic0ZzOege6TNVAk5t6J0U,825
 autogen/coding/base.py,sha256=hj70EwB-b0MVzHXACw-Oj3CiHo-GUC5kGZGniDTMOnw,3801
-autogen/coding/docker_commandline_code_executor.py,sha256=njZM__TUdQyIHdIx2tH4DBtptFzjIrQwyxpt2CJgMGo,9900
+autogen/coding/docker_commandline_code_executor.py,sha256=8sr6bBpk1JtWEb1YQNgmj5z_n2mL_-cAP3EzSrn6SLU,10872
 autogen/coding/factory.py,sha256=bC3kkIBNExAPt8KZvCQ1PsLpyJWLq1jpw1JcvIbKR04,1978
 autogen/coding/func_with_reqs.py,sha256=dPcjRs4gOjoVO3m5cQYWtFm7FKO94gBYPwr3O7gVj7g,6372
 autogen/coding/local_commandline_code_executor.py,sha256=XKkT141IYZf_HngNJjMcJ7uZXe3k056wMdXZC2hfAts,16671
@@ -226,6 +226,12 @@ autogen/coding/jupyter/import_utils.py,sha256=7yzEAYmNmJsODsqz3XCNOORKfvp0t6xnaf
 autogen/coding/jupyter/jupyter_client.py,sha256=ROXAWOKG_EJ_oFNuyqUd_3uOBPUTRoTh6_-8bSpXBdU,8674
 autogen/coding/jupyter/jupyter_code_executor.py,sha256=Z2vZvou6QzpMBg0IgOzVRoCADswd15mvfkktIjGhUMY,6374
 autogen/coding/jupyter/local_jupyter_server.py,sha256=7b8yi5qK8ms2e5-PRCrzmXKGp1iC5KgpMU8xiqQ9u8o,6589
+autogen/environments/__init__.py,sha256=SNh4NFcBgySNW--H1YUZPEf7F7QLpBQA3Qc8EvyM-gk,488
+autogen/environments/docker_python_environment.py,sha256=oKdtr2IN2UDoYi8V_Qjvut5VGfwUNzNoj8J1aMRP9GU,15312
+autogen/environments/python_environment.py,sha256=CXY0h3SWJPYSZtcR_nqY5VmVvGItIJwAnBqSx7YvECg,4265
+autogen/environments/system_python_environment.py,sha256=jk1U4CSDPsF1igqdv-GQOKsH_NTxitRzN35-UWng2e8,3081
+autogen/environments/venv_python_environment.py,sha256=i7dgd8lFuxfZwkysnFXuOn_B26CFYCzNHHBfCtExLkk,10076
+autogen/environments/working_directory.py,sha256=MevUpN1lzmJLEKM_o9JHZod9cy9pQgI5AsE0ic6fvrE,2505
 autogen/events/__init__.py,sha256=XwCA6Rsq9AyjgeecGuiwHcAvDQMmKXgGomw5iLDIU5Q,358
 autogen/events/agent_events.py,sha256=LSCOMwA-nlBSboE5jOh-Da2Pm7hghiwjfzYTz_bS30k,31112
 autogen/events/base_event.py,sha256=5K1wzDBAio9wLxahErSvE0-UbFfMuSTxBp6EI8SbPGU,3475
@@ -281,7 +287,7 @@ autogen/mcp/helpers.py,sha256=J5_J6n3jMJUEJH5K8k9BeUb6ymQgRUI0hC1gbY7rlwM,1533
 autogen/mcp/mcp_client.py,sha256=7c_lHgBJEs77TFYjLcTlVrEu_0z4EafPPY3PgteY87c,7400
 autogen/mcp/mcp_proxy/__init__.py,sha256=3HTU-TqHLk4XSXeBV1UFd9XkQ1B0yOuXXyGseXvDVec,518
 autogen/mcp/mcp_proxy/fastapi_code_generator_helpers.py,sha256=dx-w2tGVMnh8pzY2NuXlMD7oIF7_5Gvc5oSbHIySEpc,2110
-autogen/mcp/mcp_proxy/mcp_proxy.py,sha256=NfjNsUnqpPQ_FrKJPiPUL7aDE9SZ_wNB0ZHAsiJHq9I,22131
+autogen/mcp/mcp_proxy/mcp_proxy.py,sha256=1eWwZatPgPxqkhcbEFCW-ErmkrWUF9F_cLkFWVtLkug,22171
 autogen/mcp/mcp_proxy/operation_grouping.py,sha256=1n4o5qhkQd2hVr7OaOMsRhInDveDGkCozLudsBVusC4,6349
 autogen/mcp/mcp_proxy/operation_renaming.py,sha256=G5J4VdxUAwSvOo-DsqIUbCfV9TnH3riaHLI6IpctDF8,3956
 autogen/mcp/mcp_proxy/patch_fastapi_code_generator.py,sha256=vBr8P890nsFvK4iuFicrdNskooHlBQeTQ6jbb5kcPAk,3490
@@ -296,7 +302,7 @@ autogen/oai/__init__.py,sha256=BIwnV6wtHmKgIM4IUdymfPfpdNqos5P7BfRv-7_QL9A,1680
 autogen/oai/anthropic.py,sha256=AK_Bbcc5I-PqAvoiwB0LaO1ZLugh_wQNAOIFcj7eTtk,29174
 autogen/oai/bedrock.py,sha256=8AYWZVsDkJS2HmQ0ggoUqlKV_a4H_ON8rks4VW2Jrxk,25719
 autogen/oai/cerebras.py,sha256=8hiSBq88l2yTXUJPV7AvGXRCtwvW0Y9hIYUnYK2S2os,12462
-autogen/oai/client.py,sha256=nXPRAiUrO5MoGGK2CjKG8TNKfuJxRCDdGVHKQGKk0H4,66957
+autogen/oai/client.py,sha256=ZJfax-XdV92xfmIvn-qmJhSwjP-MusU4oDc9_88o-1k,68206
 autogen/oai/client_utils.py,sha256=lVbHyff7OnpdM-tXskC23xLdFccj2AalTdWA4DxzxS4,7543
 autogen/oai/cohere.py,sha256=pRcQWjbzKbZ1RfC1vk9WGjgndwjHbIaOVoKEYdV2L6c,19421
 autogen/oai/gemini.py,sha256=bc_RQwtoGi7DnwQwPie7ZdvsqpD1AjYwzjVwnIKP39U,43168
@@ -323,9 +329,11 @@ autogen/tools/toolkit.py,sha256=1tOmTGJ96RhkJrrtAViKUyEcwacA6ztoIbYbnf8NgTU,2558
 autogen/tools/contrib/__init__.py,sha256=DWEjPK6xCR2ihAXXdquQZmiuqRLA3Pqb8QV8W1RtS3k,202
 autogen/tools/contrib/time/__init__.py,sha256=dplie5aBJZ8VoKy6EKcQMLTtSgcCkNDYzpdsC2I0YWk,195
 autogen/tools/contrib/time/time.py,sha256=tPi49vOUwfvujbYA-zS00CWcLW-y18CPyQ1gnJG6iRg,1271
-autogen/tools/experimental/__init__.py,sha256=jGyt9GVoJO6VsZdmBLzwTxXZGBbWEwdLrUjn-rWQ6os,1588
+autogen/tools/experimental/__init__.py,sha256=OPJlrK_tJCPbeBT-qsIWwJBdLuaCMskpshduA8Haj7E,1671
 autogen/tools/experimental/browser_use/__init__.py,sha256=kfxCajXcVMDH6CZq-lWh2p8PKxOwT9yjC_Za0jr4zUg,290
 autogen/tools/experimental/browser_use/browser_use.py,sha256=KfU4MI_BWaHepv0bDMf9HTDUaHTJThuBJI8R_BPpjmg,5561
+autogen/tools/experimental/code_execution/__init__.py,sha256=KFUku2awEgsnkSa48t2iMMPC-QCxpqAG7lb8fB4Fr-c,242
+autogen/tools/experimental/code_execution/python_code_execution.py,sha256=Fj1Wxsn6z0HuXWpqa-ahedkCtyPYBShUnbiyvSw_mus,3705
 autogen/tools/experimental/crawl4ai/__init__.py,sha256=UjFJLSZ9P5xT6WCV0RDPtwt4MHuwPdK90TU7ByXhLWs,207
 autogen/tools/experimental/crawl4ai/crawl4ai.py,sha256=MsOLtbPHRpRrCnRJPQVVVNwmsBcgsWLSHNXDOF-47ws,6088
 autogen/tools/experimental/deep_research/__init__.py,sha256=9SFcDEj2OHxNSlXP11lf1uHENlfUeO47ROcOSD9GCDs,220
@@ -406,8 +414,8 @@ autogen/agentchat/contrib/captainagent/tools/math/modular_inverse_sum.py,sha256=
 autogen/agentchat/contrib/captainagent/tools/math/simplify_mixed_numbers.py,sha256=iqgpFJdyBHPPNCqkehSIbeuV8Rabr2eDMilT23Wx7PI,1687
 autogen/agentchat/contrib/captainagent/tools/math/sum_of_digit_factorials.py,sha256=-6T5r6Er4mONPldRxv3F9tLoE7Og3qmeSeTC7Du_tTg,596
 autogen/agentchat/contrib/captainagent/tools/math/sum_of_primes_below.py,sha256=Xig7K3A3DRnbv-UXfyo5bybGZUQYAQsltthfTYW5eV8,509
-ag2-0.9.5.dist-info/METADATA,sha256=K4Gz-eYvrw_xTPz7UV0WPlKiR5LluSMxvV0PGJZUWpA,35268
-ag2-0.9.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ag2-0.9.5.dist-info/licenses/LICENSE,sha256=GEFQVNayAR-S_rQD5l8hPdgvgyktVdy4Bx5-v90IfRI,11384
-ag2-0.9.5.dist-info/licenses/NOTICE.md,sha256=07iCPQGbth4pQrgkSgZinJGT5nXddkZ6_MGYcBd2oiY,1134
-ag2-0.9.5.dist-info/RECORD,,
+ag2-0.9.6.dist-info/METADATA,sha256=Syw0Wb_vvJEdWJ52b0UjycmcDQj0PJtCt8ZRUa-lLeM,35268
+ag2-0.9.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ag2-0.9.6.dist-info/licenses/LICENSE,sha256=GEFQVNayAR-S_rQD5l8hPdgvgyktVdy4Bx5-v90IfRI,11384
+ag2-0.9.6.dist-info/licenses/NOTICE.md,sha256=07iCPQGbth4pQrgkSgZinJGT5nXddkZ6_MGYcBd2oiY,1134
+ag2-0.9.6.dist-info/RECORD,,

autogen/coding/docker_commandline_code_executor.py

@@ -71,6 +71,8 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
         auto_remove: bool = True,
         stop_container: bool = True,
         execution_policies: Optional[dict[str, bool]] = None,
+        *,
+        container_create_kwargs: Optional[dict[str, Any]] = None,
     ):
         """(Experimental) A code executor class that executes code through
         a command line environment in a Docker container.
@@ -98,6 +100,11 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
                 whether code in that language should be executed. True means code in that language
                 will be executed, False means it will only be saved to a file. This overrides the
                 default execution policies. Defaults to None.
+            container_create_kwargs: Optional dict forwarded verbatim to
+                "docker.client.containers.create". Use it to set advanced Docker
+                options (environment variables, GPU device_requests, port mappings, etc.).
+                Values here override the class defaults when keys collide. Defaults to None.
+
 
         Raises:
             ValueError: On argument error, or if the container fails to start.
@@ -128,16 +135,29 @@ class DockerCommandLineCodeExecutor(CodeExecutor):
         if container_name is None:
             container_name = f"autogen-code-exec-{uuid.uuid4()}"
 
+        # build kwargs for docker.create
+        base_kwargs: dict[str, Any] = {
+            "image": image,
+            "name": container_name,
+            "entrypoint": "/bin/sh",
+            "tty": True,
+            "auto_remove": auto_remove,
+            "volumes": {str(bind_dir.resolve()): {"bind": "/workspace", "mode": "rw"}},
+            "working_dir": "/workspace",
+        }
+
+        if container_create_kwargs:
+            for k in ("entrypoint", "volumes", "working_dir", "tty"):
+                if k in container_create_kwargs:
+                    logging.warning(
+                        "DockerCommandLineCodeExecutor: overriding default %s=%s",
+                        k,
+                        container_create_kwargs[k],
+                    )
+            base_kwargs.update(container_create_kwargs)
+
         # Start a container from the image, read to exec commands later
-        self._container = client.containers.create(
-            image,
-            name=container_name,
-            entrypoint="/bin/sh",
-            tty=True,
-            auto_remove=auto_remove,
-            volumes={str(bind_dir.resolve()): {"bind": "/workspace", "mode": "rw"}},
-            working_dir="/workspace",
-        )
+        self._container = client.containers.create(**base_kwargs)
         self._container.start()
 
         _wait_for_ready(self._container)

autogen/environments/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .docker_python_environment import DockerPythonEnvironment
+from .system_python_environment import SystemPythonEnvironment
+from .venv_python_environment import VenvPythonEnvironment
+from .working_directory import WorkingDirectory
+
+__all__ = ["DockerPythonEnvironment", "SystemPythonEnvironment", "VenvPythonEnvironment", "WorkingDirectory"]

autogen/environments/docker_python_environment.py

@@ -0,0 +1,375 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+import shutil
+import subprocess
+import tempfile
+import uuid
+from typing import Any, Optional, Tuple
+
+from asyncer import asyncify
+
+from .python_environment import PythonEnvironment
+
+__all__ = ["DockerPythonEnvironment"]
+
+
+class DockerPythonEnvironment(PythonEnvironment):
+    """A Python environment using Docker containers for isolated execution."""
+
+    def __init__(
+        self,
+        image: str = "python:3.11-slim",
+        container_name_prefix: str = "ag2_docker_env_",
+        volumes: Optional[dict[str, str]] = None,
+        environment: Optional[dict[str, str]] = None,
+        network: Optional[str] = None,
+        pip_packages: Optional[list[str]] = None,
+        requirements_file: Optional[str] = None,
+        dockerfile: Optional[str] = None,
+        build_args: Optional[dict[str, str]] = None,
+        cleanup_container: bool = True,
+        keep_container_running: bool = False,
+        container_startup_timeout: int = 30,
+    ):
+        """
+        Initialize a Docker Python environment.
+
+        Args:
+            image: Docker image to use (ignored if dockerfile is provided)
+            container_name_prefix: Prefix for container names
+            volumes: Dictionary mapping host paths to container paths for mounting
+            environment: Dictionary of environment variables to set in the container
+            network: Docker network to attach the container to
+            pip_packages: List of pip packages to install in the container
+            requirements_file: Path to requirements.txt file to install in the container
+            dockerfile: Optional path to a Dockerfile to build and use instead of pulling an image
+            build_args: Optional build arguments for the Dockerfile
+            cleanup_container: Whether to remove the container after use
+            keep_container_running: Whether to keep the container running after execution
+            container_startup_timeout: Timeout in seconds for container startup
+        """
+        self.image = image
+        self.container_name_prefix = container_name_prefix
+        self.volumes = volumes or {}
+        self.environment = environment or {}
+        self.network = network
+        self.pip_packages = pip_packages or []
+        self.requirements_file = requirements_file
+        self.dockerfile = dockerfile
+        self.build_args = build_args or {}
+        self.cleanup_container = cleanup_container
+        self.keep_container_running = keep_container_running
+        self.container_startup_timeout = container_startup_timeout
+
+        # Internal state
+        self._container_id = None
+        self._container_name = None
+        self._custom_image_name = None
+        self._temp_dir = None
+
+        super().__init__()
+
+    def _setup_environment(self) -> None:
+        """Set up the Docker environment."""
+        # Verify Docker is installed and accessible
+        try:
+            result = subprocess.run(["docker", "--version"], capture_output=True, text=True, check=True)
+            logging.info(f"Docker version: {result.stdout.strip()}")
+        except (subprocess.SubprocessError, FileNotFoundError) as e:
+            raise RuntimeError(
+                "Docker not found or not accessible. Please ensure Docker is installed and running."
+            ) from e
+
+        # Create a temporary directory for file operations
+        self._temp_dir = tempfile.mkdtemp(prefix="ag2_docker_")
+
+        # Generate a unique container name
+        self._container_name = f"{self.container_name_prefix}{uuid.uuid4().hex[:8]}"
+
+        # Build custom image if Dockerfile is provided
+        if self.dockerfile:
+            self._build_custom_image()
+        else:
+            # Pull the specified image
+            try:
+                subprocess.run(
+                    ["docker", "pull", self.image],
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+                logging.info(f"Pulled Docker image: {self.image}")
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to pull Docker image: {e.stderr}") from e
+
+        # Start the container
+        self._start_container()
+
+    def _build_custom_image(self) -> None:
+        """Build a custom Docker image from the provided Dockerfile."""
+        if not os.path.exists(self.dockerfile):
+            raise RuntimeError(f"Dockerfile not found at: {self.dockerfile}")
+
+        # Create a unique image name
+        self._custom_image_name = f"ag2-custom-python-{uuid.uuid4().hex[:8]}"
+
+        # Build command
+        build_cmd = ["docker", "build", "-t", self._custom_image_name]
+
+        # Add build args
+        for arg_name, arg_value in self.build_args.items():
+            build_cmd.extend(["--build-arg", f"{arg_name}={arg_value}"])
+
+        # Add Dockerfile path
+        build_cmd.extend(["-f", self.dockerfile, os.path.dirname(self.dockerfile)])
+
+        try:
+            logging.info(f"Building custom Docker image: {self._custom_image_name}")
+            _ = subprocess.run(
+                build_cmd,
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            logging.info(f"Built custom Docker image: {self._custom_image_name}")
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to build Docker image: {e.stderr}") from e
+
+        # Use the custom image
+        self.image = self._custom_image_name
+
+    def _start_container(self) -> None:
+        """Start the Docker container."""
+        # Basic container run command
+        run_cmd = ["docker", "run", "--name", self._container_name]
+
+        # Add detached mode flag to run container in background
+        run_cmd.append("-d")
+
+        # Add network if specified
+        if self.network:
+            run_cmd.extend(["--network", self.network])
+
+        # Add environment variables
+        for env_name, env_value in self.environment.items():
+            run_cmd.extend(["-e", f"{env_name}={env_value}"])
+
+        # Add volume mounts including temp directory
+        work_dir_mount = f"{self._temp_dir}:/workspace"
+        run_cmd.extend(["-v", work_dir_mount])
+
+        for host_path, container_path in self.volumes.items():
+            run_cmd.extend(["-v", f"{host_path}:{container_path}"])
+
+        # Set workspace as working directory
+        run_cmd.extend(["-w", "/workspace"])
+
+        # Add tty to keep container running
+        run_cmd.append("-t")
+
+        # Add image name
+        run_cmd.append(self.image)
+
+        # Initial command to keep container running
+        run_cmd.extend(["tail", "-f", "/dev/null"])
+
+        try:
+            # Start the container
+            logging.info(f"Starting Docker container: {self._container_name}")
+            result = subprocess.run(
+                run_cmd,
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+
+            # Get container ID
+            self._container_id = result.stdout.strip()
+            logging.info(f"Started Docker container: {self._container_name} ({self._container_id})")
+
+            # Install pip packages if specified
+            if self.pip_packages or self.requirements_file:
+                self._install_packages()
+
+        except subprocess.CalledProcessError as e:
+            raise RuntimeError(f"Failed to start Docker container: {e.stderr}") from e
+
+    def _install_packages(self) -> None:
+        """Install Python packages in the running container."""
+        # Install pip packages
+        if self.pip_packages:
+            packages_str = " ".join(self.pip_packages)
+            try:
+                logging.info(f"Installing pip packages: {packages_str}")
+                _ = subprocess.run(
+                    ["docker", "exec", self._container_name, "pip", "install", "--no-cache-dir"] + self.pip_packages,
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+                logging.info("Successfully installed pip packages")
+            except subprocess.CalledProcessError as e:
+                logging.warning(f"Failed to install pip packages: {e.stderr}")
+
+        # Install from requirements file
+        if self.requirements_file:
+            if os.path.exists(self.requirements_file):
+                # Copy requirements file to temp directory
+                req_filename = os.path.basename(self.requirements_file)
+                temp_req_path = os.path.join(self._temp_dir, req_filename)
+                shutil.copy(self.requirements_file, temp_req_path)
+
+                try:
+                    logging.info(f"Installing requirements from: {req_filename}")
+                    _ = subprocess.run(
+                        [
+                            "docker",
+                            "exec",
+                            self._container_name,
+                            "pip",
+                            "install",
+                            "--no-cache-dir",
+                            "-r",
+                            f"/workspace/{req_filename}",
+                        ],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                    )
+                    logging.info("Successfully installed requirements")
+                except subprocess.CalledProcessError as e:
+                    logging.warning(f"Failed to install requirements: {e.stderr}")
+            else:
+                logging.warning(f"Requirements file not found: {self.requirements_file}")
+
+    def _cleanup_environment(self) -> None:
+        """Clean up the Docker environment."""
+        if self._container_id:
+            # Stop the container if it's running and we want to clean it up
+            if not self.keep_container_running:
+                try:
+                    logging.info(f"Stopping Docker container: {self._container_name}")
+                    subprocess.run(
+                        ["docker", "stop", self._container_name],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                    )
+                except subprocess.CalledProcessError:
+                    logging.warning(f"Failed to stop Docker container: {self._container_name}")
+
+            # Remove the container if cleanup is enabled
+            if self.cleanup_container and not self.keep_container_running:
+                try:
+                    logging.info(f"Removing Docker container: {self._container_name}")
+                    subprocess.run(
+                        ["docker", "rm", "-f", self._container_name],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                    )
+                except subprocess.CalledProcessError:
+                    logging.warning(f"Failed to remove Docker container: {self._container_name}")
+
+            # Remove the custom image if it was created
+            if self._custom_image_name and self.cleanup_container:
+                try:
+                    logging.info(f"Removing custom Docker image: {self._custom_image_name}")
+                    subprocess.run(
+                        ["docker", "rmi", self._custom_image_name],
+                        check=True,
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                    )
+                except subprocess.CalledProcessError:
+                    logging.warning(f"Failed to remove custom Docker image: {self._custom_image_name}")
+
+        # Clean up the temporary directory
+        if self._temp_dir and os.path.exists(self._temp_dir):
+            try:
+                shutil.rmtree(self._temp_dir)
+            except Exception as e:
+                logging.warning(f"Failed to remove temporary directory: {e}")
+
+    def get_executable(self) -> str:
+        """Get the path to the Python executable in the Docker container."""
+        # This is a virtual path in the container
+        return "python"
+
+    async def execute_code(self, code: str, script_path: str, timeout: int = 30) -> dict[str, Any]:
+        """Execute code in the Docker container."""
+        # Ensure the container is running
+        if not self._container_id:
+            return {"success": False, "error": "Docker container not started"}
+
+        try:
+            # Calculate the relative path within the temp directory
+            if os.path.isabs(script_path):
+                rel_path = os.path.basename(script_path)
+                host_script_path = os.path.join(self._temp_dir, rel_path)
+            else:
+                rel_path = script_path
+                host_script_path = os.path.join(self._temp_dir, rel_path)
+
+            # Ensure the directory for the script exists
+            script_dir = os.path.dirname(host_script_path)
+            if script_dir:
+                os.makedirs(script_dir, exist_ok=True)
+
+            # Write the code to the script file on the host
+            await asyncify(self._write_to_file)(host_script_path, code)
+
+            # Path to the script in the container
+            container_script_path = f"/workspace/{rel_path}"
+
+            # Execute the script in the container
+            exec_cmd = ["docker", "exec", self._container_name, "python", container_script_path]
+
+            # Run the command with a timeout
+            result = await asyncify(self._run_subprocess_with_timeout)(exec_cmd, timeout)
+
+            return {
+                "success": result[0],
+                "stdout": result[1],
+                "stderr": result[2],
+                "returncode": result[3] if result[0] else 1,
+            }
+
+        except Exception as e:
+            return {"success": False, "error": f"Execution error: {str(e)}"}
+
+    def _run_subprocess_with_timeout(self, cmd: list[str], timeout: int) -> Tuple[bool, str, str, int]:
+        """
+        Run a subprocess with timeout and return status, stdout, stderr, and return code.
+
+        Args:
+            cmd: Command to run as a list of strings
+            timeout: Maximum execution time in seconds
+
+        Returns:
+            Tuple of (success, stdout, stderr, return_code)
+        """
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            return (result.returncode == 0, result.stdout, result.stderr, result.returncode)
+        except subprocess.TimeoutExpired:
+            return (False, "", f"Execution timed out after {timeout} seconds", -1)
+        except Exception as e:
+            return (False, "", str(e), -1)

autogen/environments/python_environment.py

@@ -0,0 +1,134 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import subprocess
+from abc import ABC, abstractmethod
+from contextvars import ContextVar
+from typing import Any, Optional
+
+__all__ = ["PythonEnvironment"]
+
+
+class PythonEnvironment(ABC):
+    """Python execution environments base class"""
+
+    # Shared context variable for tracking the current environment
+    _current_python_environment: ContextVar["PythonEnvironment"] = ContextVar("_current_python_environment")
+
+    def __init__(self):
+        """
+        Initialize the Python environment.
+        """
+        self._token = None
+
+        # Set up the environment
+        self._setup_environment()
+
+    def __enter__(self):
+        """
+        Enter the environment context.
+        Sets this environment as the current one.
+        """
+        # Set this as the current Python environment in the context
+        self._token = PythonEnvironment._current_python_environment.set(self)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Exit the environment context.
+        Resets the current environment and performs cleanup.
+        """
+        # Reset the context variable if this was the active environment
+        if self._token is not None:
+            PythonEnvironment._current_python_environment.reset(self._token)
+            self._token = None
+
+        # Clean up resources
+        self._cleanup_environment()
+
+    @abstractmethod
+    def _setup_environment(self) -> None:
+        """Set up the Python environment. Called by __enter__."""
+        pass
+
+    @abstractmethod
+    def _cleanup_environment(self) -> None:
+        """Clean up the Python environment. Called by __exit__."""
+        pass
+
+    @abstractmethod
+    def get_executable(self) -> str:
+        """
+        Get the path to the Python executable in this environment.
+
+        Returns:
+            The full path to the Python executable.
+        """
+        pass
+
+    @abstractmethod
+    async def execute_code(self, code: str, script_path: str, timeout: int = 30) -> dict[str, Any]:
+        """
+        Execute the given code in this environment.
+
+        Args:
+            code: The Python code to execute.
+            script_path: Path where the code should be saved before execution.
+            timeout: Maximum execution time in seconds.
+
+        Returns:
+            dict with execution results including stdout, stderr, and success status.
+        """
+        pass
+
+    # Utility method for subclasses to wrap (for async support)
+    def _write_to_file(self, script_path: str, content: str) -> None:
+        """
+        Write content to a file (blocking operation).
+
+        This is a helper method for use with asyncify in async contexts.
+
+        Args:
+            script_path: Path to the file to write.
+            content: Content to write to the file.
+        """
+        with open(script_path, "w") as f:
+            f.write(content)
+
+    # Utility method for subclasses to wrap (for async support)
+    def _run_subprocess(self, cmd: list[str], timeout: int) -> subprocess.CompletedProcess:
+        """
+        Run a subprocess (blocking operation).
+
+        This is a helper method for use with asyncify in async contexts.
+
+        Args:
+            cmd: Command to run as a list of strings.
+            timeout: Maximum execution time in seconds.
+
+        Returns:
+            CompletedProcess instance with results of the subprocess.
+        """
+        return subprocess.run(cmd, capture_output=True, text=True, timeout=timeout)
+
+    @classmethod
+    def get_current_python_environment(
+        cls, python_environment: Optional["PythonEnvironment"] = None
+    ) -> Optional["PythonEnvironment"]:
+        """
+        Get the current Python environment or the specified one if provided.
+
+        Args:
+            python_environment: Optional environment to return if specified.
+
+        Returns:
+            The current Python environment or None if none is active.
+        """
+        if python_environment is not None:
+            return python_environment
+        try:
+            return cls._current_python_environment.get()
+        except LookupError:
+            return None

autogen/environments/system_python_environment.py

@@ -0,0 +1,86 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+import subprocess
+import sys
+from typing import Any, Optional
+
+from asyncer import asyncify
+
+from .python_environment import PythonEnvironment
+
+__all__ = ["SystemPythonEnvironment"]
+
+
+class SystemPythonEnvironment(PythonEnvironment):
+    """A Python environment using the system's Python installation."""
+
+    def __init__(
+        self,
+        executable: Optional[str] = None,
+    ):
+        """
+        Initialize a system Python environment.
+
+        Args:
+            executable: Optional path to a specific Python executable. If None, uses the current Python executable.
+        """
+        self._executable = executable or sys.executable
+        super().__init__()
+
+    def _setup_environment(self) -> None:
+        """Set up the system Python environment."""
+        # Verify the Python executable exists
+        if not os.path.exists(self._executable):
+            raise RuntimeError(f"Python executable not found at: {self._executable}")
+
+        logging.info(f"Using system Python at: {self._executable}")
+
+    def _cleanup_environment(self) -> None:
+        """Clean up the system Python environment."""
+        # No cleanup needed for system Python
+        pass
+
+    def get_executable(self) -> str:
+        """Get the path to the Python executable."""
+        return self._executable
+
+    async def execute_code(self, code: str, script_path: str, timeout: int = 30) -> dict[str, Any]:
+        """Execute code using the system Python."""
+        try:
+            # Get the Python executable
+            python_executable = self.get_executable()
+
+            # Verify the executable exists
+            if not os.path.exists(python_executable):
+                return {"success": False, "error": f"Python executable not found at {python_executable}"}
+
+            # Ensure the directory for the script exists
+            script_dir = os.path.dirname(script_path)
+            if script_dir:
+                os.makedirs(script_dir, exist_ok=True)
+
+            # Write the code to the script file using asyncify (from base class)
+            await asyncify(self._write_to_file)(script_path, code)
+
+            logging.info(f"Wrote code to {script_path}")
+
+            try:
+                # Execute directly with subprocess using asyncify for better reliability
+                result = await asyncify(self._run_subprocess)([python_executable, script_path], timeout)
+
+                # Main execution result
+                return {
+                    "success": result.returncode == 0,
+                    "stdout": result.stdout,
+                    "stderr": result.stderr,
+                    "returncode": result.returncode,
+                }
+            except subprocess.TimeoutExpired:
+                return {"success": False, "error": f"Execution timed out after {timeout} seconds"}
+
+        except Exception as e:
+            return {"success": False, "error": f"Execution error: {str(e)}"}

autogen/environments/venv_python_environment.py

@@ -0,0 +1,224 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import logging
+import os
+import subprocess
+import sys
+import tempfile
+from typing import Any, Optional
+
+from asyncer import asyncify
+
+from .python_environment import PythonEnvironment
+
+__all__ = ["VenvPythonEnvironment"]
+
+
+class VenvPythonEnvironment(PythonEnvironment):
+    """A Python environment using a virtual environment (venv)."""
+
+    def __init__(
+        self,
+        python_version: Optional[str] = None,
+        python_path: Optional[str] = None,
+        venv_path: Optional[str] = None,
+    ):
+        """
+        Initialize a virtual environment for Python execution.
+
+        If you pass in a venv_path the path will be checked for a valid venv. If the venv doesn't exist it will be created using the python_version or python_path provided.
+
+        If the python_version or python_path is provided and the venv_path is not, a temporary directory will be created for venv and it will be setup with the provided python version.
+
+        If python_path is provided, it will take precedence over python_version.
+
+        The python version will not be installed if it doesn't exist and a RuntimeError will be raised.
+
+        Args:
+            python_version: The Python version to use (e.g., "3.11"), otherwise defaults to the current executing Python version. Ignored if venv_path is provided and has a valid environment already.
+            python_path: Optional direct path to a Python executable to use (must include the executable). Takes precedence over python_version if both are provided.
+            venv_path: Optional path for the virtual environment, will create it if it doesn't exist. If None, creates a temp directory.
+        """
+        self.python_version = python_version
+        self.python_path = python_path
+        self.venv_path = venv_path
+        self.created_venv = False
+        self._executable = None
+        super().__init__()
+
+    def _setup_environment(self) -> None:
+        """Set up the virtual environment."""
+        # Create a venv directory if not provided
+        if self.venv_path is None:
+            self.venv_path = tempfile.mkdtemp(prefix="ag2_python_env_")
+            self.created_venv = True
+
+            # Determine the python version, getting it from the venv if it already has one
+            base_python = self._get_python_executable_for_version()
+            needs_creation = True
+        else:
+            # If venv_path is provided, check if it's already a valid venv
+            if os.name == "nt":  # Windows
+                venv_python = os.path.join(self.venv_path, "Scripts", "python.exe")
+            else:  # Unix-like (Mac/Linux)
+                venv_python = os.path.join(self.venv_path, "bin", "python")
+
+            if os.path.exists(venv_python) and os.access(venv_python, os.X_OK):
+                # Valid venv already exists, just use it
+                self._executable = venv_python
+                logging.info(f"Using existing virtual environment at {self.venv_path}")
+                needs_creation = False
+            else:
+                # Path exists but not a valid venv, or doesn't exist
+                if not os.path.exists(self.venv_path):
+                    os.makedirs(self.venv_path, exist_ok=True)
+                self.created_venv = True
+                base_python = sys.executable
+                needs_creation = True
+
+        # Only create the venv if needed
+        if needs_creation:
+            logging.info(f"Creating virtual environment at {self.venv_path} using {base_python}")
+
+            try:
+                # Create the virtual environment
+                _ = subprocess.run(
+                    [base_python, "-m", "venv", "--system-site-packages", self.venv_path],
+                    check=True,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    text=True,
+                )
+
+                # Determine the Python executable path
+                if os.name == "nt":  # Windows
+                    self._executable = os.path.join(self.venv_path, "Scripts", "python.exe")
+                else:  # Unix-like (Mac/Linux)
+                    self._executable = os.path.join(self.venv_path, "bin", "python")
+
+                # Verify the executable exists
+                if not os.path.exists(self._executable):
+                    raise RuntimeError(
+                        f"Virtual environment created but Python executable not found at {self._executable}"
+                    )
+
+            except subprocess.CalledProcessError as e:
+                raise RuntimeError(f"Failed to create virtual environment: {e.stderr}") from e
+
+    def _cleanup_environment(self) -> None:
+        """Clean up the virtual environment."""
+        # Note: We intentionally don't clean up the venv here to allow
+        # tools to continue using it after the context exits.
+        pass
+
+    def get_executable(self) -> str:
+        """Get the path to the Python executable in the virtual environment."""
+        if not self._executable or not os.path.exists(self._executable):
+            raise RuntimeError("Virtual environment Python executable not found")
+        return self._executable
+
+    async def execute_code(self, code: str, script_path: str, timeout: int = 30) -> dict[str, Any]:
+        """Execute code in the virtual environment."""
+        try:
+            # Get the Python executable
+            python_executable = self.get_executable()
+
+            # Verify the executable exists
+            if not os.path.exists(python_executable):
+                return {"success": False, "error": f"Python executable not found at {python_executable}"}
+
+            # Ensure the directory for the script exists
+            script_dir = os.path.dirname(script_path)
+            if script_dir:
+                os.makedirs(script_dir, exist_ok=True)
+
+            # Write the code to the script file using asyncify (from base class)
+            await asyncify(self._write_to_file)(script_path, code)
+
+            logging.info(f"Wrote code to {script_path}")
+
+            try:
+                # Execute directly with subprocess using asyncify for better reliability
+                result = await asyncify(self._run_subprocess)([python_executable, script_path], timeout)
+
+                # Main execution result
+                return {
+                    "success": result.returncode == 0,
+                    "stdout": result.stdout,
+                    "stderr": result.stderr,
+                    "returncode": result.returncode,
+                }
+            except subprocess.TimeoutExpired:
+                return {"success": False, "error": f"Execution timed out after {timeout} seconds"}
+
+        except Exception as e:
+            return {"success": False, "error": f"Execution error: {str(e)}"}
+
+    def _get_python_executable_for_version(self) -> str:
+        """Get the Python executable for the specified version and verify it can create a venv."""
+        # If a specific path is provided, use it directly
+        if self.python_path:
+            if not os.path.exists(self.python_path) or not os.access(self.python_path, os.X_OK):
+                raise RuntimeError(f"Python executable not found at {self.python_path}")
+            return self.python_path
+
+        # If no specific version is requested, use the current Python
+        if not self.python_version:
+            return sys.executable
+
+        potential_executables = []
+
+        # Try to find a specific Python version using pyenv if available
+        try:
+            pyenv_result = subprocess.run(
+                ["pyenv", "which", f"python{self.python_version}"],
+                check=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+            potential_executables.append(pyenv_result.stdout.strip())
+        except (subprocess.SubprocessError, FileNotFoundError):
+            pass
+
+        # Try common system paths based on platform
+        if os.name == "nt":  # Windows
+            potential_executables.extend([
+                f"C:\\Python{self.python_version.replace('.', '')}\\python.exe",
+                f"C:\\Program Files\\Python{self.python_version.replace('.', '')}\\python.exe",
+                f"C:\\Program Files (x86)\\Python{self.python_version.replace('.', '')}\\python.exe",
+            ])
+        else:  # Unix-like (Mac and Linux)
+            # Add more paths that might exist on macOS
+            potential_executables.extend([
+                f"/usr/bin/python{self.python_version}",
+                f"/usr/local/bin/python{self.python_version}",
+                f"/opt/homebrew/bin/python{self.python_version}",  # Homebrew on Apple Silicon
+                f"/opt/python/bin/python{self.python_version}",
+            ])
+
+        # Try each potential path and verify it can create a venv
+        for path in potential_executables:
+            if os.path.exists(path) and os.access(path, os.X_OK):
+                # Verify this Python can create a venv
+                try:
+                    test_result = subprocess.run(
+                        [path, "-m", "venv", "--help"],
+                        check=False,  # Don't raise exception
+                        stdout=subprocess.PIPE,
+                        stderr=subprocess.PIPE,
+                        text=True,
+                        timeout=5,  # Add timeout for safety
+                    )
+                    if test_result.returncode == 0:
+                        # Successfully found a valid Python executable
+                        return path
+                except (subprocess.SubprocessError, FileNotFoundError):
+                    continue
+
+        # If we couldn't find the specified version, raise an exception
+        raise RuntimeError(
+            f"Python {self.python_version} not found or cannot create virtual environments. Provide a python_path to use a specific Python executable."
+        )

autogen/environments/working_directory.py

@@ -0,0 +1,75 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import contextlib
+import os
+import shutil
+import tempfile
+from contextvars import ContextVar
+from typing import Optional
+
+__all__ = ["WorkingDirectory"]
+
+
+class WorkingDirectory:
+    """Context manager for changing the current working directory."""
+
+    _current_working_directory: ContextVar["WorkingDirectory"] = ContextVar("_current_working_directory")
+
+    def __init__(self, path: str):
+        """
+        Initialize with a directory path.
+
+        Args:
+            path: The directory path to change to.
+        """
+        self.path = path
+        self.original_path = None
+        self.created_tmp = False
+        self._token = None
+
+    def __enter__(self):
+        """Change to the specified directory and return self."""
+        self.original_path = os.getcwd()
+        if self.path:
+            os.makedirs(self.path, exist_ok=True)
+            os.chdir(self.path)
+
+        # Set this as the current working directory in the context
+        self._token = WorkingDirectory._current_working_directory.set(self)
+
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Change back to the original directory and clean up if necessary."""
+        # Reset the context variable if this was the active working directory
+        if self._token is not None:
+            WorkingDirectory._current_working_directory.reset(self._token)
+            self._token = None
+
+        if self.original_path:
+            os.chdir(self.original_path)
+        if self.created_tmp and self.path and os.path.exists(self.path):
+            with contextlib.suppress(Exception):
+                shutil.rmtree(self.path)
+
+    @classmethod
+    def create_tmp(cls):
+        """Create a temporary directory and return a WorkingDirectory instance for it."""
+        tmp_dir = tempfile.mkdtemp(prefix="ag2_work_dir_")
+        instance = cls(tmp_dir)
+        instance.created_tmp = True
+        return instance
+
+    @classmethod
+    def get_current_working_directory(
+        cls, working_directory: Optional["WorkingDirectory"] = None
+    ) -> Optional["WorkingDirectory"]:
+        """Get the current working directory or the specified one if provided."""
+        if working_directory is not None:
+            return working_directory
+        try:
+            return cls._current_working_directory.get()
+        except LookupError:
+            return None

autogen/llm_config.py

@@ -9,7 +9,7 @@ from abc import ABC, abstractmethod
 from collections.abc import Iterable
 from contextvars import ContextVar
 from pathlib import Path
-from typing import TYPE_CHECKING, Annotated, Any, Mapping, Optional, Type, TypeVar, Union
+from typing import TYPE_CHECKING, Annotated, Any, Literal, Mapping, Optional, Type, TypeVar, Union
 
 from httpx import Client as httpxClient
 from pydantic import BaseModel, ConfigDict, Field, HttpUrl, SecretStr, ValidationInfo, field_serializer, field_validator
@@ -268,6 +268,7 @@ class LLMConfig(metaclass=MetaLLMConfig):
                     list[Annotated[Union[llm_config_classes], Field(discriminator="api_type")]],
                     Field(default_factory=list, min_length=1),
                 ]
+                routing_method: Optional[Literal["fixed_order", "round_robin"]] = None
 
                 # Following field is configuration for pydantic to disallow extra fields
                 model_config = ConfigDict(extra="forbid")
@@ -302,13 +303,15 @@ class LLMConfigEntry(BaseModel, ABC):
     @field_validator("base_url", mode="before")
     @classmethod
     def check_base_url(cls, v: Any, info: ValidationInfo) -> Any:
+        if v is None:  # Handle None case explicitly
+            return None
         if not str(v).startswith("https://") and not str(v).startswith("http://"):
             v = f"http://{str(v)}"
         return v
 
-    @field_serializer("base_url")
+    @field_serializer("base_url", when_used="unless-none")  # Ensure serializer also respects None
     def serialize_base_url(self, v: Any) -> Any:
-        return str(v)
+        return str(v) if v is not None else None
 
     @field_serializer("api_key", when_used="unless-none")
     def serialize_api_key(self, v: SecretStr) -> Any:

autogen/mcp/mcp_proxy/mcp_proxy.py

@@ -129,12 +129,12 @@ class MCPProxy:
         return mcp
 
     def _process_params(
-        self, path: str, func: Callable[[Any], Any], **kwargs: Any
+        self, process_path: str, func: Callable[[Any], Any], **kwargs: Any
     ) -> tuple[str, dict[str, Any], dict[str, Any]]:
-        path = MCPProxy._convert_camel_case_within_braces_to_snake(path)
-        q_params, path_params, body, security = MCPProxy._get_params(path, func)
+        process_path = MCPProxy._convert_camel_case_within_braces_to_snake(process_path)
+        q_params, path_params, body, security = MCPProxy._get_params(process_path, func)
 
-        expanded_path = path.format(**{p: kwargs[p] for p in path_params})
+        expanded_path = process_path.format(**{p: kwargs[p] for p in path_params})
 
         url = self._servers[0]["url"] + expanded_path
 

autogen/oai/client.py

@@ -806,17 +806,29 @@ class OpenAIWrapper:
         self._clients: list[ModelClient] = []
         self._config_list: list[dict[str, Any]] = []
 
+        # Determine routing_method from base_config only.
+        self.routing_method = base_config.get("routing_method") or "fixed_order"
+        self._round_robin_index = 0
+
+        # Remove routing_method from extra_kwargs after it has been used to set self.routing_method
+        # This ensures it's not part of the individual client configurations that are based on extra_kwargs.
+        extra_kwargs.pop("routing_method", None)
+
         if config_list:
             config_list = [config.copy() for config in config_list]  # make a copy before modifying
-            for config in config_list:
-                self._register_default_client(config, openai_config)  # could modify the config
-                self._config_list.append({
-                    **extra_kwargs,
-                    **{k: v for k, v in config.items() if k not in self.openai_kwargs},
-                })
+            for config_item in config_list:
+                self._register_default_client(config_item, openai_config)
+                # Construct current_config_extra_kwargs using the cleaned extra_kwargs
+                # (which doesn't have routing_method from base_config)
+                # and specific non-openai kwargs from config_item.
+                config_item_specific_extras = {k: v for k, v in config_item.items() if k not in self.openai_kwargs}
+                self._config_list.append({**extra_kwargs, **config_item_specific_extras})
         else:
+            # For a single config passed via base_config (already in extra_kwargs)
             self._register_default_client(extra_kwargs, openai_config)
+            # extra_kwargs has already had routing_method popped.
             self._config_list = [extra_kwargs]
+
         self.wrapper_id = id(self)
 
     def _separate_openai_config(self, config: dict[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]:
@@ -1074,7 +1086,16 @@ class OpenAIWrapper:
             raise RuntimeError(
                 f"Model client(s) {non_activated} are not activated. Please register the custom model clients using `register_model_client` or filter them out form the config list."
             )
-        for i, client in enumerate(self._clients):
+
+        ordered_clients_indices = list(range(len(self._clients)))
+        if self.routing_method == "round_robin" and len(self._clients) > 0:
+            ordered_clients_indices = (
+                ordered_clients_indices[self._round_robin_index :] + ordered_clients_indices[: self._round_robin_index]
+            )
+            self._round_robin_index = (self._round_robin_index + 1) % len(self._clients)
+
+        for i in ordered_clients_indices:
+            client = self._clients[i]
             # merge the input config with the i-th config in the config list
             full_config = {**config, **self._config_list[i]}
             # separate the config into create_config and extra_kwargs

autogen/tools/experimental/__init__.py

@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from .browser_use import BrowserUseTool
+from .code_execution import PythonCodeExecutionTool
 from .crawl4ai import Crawl4AITool
 from .deep_research import DeepResearchTool
 from .duckduckgo import DuckDuckGoSearchTool
@@ -34,6 +35,7 @@ __all__ = [
     "FirecrawlTool",
     "GoogleSearchTool",
     "PerplexitySearchTool",
+    "PythonCodeExecutionTool",
     "ReliableTool",
     "ReliableToolError",
     "SearxngSearchTool",

autogen/tools/experimental/code_execution/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .python_code_execution import PythonCodeExecutionTool
+
+__all__ = ["PythonCodeExecutionTool"]

autogen/tools/experimental/code_execution/python_code_execution.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import tempfile
+from typing import Annotated, Any, Optional
+
+from pydantic import BaseModel, Field
+
+from ....doc_utils import export_module
+from ....environments import WorkingDirectory
+from ....environments.python_environment import PythonEnvironment
+from ... import Tool
+
+__all__ = ["PythonCodeExecutionTool"]
+
+
+@export_module("autogen.tools.experimental")
+class PythonCodeExecutionTool(Tool):
+    """Executes Python code in a given environment and returns the result."""
+
+    def __init__(
+        self,
+        *,
+        timeout: int = 30,
+        working_directory: Optional[WorkingDirectory] = None,
+        python_environment: Optional[PythonEnvironment] = None,
+    ) -> None:
+        """
+        Initialize the PythonCodeExecutionTool.
+
+        **CAUTION**: If provided a local environment, this tool will execute code in your local environment, which can be dangerous if the code is untrusted.
+
+        Args:
+            timeout: Maximum execution time allowed in seconds, will raise a TimeoutError exception if exceeded.
+            working_directory: Optional WorkingDirectory context manager to use.
+            python_environment: Optional PythonEnvironment to use. If None, will auto-detect or create based on other parameters.
+        """
+        # Store configuration parameters
+        self.timeout = timeout
+        self.working_directory = WorkingDirectory.get_current_working_directory(working_directory)
+        tool_python_environment = PythonEnvironment.get_current_python_environment(python_environment)
+
+        assert self.working_directory, "No Working directory found"
+        assert tool_python_environment, "No Python environment found"
+
+        self.python_environment = tool_python_environment
+
+        # Pydantic model to contain the code and list of libraries to execute
+        class CodeExecutionRequest(BaseModel):
+            code: Annotated[str, Field(description="Python code to execute")]
+            libraries: Annotated[list[str], Field(description="List of libraries to install before execution")]
+
+        # The tool function, this is what goes to the LLM
+        async def execute_python_code(
+            code_execution_request: Annotated[CodeExecutionRequest, "Python code and the libraries required"],
+        ) -> dict[str, Any]:
+            """
+            Executes Python code in the attached environment and returns the result.
+
+            Args:
+                code_execution_request (CodeExecutionRequest): The Python code and libraries to execute
+            """
+            code = code_execution_request.code
+
+            # NOTE: Libraries are not installed (something to consider for future versions)
+
+            # Prepare a script file path
+            script_dir = self._get_script_directory()
+            script_path = os.path.join(script_dir, "script.py")
+
+            # Execute the code
+            return await self.python_environment.execute_code(code=code, script_path=script_path, timeout=self.timeout)
+
+        super().__init__(
+            name="python_execute_code",
+            description="Executes Python code and returns the result.",
+            func_or_tool=execute_python_code,
+        )
+
+    def _get_script_directory(self) -> str:
+        """Get the directory to use for scripts."""
+        if self.working_directory and hasattr(self.working_directory, "path") and self.working_directory.path:
+            path = self.working_directory.path
+            os.makedirs(path, exist_ok=True)
+            return path
+        return tempfile.mkdtemp(prefix="ag2_script_dir_")

autogen/version.py

@@ -4,4 +4,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.9.5"
+__version__ = "0.9.6"