ag2 0.9.7__py3-none-any.whl → 0.9.9__py3-none-any.whl

autogen/llm_config/config.py

@@ -0,0 +1,384 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import functools
+import json
+import re
+from collections.abc import Iterable
+from contextvars import ContextVar
+from pathlib import Path
+from typing import Annotated, Any, Literal, TypeAlias
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from autogen.oai.anthropic import AnthropicEntryDict, AnthropicLLMConfigEntry
+from autogen.oai.bedrock import BedrockEntryDict, BedrockLLMConfigEntry
+from autogen.oai.cerebras import CerebrasEntryDict, CerebrasLLMConfigEntry
+from autogen.oai.client import (
+    AzureOpenAIEntryDict,
+    AzureOpenAILLMConfigEntry,
+    DeepSeekEntyDict,
+    DeepSeekLLMConfigEntry,
+    OpenAIEntryDict,
+    OpenAILLMConfigEntry,
+    OpenAIResponsesLLMConfigEntry,
+)
+from autogen.oai.cohere import CohereEntryDict, CohereLLMConfigEntry
+from autogen.oai.gemini import GeminiEntryDict, GeminiLLMConfigEntry
+from autogen.oai.groq import GroqEntryDict, GroqLLMConfigEntry
+from autogen.oai.mistral import MistralEntryDict, MistralLLMConfigEntry
+from autogen.oai.ollama import OllamaEntryDict, OllamaLLMConfigEntry
+from autogen.oai.together import TogetherEntryDict, TogetherLLMConfigEntry
+
+from ..doc_utils import export_module
+from .entry import ApplicationConfig, LLMConfigEntry
+
+
+# Meta class to allow LLMConfig.current and LLMConfig.default to be used as class properties
+class MetaLLMConfig(type):
+    def __init__(cls, *args: Any, **kwargs: Any) -> None:
+        pass
+
+    @property
+    def current(cls) -> "LLMConfig":
+        current_llm_config = LLMConfig.get_current_llm_config(llm_config=None)
+        if current_llm_config is None:
+            raise ValueError("No current LLMConfig set. Are you inside a context block?")
+        return current_llm_config  # type: ignore[return-value]
+
+    @property
+    def default(cls) -> "LLMConfig":
+        return cls.current
+
+
+ConfigItem: TypeAlias = (
+    LLMConfigEntry
+    | AnthropicEntryDict
+    | BedrockEntryDict
+    | CerebrasEntryDict
+    | CohereEntryDict
+    | AzureOpenAIEntryDict
+    | OpenAIEntryDict
+    | DeepSeekEntyDict
+    | MistralEntryDict
+    | GroqEntryDict
+    | OllamaEntryDict
+    | GeminiEntryDict
+    | TogetherEntryDict
+    | dict[str, Any]
+)
+
+
+@export_module("autogen")
+class LLMConfig(metaclass=MetaLLMConfig):
+    _current_llm_config: ContextVar["LLMConfig"] = ContextVar("current_llm_config")
+
+    def __init__(
+        self,
+        *,
+        top_p: float | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        config_list: Iterable[ConfigItem] | dict[str, Any] = (),
+        check_every_ms: int | None = None,
+        allow_format_str_template: bool | None = None,
+        response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None,
+        timeout: int | None = None,
+        seed: int | None = None,
+        cache_seed: int | None = None,
+        parallel_tool_calls: bool | None = None,
+        tools: Iterable[Any] = (),
+        functions: Iterable[Any] = (),
+        routing_method: Literal["fixed_order", "round_robin"] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        """Initializes the LLMConfig object.
+
+        Args:
+            config_list: A list of LLM configuration entries or dictionaries.
+            temperature: The sampling temperature for LLM generation.
+            check_every_ms: The interval (in milliseconds) to check for updates
+            allow_format_str_template: Whether to allow format string templates.
+            response_format: The format of the response (e.g., JSON, text).
+            timeout: The timeout for LLM requests in seconds.
+            seed: The random seed for reproducible results.
+            cache_seed: The seed for caching LLM responses.
+            parallel_tool_calls: Whether to enable parallel tool calls.
+            tools: A list of tools available for the LLM.
+            functions: A list of functions available for the LLM.
+            max_tokens: The maximum number of tokens to generate.
+            top_p: The nucleus sampling probability.
+            routing_method: The method used to route requests (e.g., fixed_order, round_robin).
+            **kwargs: Additional keyword arguments for future extensions.
+
+        Examples:
+            ```python
+            # Example 1: create config from `kwargs` options
+            config = LLMConfig(
+                model="gpt-4o-mini",
+                api_key=os.environ["OPENAI_API_KEY"],
+            )
+
+            # Example 2: create config from `config_list` dictionary
+            config = LLMConfig(
+                config_list={
+                    "model": "gpt-4o-mini",
+                    "api_key": os.environ["OPENAI_API_KEY"],
+                }
+            )
+
+            # Example 3: create config from `config_list` list
+            config = LLMConfig(
+                config_list=[
+                    {
+                        "model": "gpt-4o-mini",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                    {
+                        "model": "gpt-4",
+                        "api_key": os.environ["OPENAI_API_KEY"],
+                    },
+                ]
+            )
+            ```
+        """
+        app_config = ApplicationConfig(
+            max_tokens=max_tokens,
+            top_p=top_p,
+            temperature=temperature,
+        )
+
+        application_level_options = app_config.model_dump(exclude_none=True)
+
+        final_config_list: list[LLMConfigEntry | dict[str, Any]] = []
+
+        if isinstance(config_list, dict):
+            config_list = [config_list]
+
+        for c in filter(bool, (*config_list, kwargs)):
+            if isinstance(c, LLMConfigEntry):
+                final_config_list.append(c.apply_application_config(app_config))
+                continue
+
+            else:
+                final_config_list.append({
+                    "api_type": "openai",  # default api_type
+                    **application_level_options,
+                    **c,
+                })
+
+        self._model = _LLMConfig(
+            **application_level_options,
+            config_list=final_config_list,
+            check_every_ms=check_every_ms,
+            seed=seed,
+            allow_format_str_template=allow_format_str_template,
+            response_format=response_format,
+            timeout=timeout,
+            cache_seed=cache_seed,
+            tools=tools or [],
+            functions=functions or [],
+            parallel_tool_calls=parallel_tool_calls,
+            routing_method=routing_method,
+        )
+
+    # used by BaseModel to create instance variables
+    def __enter__(self) -> "LLMConfig":
+        # Store previous context and set self as current
+        self._token = LLMConfig._current_llm_config.set(self)
+        return self
+
+    def __exit__(self, exc_type: type[Exception], exc_val: Exception, exc_tb: Any) -> None:
+        LLMConfig._current_llm_config.reset(self._token)
+
+    @classmethod
+    def get_current_llm_config(cls, llm_config: "LLMConfig | None" = None) -> "LLMConfig | None":
+        if llm_config is not None:
+            return llm_config
+        try:
+            return (LLMConfig._current_llm_config.get()).copy()
+        except LookupError:
+            return None
+
+    def _satisfies_criteria(self, value: Any, criteria_values: Any) -> bool:
+        if value is None:
+            return False
+
+        if isinstance(value, list):
+            return bool(set(value) & set(criteria_values))  # Non-empty intersection
+        else:
+            return value in criteria_values
+
+    @classmethod
+    def from_json(
+        cls,
+        *,
+        env: str | None = None,
+        path: str | Path | None = None,
+        file_location: str | None = None,
+        **kwargs: Any,
+    ) -> "LLMConfig":
+        from autogen.oai.openai_utils import config_list_from_json
+
+        if env is None and path is None:
+            raise ValueError("Either 'env' or 'path' must be provided")
+        if env is not None and path is not None:
+            raise ValueError("Only one of 'env' or 'path' can be provided")
+
+        config_list = config_list_from_json(
+            env_or_file=env if env is not None else str(path), file_location=file_location
+        )
+        return LLMConfig(config_list=config_list, **kwargs)
+
+    def where(self, *, exclude: bool = False, **kwargs: Any) -> "LLMConfig":
+        from autogen.oai.openai_utils import filter_config
+
+        filtered_config_list = filter_config(config_list=self.config_list, filter_dict=kwargs, exclude=exclude)
+        if len(filtered_config_list) == 0:
+            raise ValueError(f"No config found that satisfies the filter criteria: {kwargs}")
+
+        kwargs = self.model_dump()
+        kwargs["config_list"] = filtered_config_list
+
+        return LLMConfig(**kwargs)
+
+    # @functools.wraps(BaseModel.model_dump)
+    def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
+        d = self._model.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return {k: v for k, v in d.items() if not (isinstance(v, list) and len(v) == 0)}
+
+    # @functools.wraps(BaseModel.model_dump_json)
+    def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
+        # return self._model.model_dump_json(*args, exclude_none=exclude_none, **kwargs)
+        d = self.model_dump(*args, exclude_none=exclude_none, **kwargs)
+        return json.dumps(d)
+
+    # @functools.wraps(BaseModel.model_validate)
+    def model_validate(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_json)
+    def model_validate_json(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_json(*args, **kwargs)
+
+    @functools.wraps(BaseModel.model_validate_strings)
+    def model_validate_strings(self, *args: Any, **kwargs: Any) -> Any:
+        return self._model.model_validate_strings(*args, **kwargs)
+
+    def __eq__(self, value: Any) -> bool:
+        if not isinstance(value, LLMConfig):
+            return NotImplemented
+        return self._model == value._model
+
+    def _getattr(self, o: object, name: str) -> Any:
+        val = getattr(o, name)
+        return val
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        val = getattr(self._model, key, default)
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            return self._getattr(self._model, key)
+        except AttributeError:
+            raise KeyError(f"Key '{key}' not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        try:
+            setattr(self._model, key, value)
+        except ValueError:
+            raise ValueError(f"'{self.__class__.__name__}' object has no field '{key}'")
+
+    def __getattr__(self, name: Any) -> Any:
+        try:
+            return self._getattr(self._model, name)
+        except AttributeError:
+            raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name == "_model":
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._model, name, value)
+
+    def __contains__(self, key: str) -> bool:
+        return hasattr(self._model, key)
+
+    def __repr__(self) -> str:
+        d = self.model_dump()
+        r = [f"{k}={repr(v)}" for k, v in d.items()]
+
+        s = f"LLMConfig({', '.join(r)})"
+        # Replace any keys ending with 'key' or 'token' values with stars for security
+        s = re.sub(
+            r"(['\"])(\w*(key|token))\1:\s*(['\"])([^'\"]*)(?:\4)", r"\1\2\1: \4**********\4", s, flags=re.IGNORECASE
+        )
+        return s
+
+    def __copy__(self) -> "LLMConfig":
+        return LLMConfig(**self.model_dump())
+
+    def __deepcopy__(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__copy__()
+
+    def copy(self) -> "LLMConfig":
+        return self.__copy__()
+
+    def deepcopy(self, memo: dict[int, Any] | None = None) -> "LLMConfig":
+        return self.__deepcopy__(memo)
+
+    def __str__(self) -> str:
+        return repr(self)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        d = self.model_dump()
+        return d.items()
+
+    def keys(self) -> Iterable[str]:
+        d = self.model_dump()
+        return d.keys()
+
+    def values(self) -> Iterable[Any]:
+        d = self.model_dump()
+        return d.values()
+
+    _base_model_classes: dict[tuple[type["LLMConfigEntry"], ...], type[BaseModel]] = {}
+
+
+class _LLMConfig(ApplicationConfig):
+    check_every_ms: int | None
+    seed: int | None
+    allow_format_str_template: bool | None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None
+    timeout: int | None
+    cache_seed: int | None
+    parallel_tool_calls: bool | None
+
+    tools: list[Any]
+    functions: list[Any]
+
+    config_list: list[  # type: ignore[valid-type]
+        Annotated[
+            AnthropicLLMConfigEntry
+            | CerebrasLLMConfigEntry
+            | BedrockLLMConfigEntry
+            | AzureOpenAILLMConfigEntry
+            | DeepSeekLLMConfigEntry
+            | OpenAILLMConfigEntry
+            | OpenAIResponsesLLMConfigEntry
+            | CohereLLMConfigEntry
+            | GeminiLLMConfigEntry
+            | GroqLLMConfigEntry
+            | MistralLLMConfigEntry
+            | OllamaLLMConfigEntry
+            | TogetherLLMConfigEntry,
+            Field(discriminator="api_type"),
+        ],
+    ] = Field(..., min_length=1)
+
+    routing_method: Literal["fixed_order", "round_robin"] | None
+
+    # Following field is configuration for pydantic to disallow extra fields
+    model_config = ConfigDict(extra="forbid")

autogen/llm_config/entry.py

@@ -0,0 +1,154 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import re
+from abc import ABC, abstractmethod
+from collections.abc import Iterable, Mapping
+from typing import Any
+
+from httpx import Client as httpxClient
+from pydantic import BaseModel, ConfigDict, Field, HttpUrl, SecretStr, ValidationInfo, field_serializer, field_validator
+from typing_extensions import Required, TypedDict
+
+from .client import ModelClient
+
+
+class LLMConfigEntryDict(TypedDict, total=False):
+    api_type: Required[str]
+    model: str
+    max_tokens: int | None
+    top_p: float | None
+    temperature: float | None
+
+    api_key: SecretStr | None
+    api_version: str | None
+    base_url: HttpUrl | None
+    voice: str | None
+    http_client: httpxClient | None
+    model_client_cls: str | None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None
+    default_headers: Mapping[str, Any] | None
+    tags: list[str]
+
+
+class ApplicationConfig(BaseModel):
+    max_tokens: int | None = Field(default=None, ge=0)
+    top_p: float | None = Field(default=None, gt=0, lt=1)
+    temperature: float | None = Field(default=None, ge=0, le=1)
+
+    @field_validator("top_p", mode="before")
+    @classmethod
+    def check_top_p(cls, v: float | None, info: ValidationInfo) -> float | None:
+        if v is not None and info.data.get("temperature") is not None:
+            raise ValueError("temperature and top_p cannot be set at the same time.")
+        return v
+
+    @field_validator("temperature", mode="before")
+    @classmethod
+    def check_temperature(cls, v: float | None, info: ValidationInfo) -> float | None:
+        if v is not None and info.data.get("top_p") is not None:
+            raise ValueError("temperature and top_p cannot be set at the same time.")
+        return v
+
+
+class LLMConfigEntry(ApplicationConfig, ABC):
+    api_type: str
+    model: str = Field(..., min_length=1)
+
+    api_key: SecretStr | None = None
+    api_version: str | None = None
+    base_url: HttpUrl | None = None
+    voice: str | None = None
+    model_client_cls: str | None = None
+    http_client: httpxClient | None = None
+    response_format: str | dict[str, Any] | BaseModel | type[BaseModel] | None = None
+    default_headers: Mapping[str, Any] | None = None
+    tags: list[str] = Field(default_factory=list)
+
+    # Following field is configuration for pydantic to disallow extra fields
+    model_config = ConfigDict(extra="allow", arbitrary_types_allowed=True)
+
+    def apply_application_config(self, application_config: ApplicationConfig) -> "LLMConfigEntry":
+        """Apply application level configurations."""
+        # TODO: should create a new instance instead of mutating current one
+        self.max_tokens = self.max_tokens or application_config.max_tokens
+        self.top_p = self.top_p or application_config.top_p
+        self.temperature = self.temperature or application_config.temperature
+        return self
+
+    @abstractmethod
+    def create_client(self) -> "ModelClient": ...
+
+    @field_validator("base_url", mode="before")
+    @classmethod
+    def check_base_url(cls, v: HttpUrl | str | None, info: ValidationInfo) -> str | None:
+        if v is None:  # Handle None case explicitly
+            return None
+        if not str(v).startswith("https://") and not str(v).startswith("http://"):
+            return f"http://{str(v)}"
+        return str(v)
+
+    @field_serializer("base_url", when_used="unless-none")  # Ensure serializer also respects None
+    def serialize_base_url(self, v: HttpUrl | None) -> str | None:
+        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) -> str:
+        return v.get_secret_value()
+
+    def model_dump(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> dict[str, Any]:
+        return BaseModel.model_dump(self, exclude_none=exclude_none, *args, **kwargs)
+
+    def model_dump_json(self, *args: Any, exclude_none: bool = True, **kwargs: Any) -> str:
+        return BaseModel.model_dump_json(self, exclude_none=exclude_none, *args, **kwargs)
+
+    def get(self, key: str, default: Any | None = None) -> Any:
+        val = getattr(self, key, default)
+        if isinstance(val, SecretStr):
+            return val.get_secret_value()
+        return val
+
+    def __getitem__(self, key: str) -> Any:
+        try:
+            val = getattr(self, key)
+            if isinstance(val, SecretStr):
+                return val.get_secret_value()
+            return val
+        except AttributeError:
+            raise KeyError(f"Key '{key}' not found in {self.__class__.__name__}")
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        setattr(self, key, value)
+
+    def __contains__(self, key: str) -> bool:
+        return hasattr(self, key)
+
+    def items(self) -> Iterable[tuple[str, Any]]:
+        d = self.model_dump()
+        return d.items()
+
+    def keys(self) -> Iterable[str]:
+        d = self.model_dump()
+        return d.keys()
+
+    def values(self) -> Iterable[Any]:
+        d = self.model_dump()
+        return d.values()
+
+    def __repr__(self) -> str:
+        # Override to eliminate none values from the repr
+        d = self.model_dump()
+        r = [f"{k}={repr(v)}" for k, v in d.items()]
+
+        s = f"{self.__class__.__name__}({', '.join(r)})"
+
+        # Replace any keys ending with '_key' or '_token' values with stars for security
+        # This regex will match any key ending with '_key' or '_token' and its value, and replace the value with stars
+        # It also captures the type of quote used (single or double) and reuses it in the replacement
+        s = re.sub(r'(\w+_(key|token)\s*=\s*)([\'"]).*?\3', r"\1\3**********\3", s, flags=re.IGNORECASE)
+
+        return s
+
+    def __str__(self) -> str:
+        return repr(self)

autogen/logger/base_logger.py

@@ -9,7 +9,8 @@ from __future__ import annotations
 import sqlite3
 import uuid
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Callable, TypeVar, Union
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
 
 if TYPE_CHECKING:
     from openai import AzureOpenAI, OpenAI
@@ -18,8 +19,8 @@ if TYPE_CHECKING:
     from .. import Agent, ConversableAgent, OpenAIWrapper
 
 F = TypeVar("F", bound=Callable[..., Any])
-ConfigItem = dict[str, Union[str, list[str]]]
-LLMConfig = dict[str, Union[None, float, int, ConfigItem, list[ConfigItem]]]
+ConfigItem = dict[str, str | list[str]]
+LLMConfig = dict[str, None | float | int | ConfigItem | list[ConfigItem]]
 
 
 class BaseLogger(ABC):

autogen/logger/file_logger.py

@@ -11,7 +11,8 @@ import logging
 import os
 import threading
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from ..doc_utils import export_module
 from .base_logger import BaseLogger, LLMConfig

autogen/logger/logger_factory.py

@@ -4,7 +4,7 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 from ..doc_utils import export_module
 from .base_logger import BaseLogger
@@ -20,7 +20,7 @@ class LoggerFactory:
 
     @staticmethod
     def get_logger(
-        logger_type: Literal["sqlite", "file"] = "sqlite", config: Optional[dict[str, Any]] = None
+        logger_type: Literal["sqlite", "file"] = "sqlite", config: dict[str, Any] | None = None
     ) -> BaseLogger:
         """Factory method to create logger objects.
 

autogen/logger/logger_utils.py

@@ -7,7 +7,7 @@
 import inspect
 from datetime import datetime, timezone
 from pathlib import Path, PurePath
-from typing import Any, Union
+from typing import Any
 
 __all__ = ("get_current_ts", "to_dict")
 
@@ -22,7 +22,7 @@ def get_current_ts() -> str:
 
 
 def to_dict(
-    obj: Union[int, float, str, bool, dict[Any, Any], list[Any], tuple[Any, ...], Any],
+    obj: int | float | str | bool | dict[Any, Any] | list[Any] | tuple[Any, ...] | Any,
     exclude: tuple[str, ...] = (),
     no_recursive: tuple[Any, ...] = (),
 ) -> Any:

autogen/logger/sqlite_logger.py

@@ -12,7 +12,8 @@ import os
 import sqlite3
 import threading
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, TypeVar
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from ..doc_utils import export_module
 from .base_logger import BaseLogger, LLMConfig

autogen/math_utils.py

@@ -4,10 +4,9 @@
 #
 # Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
 # SPDX-License-Identifier: MIT
-from typing import Optional
 
 
-def remove_boxed(string: str) -> Optional[str]:
+def remove_boxed(string: str) -> str | None:
     """Source: https://github.com/hendrycks/math
     Extract the text within a \\boxed`{...}` environment.
 
@@ -28,7 +27,7 @@ def remove_boxed(string: str) -> Optional[str]:
         return None
 
 
-def last_boxed_only_string(string: str) -> Optional[str]:
+def last_boxed_only_string(string: str) -> str | None:
     """Source: https://github.com/hendrycks/math
     Extract the last \\boxed`{...}` or \\fbox`{...}` element from a string.
     """
@@ -239,7 +238,7 @@ def _strip_string(string: str) -> str:
     return string
 
 
-def get_answer(solution: Optional[str]) -> Optional[str]:
+def get_answer(solution: str | None) -> str | None:
     if solution is None:
         return None
     last_boxed = last_boxed_only_string(solution)
@@ -251,7 +250,7 @@ def get_answer(solution: Optional[str]) -> Optional[str]:
     return answer
 
 
-def is_equiv(str1: Optional[str], str2: Optional[str]) -> float:
+def is_equiv(str1: str | None, str2: str | None) -> float:
     """Returns (as a float) whether two strings containing math are equivalent up to differences of formatting in
     - units
     - fractions