ag2 0.9.1a1__py3-none-any.whl → 0.9.1.post0__py3-none-any.whl

autogen/events/base_event.py

@@ -0,0 +1,99 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+from abc import ABC
+from typing import Annotated, Any, Callable, Literal, Optional, Union
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, create_model
+
+from ..doc_utils import export_module
+
+__all__ = ["BaseEvent", "get_annotated_type_for_event_classes", "get_event_classes", "wrap_event"]
+
+
+@export_module("autogen.events")
+class BaseEvent(BaseModel, ABC):
+    uuid: UUID
+
+    def __init__(self, uuid: Optional[UUID] = None, **kwargs: Any) -> None:
+        uuid = uuid or uuid4()
+        super().__init__(uuid=uuid, **kwargs)
+
+    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        """Print event
+
+        Args:
+            f (Optional[Callable[..., Any]], optional): Print function. If none, python's default print will be used.
+        """
+        ...
+
+
+def camel2snake(name: str) -> str:
+    return "".join(["_" + i.lower() if i.isupper() else i for i in name]).lstrip("_")
+
+
+_event_classes: dict[str, type[BaseModel]] = {}
+
+
+@export_module("autogen.events")
+def wrap_event(event_cls: type[BaseEvent]) -> type[BaseModel]:
+    """Wrap a event class with a type field to be used in a union type
+
+    This is needed for proper serialization and deserialization of events in a union type.
+
+    Args:
+        event_cls (type[BaseEvent]): Event class to wrap
+    """
+    global _event_classes
+
+    if not event_cls.__name__.endswith("Event"):
+        raise ValueError("Event class name must end with 'Event'")
+
+    type_name = camel2snake(event_cls.__name__)
+    type_name = type_name[: -len("_event")]
+
+    class WrapperBase(BaseModel):
+        # these types are generated dynamically so we need to disable the type checker
+        type: Literal[type_name] = type_name  # type: ignore[valid-type]
+        content: event_cls  # type: ignore[valid-type]
+
+        def __init__(self, *args: Any, **data: Any):
+            if set(data.keys()) == {"type", "content"} and "content" in data:
+                super().__init__(*args, **data)
+            else:
+                if "content" in data:
+                    content = data.pop("content")
+                    super().__init__(*args, content=event_cls(*args, **data, content=content), **data)
+                else:
+                    super().__init__(content=event_cls(*args, **data), **data)
+
+        def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+            self.content.print(f)  # type: ignore[attr-defined]
+
+    wrapper_cls = create_model(event_cls.__name__, __base__=WrapperBase)
+
+    # Preserve the original class's docstring and other attributes
+    wrapper_cls.__doc__ = event_cls.__doc__
+    wrapper_cls.__module__ = event_cls.__module__
+
+    # Copy any other relevant attributes/metadata from the original class
+    if hasattr(event_cls, "__annotations__"):
+        wrapper_cls.__annotations__ = event_cls.__annotations__
+
+    _event_classes[type_name] = wrapper_cls
+
+    return wrapper_cls
+
+
+@export_module("autogen.events")
+def get_annotated_type_for_event_classes() -> type[Any]:
+    # this is a dynamic type so we need to disable the type checker
+    union_type = Union[tuple(_event_classes.values())]  # type: ignore[valid-type]
+    return Annotated[union_type, Field(discriminator="type")]  # type: ignore[return-value]
+
+
+def get_event_classes() -> dict[str, type[BaseModel]]:
+    return _event_classes

autogen/events/client_events.py

