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

autogen/oai/client.py

@@ -51,6 +51,8 @@ if openai_result.is_successful:
     from openai.types.completion import Completion
     from openai.types.completion_usage import CompletionUsage
 
+    from autogen.oai.openai_responses import OpenAIResponsesClient
+
     if openai.__version__ >= "1.1.0":
         TOOL_ENABLED = True
     ERROR = None
@@ -314,7 +316,7 @@ class ModelClient(Protocol):
     class ModelClientResponseProtocol(Protocol):
         class Choice(Protocol):
             class Message(Protocol):
-                content: Optional[str]
+                content: Optional[str] | Optional[dict[str, Any]]
 
             message: Message
 
@@ -804,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]]:
@@ -952,6 +966,15 @@ class OpenAIWrapper:
                     raise ImportError("Please install `boto3` to use the Amazon Bedrock API.")
                 client = BedrockClient(response_format=response_format, **openai_config)
                 self._clients.append(client)
+            elif api_type is not None and api_type.startswith("responses"):
+                # OpenAI Responses API (stateful). Reuse the same OpenAI SDK but call the `/responses` endpoint via the new client.
+                @require_optional_import("openai>=1.66.2", "openai")
+                def create_responses_client() -> "OpenAI":
+                    client = OpenAI(**openai_config)
+                    self._clients.append(OpenAIResponsesClient(client, response_format=response_format))
+                    return client
+
+                client = create_responses_client()
             else:
 
                 @require_optional_import("openai>=1.66.2", "openai")
