ag2 0.9.6__py3-none-any.whl → 0.9.8.post1__py3-none-any.whl

autogen/retrieve_utils.py

@@ -9,7 +9,8 @@ import hashlib
 import logging
 import os
 import re
-from typing import Any, Callable, Optional, Union
+from collections.abc import Callable
+from typing import Any
 from urllib.parse import urlparse
 
 import requests
@@ -158,11 +159,11 @@ def extract_text_from_pdf(file: str) -> str:
 
 
 def split_files_to_chunks(
-    files: list[Union[tuple[str, str], str]],
+    files: list[tuple[str, str] | str],
     max_tokens: int = 4000,
     chunk_mode: str = "multi_lines",
     must_break_at_empty_line: bool = True,
-    custom_text_split_function: Optional[Callable[[str], list[str]]] = None,
+    custom_text_split_function: Callable[[str], list[str]] | None = None,
 ) -> tuple[list[str], list[dict[str, Any]]]:
     """Split a list of files into chunks of max_tokens."""
     chunks = []
@@ -200,9 +201,7 @@ def split_files_to_chunks(
     return chunks, sources
 
 
-def get_files_from_dir(
-    dir_path: Union[str, list[str]], types: list[str] = TEXT_FORMATS, recursive: bool = True
-) -> list[Any]:
+def get_files_from_dir(dir_path: str | list[str], types: list[str] = TEXT_FORMATS, recursive: bool = True) -> list[Any]:
     """Return a list of all the files in a given directory, a url, a file path or a list of them."""
     if len(types) == 0:
         raise ValueError("types cannot be empty.")
@@ -343,7 +342,7 @@ def is_url(string: str):
 
 @require_optional_import("chromadb", "retrievechat")
 def create_vector_db_from_dir(
-    dir_path: Union[str, list[str]],
+    dir_path: str | list[str],
     max_tokens: int = 4000,
     client: "API" = None,
     db_path: str = "tmp/chromadb.db",

autogen/runtime_logging.py

@@ -9,7 +9,8 @@ from __future__ import annotations
 import logging
 import sqlite3
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, Literal, Optional, TypeVar
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Literal, TypeVar
 
 from .logger.base_logger import BaseLogger, LLMConfig
 from .logger.logger_factory import LoggerFactory
@@ -38,9 +39,9 @@ F = TypeVar("F", bound=Callable[..., Any])
 
 
 def start(
-    logger: Optional[BaseLogger] = None,
+    logger: BaseLogger | None = None,
     logger_type: Literal["sqlite", "file"] = "sqlite",
-    config: Optional[dict[str, Any]] = None,
+    config: dict[str, Any] | None = None,
 ) -> str:
     """Start logging for the runtime.
 
@@ -71,7 +72,7 @@ def log_chat_completion(
     wrapper_id: int,
     agent: str | Agent,
     request: dict[str, float | str | list[dict[str, str]]],
-    response: str | "ChatCompletion",
+    response: str | ChatCompletion,
     is_cached: int,
     cost: float,
     start_time: str,

autogen/token_count_utils.py

@@ -8,7 +8,7 @@
 import json
 import logging
 import re
-from typing import Any, Union
+from typing import Any
 
 import tiktoken
 
@@ -63,6 +63,9 @@ def get_max_token_limit(model: str = "gpt-3.5-turbo-0613") -> int:
         "gpt-4o-2024-11-20": 128000,
         "gpt-4o-mini": 128000,
         "gpt-4o-mini-2024-07-18": 128000,
+        "gpt-5": 128000,
+        "gpt-5-mini": 128000,
+        "gpt-5-nano": 128000,
     }
     return max_token_limit[model]
 
@@ -71,7 +74,7 @@ def percentile_used(input, model="gpt-3.5-turbo-0613"):
     return count_token(input) / get_max_token_limit(model)
 
 
-def token_left(input: Union[str, list[str], dict[str, Any]], model="gpt-3.5-turbo-0613") -> int:
+def token_left(input: str | list[str] | dict[str, Any], model="gpt-3.5-turbo-0613") -> int:
     """Count number of tokens left for an OpenAI model.
 
     Args:
@@ -84,7 +87,7 @@ def token_left(input: Union[str, list[str], dict[str, Any]], model="gpt-3.5-turb
     return get_max_token_limit(model) - count_token(input, model=model)
 
 
-def count_token(input: Union[str, list[str], dict[str, Any]], model: str = "gpt-3.5-turbo-0613") -> int:
+def count_token(input: str | list[str] | dict[str, Any], model: str = "gpt-3.5-turbo-0613") -> int:
     """Count number of tokens used by an OpenAI model.
 
     Args:
@@ -112,7 +115,7 @@ def _num_token_from_text(text: str, model: str = "gpt-3.5-turbo-0613"):
     return len(encoding.encode(text))
 
 
-def _num_token_from_messages(messages: Union[list[str], dict[str, Any]], model="gpt-3.5-turbo-0613"):
+def _num_token_from_messages(messages: list[str] | dict[str, Any], model="gpt-3.5-turbo-0613"):
     """Return the number of tokens used by a list of messages.
 
     retrieved from https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb/

autogen/tools/contrib/time/time.py

@@ -26,7 +26,6 @@ class TimeTool(Tool):
         Args:
             date_time_format (str, optional): The format of the date and time. Defaults to "%Y-%m-%d %H:%M:%S".
         """
-
         self._date_time_format = date_time_format
 
         async def get_date_and_time(

autogen/tools/dependency_injection.py

@@ -6,8 +6,9 @@ import functools
 import inspect
 import sys
 from abc import ABC
+from collections.abc import Callable, Iterable
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Optional, TypeVar, Union, get_type_hints
+from typing import TYPE_CHECKING, Any, TypeVar, get_type_hints
 
 from ..agentchat import Agent
 from ..doc_utils import export_module
@@ -67,7 +68,7 @@ class ChatContext(BaseContext):
         return self._agent.chat_messages
 
     @property
-    def last_message(self) -> Optional[dict[str, Any]]:
+    def last_message(self) -> dict[str, Any] | None:
         """The last message in the chat.
 
         Returns:
@@ -102,7 +103,7 @@ def Depends(x: Any) -> Any:  # noqa: N802
     return FastDepends(x)
 
 
-def get_context_params(func: Callable[..., Any], subclass: Union[type[BaseContext], type[ChatContext]]) -> list[str]:
+def get_context_params(func: Callable[..., Any], subclass: type[BaseContext] | type[ChatContext]) -> list[str]:
     """Gets the names of the context parameters in a function signature.
 
     Args:
@@ -116,9 +117,7 @@ def get_context_params(func: Callable[..., Any], subclass: Union[type[BaseContex
     return [p.name for p in sig.parameters.values() if _is_context_param(p, subclass=subclass)]
 
 
-def _is_context_param(
-    param: inspect.Parameter, subclass: Union[type[BaseContext], type[ChatContext]] = BaseContext
-) -> bool:
+def _is_context_param(param: inspect.Parameter, subclass: type[BaseContext] | type[ChatContext] = BaseContext) -> bool:
     # param.annotation.__args__[0] is used to handle Annotated[MyContext, Depends(MyContext(b=2))]
     param_annotation = param.annotation.__args__[0] if hasattr(param.annotation, "__args__") else param.annotation
     try:

autogen/tools/experimental/browser_use/browser_use.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any, Optional
 
 from pydantic import BaseModel, field_validator
 
@@ -32,11 +32,11 @@ class ExtractedContent(BaseModel):
     """
 
     content: str
-    url: Optional[str]
+    url: str | None
 
     @field_validator("url")
     @classmethod
-    def check_url(cls, v: str) -> Optional[str]:
+    def check_url(cls, v: str) -> str | None:
         """Check if the URL is about:blank and return None if it is.
 
         Args:
@@ -57,7 +57,7 @@ class BrowserUseResult(BaseModel):
     """
 
     extracted_content: list[ExtractedContent]
-    final_result: Optional[str]
+    final_result: str | None
 
 
 @require_optional_import(
@@ -78,10 +78,10 @@ class BrowserUseTool(Tool):
     def __init__(  # type: ignore[no-any-unimported]
         self,
         *,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
         browser: Optional["Browser"] = None,
-        agent_kwargs: Optional[dict[str, Any]] = None,
-        browser_config: Optional[dict[str, Any]] = None,
+        agent_kwargs: dict[str, Any] | None = None,
+        browser_config: dict[str, Any] | None = None,
     ):
         """Use the browser to perform a task.
 
@@ -104,8 +104,8 @@ class BrowserUseTool(Tool):
 
         async def browser_use(  # type: ignore[no-any-unimported]
             task: Annotated[str, "The task to perform."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
-            browser: Annotated[Optional[Browser], Depends(on(browser))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
+            browser: Annotated[Browser | None, Depends(on(browser))],
             agent_kwargs: Annotated[dict[str, Any], Depends(on(agent_kwargs))],
             browser_config: Annotated[dict[str, Any], Depends(on(browser_config))],
         ) -> BrowserUseResult:
@@ -145,7 +145,7 @@ class BrowserUseTool(Tool):
         )
 
     @staticmethod
-    def _get_controller(llm_config: Union[LLMConfig, dict[str, Any]]) -> Any:
+    def _get_controller(llm_config: LLMConfig | dict[str, Any]) -> Any:
         response_format = (
             llm_config["config_list"][0].get("response_format", None)
             if "config_list" in llm_config

autogen/tools/experimental/code_execution/python_code_execution.py

@@ -4,7 +4,7 @@
 
 import os
 import tempfile
-from typing import Annotated, Any, Optional
+from typing import Annotated, Any
 
 from pydantic import BaseModel, Field
 
@@ -24,11 +24,10 @@ class PythonCodeExecutionTool(Tool):
         self,
         *,
         timeout: int = 30,
-        working_directory: Optional[WorkingDirectory] = None,
-        python_environment: Optional[PythonEnvironment] = None,
+        working_directory: WorkingDirectory | None = None,
+        python_environment: PythonEnvironment | None = None,
     ) -> None:
-        """
-        Initialize the PythonCodeExecutionTool.
+        """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.
 
@@ -56,8 +55,7 @@ class PythonCodeExecutionTool(Tool):
         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.
+            """Executes Python code in the attached environment and returns the result.
 
             Args:
                 code_execution_request (CodeExecutionRequest): The Python code and libraries to execute

autogen/tools/experimental/crawl4ai/crawl4ai.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any, Optional
 
 from pydantic import BaseModel
 
@@ -23,18 +23,15 @@ __all__ = ["Crawl4AITool"]
 @require_optional_import(["crawl4ai"], "crawl4ai")
 @export_module("autogen.tools.experimental")
 class Crawl4AITool(Tool):
-    """
-    Crawl a website and extract information using the crawl4ai library.
-    """
+    """Crawl a website and extract information using the crawl4ai library."""
 
     def __init__(
         self,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        extraction_model: Optional[type[BaseModel]] = None,
-        llm_strategy_kwargs: Optional[dict[str, Any]] = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        extraction_model: type[BaseModel] | None = None,
+        llm_strategy_kwargs: dict[str, Any] | None = None,
     ) -> None:
-        """
-        Initialize the Crawl4AITool.
+        """Initialize the Crawl4AITool.
 
         Args:
             llm_config: The config dictionary for the LLM model. If None, the tool will run without LLM.
@@ -70,8 +67,8 @@ class Crawl4AITool(Tool):
             url: Annotated[str, "The url to crawl and extract information from."],
             instruction: Annotated[str, "The instruction to provide on how and what to extract."],
             llm_config: Annotated[Any, Depends(on(llm_config))],
-            llm_strategy_kwargs: Annotated[Optional[dict[str, Any]], Depends(on(llm_strategy_kwargs))],
-            extraction_model: Annotated[Optional[type[BaseModel]], Depends(on(extraction_model))],
+            llm_strategy_kwargs: Annotated[dict[str, Any] | None, Depends(on(llm_strategy_kwargs))],
+            extraction_model: Annotated[type[BaseModel] | None, Depends(on(extraction_model))],
         ) -> Any:
             browser_cfg = BrowserConfig(headless=True)
             crawl_config = Crawl4AITool._get_crawl_config(
@@ -90,7 +87,7 @@ class Crawl4AITool(Tool):
         )
 
     @staticmethod
-    def _validate_llm_strategy_kwargs(llm_strategy_kwargs: Optional[dict[str, Any]], llm_config_provided: bool) -> None:
+    def _validate_llm_strategy_kwargs(llm_strategy_kwargs: dict[str, Any] | None, llm_config_provided: bool) -> None:
         if not llm_strategy_kwargs:
             return
 
@@ -120,10 +117,10 @@ class Crawl4AITool(Tool):
 
     @staticmethod
     def _get_crawl_config(  # type: ignore[no-any-unimported]
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         instruction: str,
-        llm_strategy_kwargs: Optional[dict[str, Any]] = None,
-        extraction_model: Optional[type[BaseModel]] = None,
+        llm_strategy_kwargs: dict[str, Any] | None = None,
+        extraction_model: type[BaseModel] | None = None,
     ) -> "CrawlerRunConfig":
         lite_llm_config = LiteLLmConfigFactory.create_lite_llm_config(llm_config)
 

autogen/tools/experimental/deep_research/deep_research.py

@@ -3,7 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import copy
-from typing import Annotated, Any, Callable, Union
+from collections.abc import Callable
+from typing import Annotated, Any
 
 from pydantic import BaseModel, Field
 
@@ -77,7 +78,7 @@ class DeepResearchTool(Tool):
 
     def __init__(
         self,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int = 30,
     ):
         """Initialize the DeepResearchTool.
@@ -117,7 +118,7 @@ class DeepResearchTool(Tool):
 
         def delegate_research_task(
             task: Annotated[str, "The task to perform a research on."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             """Delegate a research task to the agent.
@@ -165,11 +166,11 @@ class DeepResearchTool(Tool):
 
     @staticmethod
     def _get_split_question_and_answer_subquestions(
-        llm_config: Union[LLMConfig, dict[str, Any]], max_web_steps: int
+        llm_config: LLMConfig | dict[str, Any], max_web_steps: int
     ) -> Callable[..., Any]:
         def split_question_and_answer_subquestions(
             question: Annotated[str, "The question to split and answer."],
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             decomposition_agent = ConversableAgent(
@@ -233,7 +234,7 @@ class DeepResearchTool(Tool):
 
     @staticmethod
     def _get_generate_subquestions(
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int,
     ) -> Callable[..., str]:
         """Get the generate_subquestions method.
@@ -248,7 +249,7 @@ class DeepResearchTool(Tool):
 
         def generate_subquestions(
             task: Task,
-            llm_config: Annotated[Union[LLMConfig, dict[str, Any]], Depends(on(llm_config))],
+            llm_config: Annotated[LLMConfig | dict[str, Any], Depends(on(llm_config))],
             max_web_steps: Annotated[int, Depends(on(max_web_steps))],
         ) -> str:
             if not task.subquestions:
@@ -270,7 +271,7 @@ class DeepResearchTool(Tool):
     @staticmethod
     def _answer_question(
         question: str,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
         max_web_steps: int,
     ) -> str:
         from ....agents.experimental.websurfer import WebSurferAgent

autogen/tools/experimental/duckduckgo/duckduckgo_search.py

@@ -21,8 +21,7 @@ def _execute_duckduckgo_query(
     query: str,
     num_results: int = 5,
 ) -> list[dict[str, Any]]:
-    """
-    Execute a search query using the DuckDuckGo Search API.
+    """Execute a search query using the DuckDuckGo Search API.
 
     Args:
         query (str): The search query string.
@@ -45,8 +44,7 @@ def _duckduckgo_search(
     query: str,
     num_results: int = 5,
 ) -> list[dict[str, Any]]:
-    """
-    Perform a DuckDuckGo search and format the results.
+    """Perform a DuckDuckGo search and format the results.
 
     This function takes search parameters, executes the query using `_execute_duckduckgo_query`,
     and formats the results into a list of dictionaries containing title, link, and snippet.
@@ -71,24 +69,20 @@ def _duckduckgo_search(
 
 @export_module("autogen.tools.experimental")
 class DuckDuckGoSearchTool(Tool):
-    """
-    DuckDuckGoSearchTool is a tool that uses DuckDuckGo to perform a search.
+    """DuckDuckGoSearchTool is a tool that uses DuckDuckGo to perform a search.
 
     This tool allows agents to leverage the DuckDuckGo search engine for information retrieval.
     DuckDuckGo does not require an API key, making it easy to use.
     """
 
     def __init__(self) -> None:
-        """
-        Initializes the DuckDuckGoSearchTool.
-        """
+        """Initializes the DuckDuckGoSearchTool."""
 
         def duckduckgo_search(
             query: Annotated[str, "The search query."],
             num_results: Annotated[int, "The number of results to return."] = 5,
         ) -> list[dict[str, Any]]:
-            """
-            Performs a search using the DuckDuckGo Search API and returns formatted results.
+            """Performs a search using the DuckDuckGo Search API and returns formatted results.
 
             Args:
                 query: The search query string.