@@ -0,0 +1,167 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Callable, Literal, Optional, Union
+from uuid import UUID
+
+from pydantic import BaseModel
+
+from .base_event import BaseEvent, wrap_event
+
+__all__ = ["UsageSummaryEvent"]
+
+
+class ModelUsageSummary(BaseModel):
+    """Model usage summary."""
+
+    model: str
+    """Model name."""
+    completion_tokens: int
+    """Number of tokens used for completion."""
+    cost: float
+    """Cost of the completion."""
+    prompt_tokens: int
+    """Number of tokens used for prompt."""
+    total_tokens: int
+    """Total number of tokens used."""
+
+
+class ActualUsageSummary(BaseModel):
+    """Actual usage summary."""
+
+    usages: Optional[list[ModelUsageSummary]] = None
+    """List of model usage summaries."""
+    total_cost: Optional[float] = None
+    """Total cost."""
+
+
+class TotalUsageSummary(BaseModel):
+    """Total usage summary."""
+
+    usages: Optional[list[ModelUsageSummary]] = None
+    """List of model usage summaries."""
+    total_cost: Optional[float] = None
+    """Total cost."""
+
+
+Mode = Literal["both", "total", "actual"]
+
+
+def _change_usage_summary_format(
+    actual_usage_summary: Optional[dict[str, Any]] = None, total_usage_summary: Optional[dict[str, Any]] = None
+) -> dict[str, dict[str, Any]]:
+    summary: dict[str, Any] = {}
+
+    for usage_type, usage_summary in {"actual": actual_usage_summary, "total": total_usage_summary}.items():
+        if usage_summary is None:
+            summary[usage_type] = {"usages": None, "total_cost": None}
+            continue
+
+        usage_summary_altered_format: dict[str, list[dict[str, Any]]] = {"usages": []}
+        for k, v in usage_summary.items():
+            if isinstance(k, str) and isinstance(v, dict):
+                current_usage = {key: value for key, value in v.items()}
+                current_usage["model"] = k
+                usage_summary_altered_format["usages"].append(current_usage)
+            else:
+                usage_summary_altered_format[k] = v
+        summary[usage_type] = usage_summary_altered_format
+
+    return summary
+
+
+@wrap_event
+class UsageSummaryEvent(BaseEvent):
+    """Usage summary message."""
+
+    actual: ActualUsageSummary
+    """Actual usage summary."""
+    total: TotalUsageSummary
+    """Total usage summary."""
+    mode: Mode
+    """Mode to display the usage summary."""
+
+    def __init__(
+        self,
+        *,
+        uuid: Optional[UUID] = None,
+        actual_usage_summary: Optional[dict[str, Any]] = None,
+        total_usage_summary: Optional[dict[str, Any]] = None,
+        mode: Mode = "both",
+    ):
+        # print(f"{actual_usage_summary=}")
+        # print(f"{total_usage_summary=}")
+
+        summary_dict = _change_usage_summary_format(actual_usage_summary, total_usage_summary)
+
+        super().__init__(uuid=uuid, **summary_dict, mode=mode)
+
+    def _print_usage(
+        self,
+        usage_summary: Union[ActualUsageSummary, TotalUsageSummary],
+        usage_type: str = "total",
+        f: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        f = f or print
+        word_from_type = "including" if usage_type == "total" else "excluding"
+        if usage_summary.usages is None or len(usage_summary.usages) == 0:
+            f("No actual cost incurred (all completions are using cache).", flush=True)
+            return
+
+        f(f"Usage summary {word_from_type} cached usage: ", flush=True)
+        f(f"Total cost: {round(usage_summary.total_cost, 5)}", flush=True)  # type: ignore [arg-type]
+
+        for usage in usage_summary.usages:
+            f(
+                f"* Model '{usage.model}': cost: {round(usage.cost, 5)}, prompt_tokens: {usage.prompt_tokens}, completion_tokens: {usage.completion_tokens}, total_tokens: {usage.total_tokens}",
+                flush=True,
+            )
+
+    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        f = f or print
+
+        if self.total.usages is None:
+            f('No usage summary. Please call "create" first.', flush=True)
+            return
+
+        f("-" * 100, flush=True)
+        if self.mode == "both":
+            self._print_usage(self.actual, "actual", f)
+            f()
+            if self.total.model_dump_json() != self.actual.model_dump_json():
+                self._print_usage(self.total, "total", f)
+            else:
+                f(
+                    "All completions are non-cached: the total cost with cached completions is the same as actual cost.",
+                    flush=True,
+                )
+        elif self.mode == "total":
+            self._print_usage(self.total, "total", f)
+        elif self.mode == "actual":
+            self._print_usage(self.actual, "actual", f)
+        else:
+            raise ValueError(f'Invalid mode: {self.mode}, choose from "actual", "total", ["actual", "total"]')
+        f("-" * 100, flush=True)
+
+
+@wrap_event
+class StreamEvent(BaseEvent):
+    """Stream event."""
+
+    content: str
+    """Content of the event."""
+
+    def __init__(self, *, uuid: Optional[UUID] = None, content: str) -> None:
+        super().__init__(uuid=uuid, content=content)
+
+    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        f = f or print
+
+        # Set the terminal text color to green
+        f("\033[32m", end="")
+
+        f(self.content, end="", flush=True)
+
+        # Reset the terminal text color
+        f("\033[0m\n")

autogen/events/helpers.py

@@ -0,0 +1,36 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import logging
+from functools import wraps
+from typing import Callable
+
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+def deprecated_by(
+    new_class: type[BaseModel],
+    param_mapping: dict[str, str] = None,
+) -> Callable[[type[BaseModel]], Callable[..., BaseModel]]:
+    param_mapping = param_mapping or {}
+
+    def decorator(
+        old_class: type[BaseModel],
+        param_mapping: dict[str, str] = param_mapping,
+    ) -> Callable[..., BaseModel]:
+        @wraps(old_class)
+        def wrapper(*args, **kwargs) -> BaseModel:
+            logger.warning(
+                f"{old_class.__name__} is deprecated by {new_class.__name__}. Please import it from {new_class.__module__} and use it instead."
+            )
+            # Translate old parameters to new parameters
+            new_kwargs = {param_mapping.get(k, k): v for k, v in kwargs.items()}
+
+            # Pass the translated parameters to the new class
+            return new_class(*args, **new_kwargs)
+
+        return wrapper
+
+    return decorator

autogen/events/print_event.py

@@ -0,0 +1,46 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+import json
+from typing import Any, Callable, Optional
+from uuid import UUID
+
+from .base_event import BaseEvent, wrap_event
+
+
+@wrap_event
+class PrintEvent(BaseEvent):
+    """Print message"""
+
+    objects: list[str]
+    """List of objects to print"""
+    sep: str
+    """Separator between objects"""
+    end: str
+    """End of the print"""
+
+    def __init__(
+        self, *objects: Any, sep: str = " ", end: str = "\n", flush: bool = False, uuid: Optional[UUID] = None
+    ):
+        objects_as_string = [self._to_json(x) for x in objects]
+
+        super().__init__(uuid=uuid, objects=objects_as_string, sep=sep, end=end)
+
+    def _to_json(self, obj: Any) -> str:
+        if isinstance(obj, str):
+            return obj
+
+        if hasattr(obj, "model_dump_json"):
+            return obj.model_dump_json()  # type: ignore [no-any-return]
+        try:
+            return json.dumps(obj)
+        except Exception:
+            return str(obj)
+            # return repr(obj)
+
+    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        f = f or print
+
+        f(*self.objects, sep=self.sep, end=self.end, flush=True)

autogen/exception_utils.py

@@ -0,0 +1,73 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/microsoft/autogen are under the MIT License.
+# SPDX-License-Identifier: MIT
+from typing import Any
+
+from .doc_utils import export_module
+
+__all__ = [
+    "AgentNameConflictError",
+    "InvalidCarryOverTypeError",
+    "ModelToolNotSupportedError",
+    "NoEligibleSpeakerError",
+    "SenderRequiredError",
+    "UndefinedNextAgentError",
+]
+
+
+@export_module("autogen")
+class AgentNameConflictError(Exception):  # noqa: N818
+    def __init__(self, msg: str = "Found multiple agents with the same name.", *args: Any, **kwargs: Any):
+        super().__init__(msg, *args, **kwargs)
+
+
+@export_module("autogen")
+class NoEligibleSpeakerError(Exception):  # noqa: N818
+    """Exception raised for early termination of a GroupChat."""
+
+    def __init__(self, message: str = "No eligible speakers."):
+        self.message = message
+        super().__init__(self.message)
+
+
+@export_module("autogen")
+class SenderRequiredError(Exception):  # noqa: N818
+    """Exception raised when the sender is required but not provided."""
+
+    def __init__(self, message: str = "Sender is required but not provided."):
+        self.message = message
+        super().__init__(self.message)
+
+
+@export_module("autogen")
+class InvalidCarryOverTypeError(Exception):  # noqa: N818
+    """Exception raised when the carryover type is invalid."""
+
+    def __init__(
+        self, message: str = "Carryover should be a string or a list of strings. Not adding carryover to the message."
+    ):
+        self.message = message
+        super().__init__(self.message)
+
+
+@export_module("autogen")
+class UndefinedNextAgentError(Exception):  # noqa: N818
+    """Exception raised when the provided next agents list does not overlap with agents in the group."""
+
+    def __init__(self, message: str = "The provided agents list does not overlap with agents in the group."):
+        self.message = message
+        super().__init__(self.message)
+
+
+class ModelToolNotSupportedError(Exception):
+    """Exception raised when attempting to use tools with models that do not support them."""
+
+    def __init__(
+        self,
+        model: str,
+    ):
+        self.message = f"Tools are not supported with {model} models. Refer to the documentation at https://platform.openai.com/docs/guides/reasoning#limitations"
+        super().__init__(self.message)

autogen/extensions/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+__all__: list[str] = []

autogen/fast_depends/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
+# SPDX-License-Identifier: MIT
+
+from .dependencies import Provider, dependency_provider
+from .use import Depends, inject
+
+__all__ = (
+    "Depends",
+    "Provider",
+    "dependency_provider",
+    "inject",
+)

autogen/fast_depends/_compat.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
+# SPDX-License-Identifier: MIT
+
+import sys
+from importlib.metadata import version as get_version
+from typing import Any, Dict, Optional, Tuple, Type
+
+from pydantic import BaseModel, create_model
+from pydantic.version import VERSION as PYDANTIC_VERSION
+
+__all__ = (
+    "PYDANTIC_V2",
+    "BaseModel",
+    "ConfigDict",
+    "ExceptionGroup",
+    "create_model",
+    "evaluate_forwardref",
+    "get_config_base",
+)
+
+
+PYDANTIC_V2 = PYDANTIC_VERSION.startswith("2.")
+
+default_pydantic_config = {"arbitrary_types_allowed": True}
+
+evaluate_forwardref: Any
+# isort: off
+if PYDANTIC_V2:
+    from pydantic import ConfigDict
+    from pydantic._internal._typing_extra import (  # type: ignore[no-redef]
+        eval_type_lenient as evaluate_forwardref,
+    )
+
+    def model_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+        return model.model_json_schema()
+
+    def get_config_base(config_data: Optional[ConfigDict] = None) -> ConfigDict:
+        return config_data or ConfigDict(**default_pydantic_config)  # type: ignore[typeddict-item]
+
+    def get_aliases(model: Type[BaseModel]) -> Tuple[str, ...]:
+        return tuple(f.alias or name for name, f in model.model_fields.items())
+
+    class CreateBaseModel(BaseModel):
+        """Just to support FastStream < 0.3.7."""
+
+        model_config = ConfigDict(arbitrary_types_allowed=True)
+
+else:
+    from pydantic.typing import evaluate_forwardref as evaluate_forwardref  # type: ignore[no-redef]
+    from pydantic.config import get_config, ConfigDict, BaseConfig
+
+    def get_config_base(config_data: Optional[ConfigDict] = None) -> Type[BaseConfig]:  # type: ignore[misc,no-any-unimported]
+        return get_config(config_data or ConfigDict(**default_pydantic_config))  # type: ignore[typeddict-item,no-any-unimported,no-any-return]
+
+    def model_schema(model: Type[BaseModel]) -> Dict[str, Any]:
+        return model.schema()
+
+    def get_aliases(model: Type[BaseModel]) -> Tuple[str, ...]:
+        return tuple(f.alias or name for name, f in model.__fields__.items())  # type: ignore[attr-defined]
+
+    class CreateBaseModel(BaseModel):  # type: ignore[no-redef]
+        """Just to support FastStream < 0.3.7."""
+
+        class Config:
+            arbitrary_types_allowed = True
+
+
+ANYIO_V3 = get_version("anyio").startswith("3.")
+
+if ANYIO_V3:
+    from anyio import ExceptionGroup as ExceptionGroup  # type: ignore[attr-defined]
+else:
+    if sys.version_info < (3, 11):
+        from exceptiongroup import ExceptionGroup as ExceptionGroup
+    else:
+        ExceptionGroup = ExceptionGroup

autogen/fast_depends/core/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# Portions derived from  https://github.com/https://github.com/Lancetnik/FastDepends are under the MIT License.
+# SPDX-License-Identifier: MIT
+
+from .build import build_call_model
+from .model import CallModel
+
+__all__ = (
+    "CallModel",
+    "build_call_model",
+)