@@ -1063,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
@@ -1442,3 +1474,35 @@ class OpenAIWrapper:
             A list of text, or a list of ChatCompletion objects if function_call/tool_calls are present.
         """
         return response.message_retrieval_function(response)
+
+
+# -----------------------------------------------------------------------------
+# New: Responses API config entry (OpenAI-hosted preview endpoint)
+# -----------------------------------------------------------------------------
+
+
+@register_llm_config
+class OpenAIResponsesLLMConfigEntry(OpenAILLMConfigEntry):
+    """LLMConfig entry for the OpenAI Responses API (stateful, tool-enabled).
+
+    This reuses all the OpenAI fields but changes *api_type* so the wrapper can
+    route traffic to the `client.responses` endpoint instead of
+    `chat.completions`.  It inherits everything else – including reasoning
+    fields – from *OpenAILLMConfigEntry* so users can simply set
+
+    ```python
+    {
+        "api_type": "responses",  # <-- key differentiator
+        "model": "o3",  # reasoning model
+        "reasoning_effort": "medium",  # low / medium / high
+        "stream": True,
+    }
+    ```
+    """
+
+    api_type: Literal["responses"] = "responses"
+    tool_choice: Optional[Literal["none", "auto", "required"]] = "auto"
+    built_in_tools: Optional[list[str]] = None
+
+    def create_client(self) -> "ModelClient":  # pragma: no cover
+        raise NotImplementedError("Handled via OpenAIWrapper._register_default_client")

autogen/oai/openai_responses.py

@@ -0,0 +1,426 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import copy
+import warnings
+from typing import TYPE_CHECKING, Any, Tuple, Union
+
+from pydantic import BaseModel
+
+from autogen.code_utils import content_str
+from autogen.import_utils import optional_import_block, require_optional_import
+
+if TYPE_CHECKING:
+    from autogen.oai.client import ModelClient, OpenAI, OpenAILLMConfigEntry
+else:
+    # Import at runtime to avoid circular import
+    OpenAILLMConfigEntry = None
+    ModelClient = None
+    OpenAI = None
+
+with optional_import_block() as openai_result:
+    from openai.types.responses.response import Response
+    from openai.types.responses.response_output_item import ImageGenerationCall
+
+# Image Costs
+# Pricing per image (in USD)
+PRICING = {
+    "gpt-image-1": {
+        "low": {"1024x1024": 0.011, "1024x1536": 0.016, "1536x1024": 0.016},
+        "medium": {"1024x1024": 0.042, "1024x1536": 0.063, "1536x1024": 0.063},
+        "high": {"1024x1024": 0.167, "1024x1536": 0.25, "1536x1024": 0.25},
+    },
+    "dall-e-3": {
+        "standard": {"1024x1024": 0.040, "1024x1792": 0.080, "1792x1024": 0.080},
+        "hd": {"1024x1024": 0.080, "1024x1792": 0.120, "1792x1024": 0.120},
+    },
+    "dall-e-2": {"standard": {"1024x1024": 0.020, "512x512": 0.018, "256x256": 0.016}},
+}
+
+# Valid sizes for each model
+VALID_SIZES = {
+    "gpt-image-1": ["1024x1024", "1024x1536", "1536x1024"],
+    "dall-e-3": ["1024x1024", "1024x1792", "1792x1024"],
+    "dall-e-2": ["1024x1024", "512x512", "256x256"],
+}
+
+
+def calculate_openai_image_cost(
+    model: str = "gpt-image-1", size: str = "1024x1024", quality: str = "high"
+) -> Tuple[float, str]:
+    """
+    Calculate the cost for a single image generation.
+
+    Args:
+        model: Model name ("gpt-image-1", "dall-e-3" or "dall-e-2")
+        size: Image size (e.g., "1024x1024", "1024x1536")
+        quality: Quality setting:
+                - For gpt-image-1: "low", "medium", or "high"
+                - For dall-e-3: "standard" or "hd"
+                - For dall-e-2: "standard" only
+
+    Returns:
+        Tuple of (cost, error_message)
+    """
+    # Normalize inputs
+    model = model.lower()
+    quality = quality.lower()
+
+    # Validate model
+    if model not in PRICING:
+        return 0.0, f"Invalid model: {model}. Valid models: {list(PRICING.keys())}"
+
+    # Validate size
+    if size not in VALID_SIZES[model]:
+        return 0.0, f"Invalid size {size} for {model}. Valid sizes: {VALID_SIZES[model]}"
+
+    # Get the cost based on model type
+    try:
+        if model == "gpt-image-1" or model == "dall-e-3":
+            cost = PRICING[model][quality][size]
+        elif model == "dall-e-2":
+            cost = PRICING[model]["standard"][size]
+        else:
+            return 0.0, f"Model {model} not properly configured"
+
+        return cost, None
+
+    except KeyError:
+        return 0.0, f"Invalid quality '{quality}' for {model}"
+
+
+def _get_base_class():
+    """Lazy import OpenAILLMConfigEntry to avoid circular imports."""
+    from autogen.oai.client import OpenAILLMConfigEntry
+
+    return OpenAILLMConfigEntry
+
+
+# -----------------------------------------------------------------------------
+# OpenAI Client that calls the /responses endpoint
+# -----------------------------------------------------------------------------
+@require_optional_import("openai", "openai")
+class OpenAIResponsesClient:
+    """Minimal implementation targeting the experimental /responses endpoint.
+
+    We purposefully keep the surface small - *create*, *message_retrieval*,
+    *cost* and *get_usage* - enough for ConversableAgent to operate.  Anything
+    that the new endpoint does natively (web_search, file_search, image
+    generation, function calling, etc.) is transparently passed through by the
+    OpenAI SDK so we don't replicate logic here.
+    """
+
+    def __init__(
+        self,
+        client: "OpenAI",
+        response_format: Union[BaseModel, dict[str, Any], None] = None,
+    ):
+        self._oai_client = client  # plain openai.OpenAI instance
+        self.response_format = response_format  # kept for parity but unused for now
+
+        # Initialize the image generation parameters
+        self.image_output_params = {
+            "quality": None,  # "high" or "low"
+            "background": None,  # "white" or "black" or "transparent"
+            "size": None,  # "1024x1024" or "1024x1792" or "1792x1024"
+            "output_format": "png",  # "png", "jpg" or "jpeg" or "webp"
+            "output_compression": None,  # 0-100 if output_format is "jpg" or "jpeg" or "webp"
+        }
+        self.previous_response_id = None
+
+        # Image costs are calculated manually (rather than off returned information)
+        self.image_costs = 0
+
+    # ------------------------------------------------------------------ helpers
+    # responses objects embed usage similarly to chat completions
+    @staticmethod
+    def _usage_dict(resp) -> dict:
+        usage_obj = getattr(resp, "usage", None) or {}
+
+        # Convert pydantic/BaseModel usage objects to dict for uniform access
+        if hasattr(usage_obj, "model_dump"):
+            usage = usage_obj.model_dump()
+        elif isinstance(usage_obj, dict):
+            usage = usage_obj
+        else:  # fallback - unknown structure
+            usage = {}
+
+        output_tokens_details = usage.get("output_tokens_details", {})
+
+        return {
+            "prompt_tokens": usage.get("input_tokens", 0),
+            "completion_tokens": usage.get("output_tokens", 0),
+            "total_tokens": usage.get("total_tokens", 0),
+            "cost": getattr(resp, "cost", 0),
+            "model": getattr(resp, "model", ""),
+            "reasoning_tokens": output_tokens_details.get("reasoning_tokens", 0),
+        }
+
+    def _add_image_cost(self, response: "Response") -> None:
+        """Add image cost to self._image_costs when an image is generated"""
+        for output in response.output:
+            if (
+                isinstance(output, ImageGenerationCall)
+                and hasattr(response.output[0], "model_extra")
+                and response.output[0].model_extra
+            ):
+                extra_fields = output.model_extra
+
+                image_cost, image_error = calculate_openai_image_cost(
+                    model="gpt-image-1",
+                    size=extra_fields.get("size", "1024x1536"),
+                    quality=extra_fields.get("quality", "high"),
+                )
+
+                if not image_error and image_cost:
+                    self.image_costs += image_cost
+
+    def _get_delta_messages(self, messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Get the delta messages from the messages."""
+        delta_messages = []
+        for m in messages[::-1]:
+            contents = m.get("content")
+            is_last_completed_response = False
+            if isinstance(contents, list):
+                for c in contents:
+                    if "status" in c and c.get("status") == "completed":
+                        is_last_completed_response = True
+                        break
+            elif isinstance(contents, str):
+                is_last_completed_response = "status" in m and m.get("status") == "completed"
+
+            if is_last_completed_response:
+                break
+            delta_messages.append(m)
+        return delta_messages[::-1]
+
+    def create(self, params: dict[str, Any]) -> "Response":
+        """Invoke `client.responses.create() or .parse()`.
+
+        If the caller provided a classic *messages* array we convert it to the
+        *input* format expected by the Responses API.
+        """
+        params = params.copy()
+
+        image_generation_tool_params = {"type": "image_generation"}
+        web_search_tool_params = {"type": "web_search_preview"}
+
+        if self.previous_response_id is not None and "previous_response_id" not in params:
+            params["previous_response_id"] = self.previous_response_id
+
+        # Back-compat: transform messages → input if needed ------------------
+        if "messages" in params and "input" not in params:
+            msgs = self._get_delta_messages(params.pop("messages"))
+            input_items = []
+            for m in msgs[::-1]:  # reverse the list to get the last item first
+                role = m.get("role", "user")
+                # First, we need to convert the content to the Responses API format
+                content = m.get("content")
+                blocks = []
+                if role != "tool":
+                    if isinstance(content, list):
+                        for c in content:
+                            if c.get("type") in ["input_text", "text"]:
+                                blocks.append({"type": "input_text", "text": c.get("text")})
+                            elif c.get("type") == "input_image":
+                                blocks.append({"type": "input_image", "image_url": c.get("image_url")})
+                            elif c.get("type") == "image_params":
+                                for k, v in c.get("image_params", {}).items():
+                                    if k in self.image_output_params:
+                                        image_generation_tool_params[k] = v
+                            else:
+                                raise ValueError(f"Invalid content type: {c.get('type')}")
+                    else:
+                        blocks.append({"type": "input_text", "text": content})
+                    input_items.append({"role": role, "content": blocks})
+
+                else:
+                    if input_items:
+                        break
+                    # tool call response is the last item in the list
+                    content = content_str(m.get("content"))
+                    input_items.append({
+                        "type": "function_call_output",
+                        "call_id": m.get("tool_call_id", None),
+                        "output": content,
+                    })
+                    break
+            params["input"] = input_items[::-1]
+
+        # Initialize tools list
+        tools_list = []
+        # Back-compat: add default tools
+        built_in_tools = params.pop("built_in_tools", [])
+        if built_in_tools:
+            if "image_generation" in built_in_tools:
+                tools_list.append(image_generation_tool_params)
+            if "web_search" in built_in_tools:
+                tools_list.append(web_search_tool_params)
+
+        if "tools" in params:
+            for tool in params["tools"]:
+                tool_item = {"type": "function"}
+                if "function" in tool:
+                    tool_item |= tool["function"]
+                    tools_list.append(tool_item)
+        params["tools"] = tools_list
+        params["tool_choice"] = "auto"
+
+        # Ensure we don't mix legacy params that Responses doesn't accept
+        if params.get("stream") and params.get("background"):
+            warnings.warn(
+                "Streaming a background response may introduce latency.",
+                UserWarning,
+            )
+
+        # ------------------------------------------------------------------
+        # Structured output handling - mimic OpenAIClient behaviour
+        # ------------------------------------------------------------------
+
+        if self.response_format is not None or "response_format" in params:
+
+            def _create_or_parse(**kwargs):
+                # For structured output we must convert dict / pydantic model
+                # into the JSON-schema body expected by the API.
+                if "stream" in kwargs:
+                    kwargs.pop("stream")  # Responses API rejects stream with RF for now
+
+                rf = kwargs.get("response_format", self.response_format)
+
+                if isinstance(rf, dict):
+                    from autogen.oai.client import _ensure_strict_json_schema
+
+                    kwargs["text_format"] = {
+                        "type": "json_schema",
+                        "json_schema": {
+                            "schema": _ensure_strict_json_schema(rf, path=(), root=rf),
+                            "name": "response_format",
+                            "strict": True,
+                        },
+                    }
+                else:
+                    # pydantic.BaseModel subclass
+                    from autogen.oai.client import type_to_response_format_param
+
+                    kwargs["text_format"] = type_to_response_format_param(rf)
+                if "response_format" in kwargs:
+                    kwargs["text_format"] = kwargs.pop("response_format")
+
+                try:
+                    return self._oai_client.responses.parse(**kwargs)
+                except TypeError as e:
+                    # Older openai-python versions may not yet expose the
+                    # text_format parameter on the Responses endpoint.
+                    if "text_format" in str(e) and "unexpected" in str(e):
+                        warnings.warn(
+                            "Installed openai-python version doesn't support "
+                            "`response_format` for the Responses API. "
+                            "Falling back to raw text output.",
+                            UserWarning,
+                        )
+                        kwargs.pop("text_format", None)
+                        return self._oai_client.responses.create(**kwargs)
+
+            response = _create_or_parse(**params)
+            self.previous_response_id = response.id
+            return response
+
+        # No structured output
+        response = self._oai_client.responses.create(**params)
+        self.previous_response_id = response.id
+
+        # Accumulate image costs
+        self._add_image_cost(response)
+
+        return response
+
+    def message_retrieval(
+        self, response
+    ) -> Union[list[str], list["ModelClient.ModelClientResponseProtocol.Choice.Message"]]:
+        output = getattr(response, "output", [])
+        content = []  # list[dict[str, Union[str, dict[str, Any]]]]]
+        tool_calls = []
+        for item in output:
+            # Convert pydantic objects to plain dicts for uniform handling
+            if hasattr(item, "model_dump"):
+                item = item.model_dump()
+
+            item_type = item.get("type")
+
+            # ------------------------------------------------------------------
+            # 1) Normal messages
+            # ------------------------------------------------------------------
+            if item_type == "message":
+                new_item = copy.deepcopy(item)
+                new_item["type"] = "text"
+                new_item["role"] = "assistant"
+                blocks = item.get("content", [])
+                if len(blocks) == 1 and blocks[0].get("type") == "output_text":
+                    new_item["text"] = blocks[0]["text"]
+                if "content" in new_item:
+                    del new_item["content"]
+                content.append(new_item)
+                continue
+
+            # ------------------------------------------------------------------
+            # 2) Custom function calls
+            # ------------------------------------------------------------------
+            if item_type == "function_call":
+                tool_calls.append({
+                    "id": item.get("call_id", None),
+                    "function": {
+                        "name": item.get("name", None),
+                        "arguments": item.get("arguments"),
+                    },
+                    "type": "function_call",
+                })
+                continue
+
+            # ------------------------------------------------------------------
+            # 3) Built-in tool calls
+            # ------------------------------------------------------------------
+            if item_type and item_type.endswith("_call"):
+                tool_name = item_type.replace("_call", "")
+                tool_call_args = {
+                    "id": item.get("id"),
+                    "role": "tool_calls",
+                    "type": "tool_call",  # Responses API currently routes via function-like tools
+                    "name": tool_name,
+                }
+                if tool_name == "image_generation":
+                    for k in self.image_output_params:
+                        if k in item:
+                            tool_call_args[k] = item[k]
+                    encoded_base64_result = item.get("result", "")
+                    tool_call_args["content"] = encoded_base64_result
+                    # add image_url for image input back to oai response api.
+                    output_format = self.image_output_params["output_format"]
+                    tool_call_args["image_url"] = f"data:image/{output_format};base64,{encoded_base64_result}"
+                elif tool_name == "web_search":
+                    pass
+                else:
+                    raise ValueError(f"Invalid tool name: {tool_name}")
+                content.append(tool_call_args)
+                continue
+
+            # ------------------------------------------------------------------
+            # 4) Fallback - store raw dict so information isn't lost
+            # ------------------------------------------------------------------
+            content.append(item)
+
+        return [
+            {
+                "role": "assistant",
+                "id": response.id,
+                "content": content if content else None,
+                "tool_calls": tool_calls,
+            }
+        ]
+
+    def cost(self, response):
+        return self._usage_dict(response).get("cost", 0) + self.image_costs
+
+    @staticmethod
+    def get_usage(response):
+        return OpenAIResponsesClient._usage_dict(response)

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.4"
+__version__ = "0.9.6"