ag2 0.9.1a1__py3-none-any.whl → 0.9.2__py3-none-any.whl

autogen/messages/base_message.py

@@ -0,0 +1,107 @@
+# 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, TypeVar, Union
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, create_model
+
+from ..doc_utils import export_module
+
+PetType = TypeVar("PetType", bound=Literal["cat", "dog"])
+
+__all__ = ["BaseMessage", "get_annotated_type_for_message_classes", "wrap_message"]
+
+
+@export_module("autogen.messages")
+class BaseMessage(BaseModel, ABC):
+    uuid: UUID
+
+    def __init__(self, uuid: Optional[UUID] = None, **kwargs: Any) -> None:
+        """Base message class
+
+        Args:
+            uuid (Optional[UUID], optional): Unique identifier for the message. Defaults to None.
+            **kwargs (Any): Additional keyword arguments
+        """
+        uuid = uuid or uuid4()
+        super().__init__(uuid=uuid, **kwargs)
+
+    def print(self, f: Optional[Callable[..., Any]] = None) -> None:
+        """Print message
+
+        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("_")
+
+
+_message_classes: dict[str, type[BaseModel]] = {}
+
+
+@export_module("autogen.messages")
+def wrap_message(message_cls: type[BaseMessage]) -> type[BaseModel]:
+    """Wrap a message class with a type field to be used in a union type
+
+    This is needed for proper serialization and deserialization of messages in a union type.
+
+    Args:
+        message_cls (type[BaseMessage]): Message class to wrap
+    """
+    global _message_classes
+
+    if not message_cls.__name__.endswith("Message"):
+        raise ValueError("Message class name must end with 'Message'")
+
+    type_name = camel2snake(message_cls.__name__)
+    type_name = type_name[: -len("_message")]
+
+    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: message_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=message_cls(*args, **data, content=content), **data)
+                else:
+                    super().__init__(content=message_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(message_cls.__name__, __base__=WrapperBase)
+
+    # Preserve the original class's docstring and other attributes
+    wrapper_cls.__doc__ = message_cls.__doc__
+    wrapper_cls.__module__ = message_cls.__module__
+
+    # Copy any other relevant attributes/metadata from the original class
+    if hasattr(message_cls, "__annotations__"):
+        wrapper_cls.__annotations__ = message_cls.__annotations__
+
+    _message_classes[type_name] = wrapper_cls
+
+    return wrapper_cls
+
+
+@export_module("autogen.messages")
+def get_annotated_type_for_message_classes() -> type[Any]:
+    # this is a dynamic type so we need to disable the type checker
+    union_type = Union[tuple(_message_classes.values())]  # type: ignore[valid-type]
+    return Annotated[union_type, Field(discriminator="type")]  # type: ignore[return-value]
+
+
+def get_message_classes() -> dict[str, type[BaseModel]]:
+    return _message_classes

autogen/messages/client_messages.py

@@ -0,0 +1,171 @@
+# 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 ..events import deprecated_by
+from ..events.client_events import StreamEvent, UsageSummaryEvent
+from .base_message import BaseMessage, wrap_message
+
+__all__ = ["UsageSummaryMessage"]
+
+
+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
+
+
+@deprecated_by(UsageSummaryEvent)
+@wrap_message
+class UsageSummaryMessage(BaseMessage):
+    """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)
+
+
+@deprecated_by(StreamEvent)
+@wrap_message
+class StreamMessage(BaseMessage):
+    """Stream message."""
+
+    content: str
+    """Content of the message."""
+
+    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/messages/print_message.py

@@ -0,0 +1,49 @@
+# 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 ..events import deprecated_by
+from ..events.print_event import PrintEvent
+from .base_message import BaseMessage, wrap_message
+
+
+@deprecated_by(PrintEvent)
+@wrap_message
+class PrintMessage(BaseMessage):
+    """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/oai/__init__.py

@@ -0,0 +1,53 @@
+# 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 ..cache.cache import Cache
+from .anthropic import AnthropicLLMConfigEntry
+from .bedrock import BedrockLLMConfigEntry
+from .cerebras import CerebrasLLMConfigEntry
+from .client import AzureOpenAILLMConfigEntry, DeepSeekLLMConfigEntry, ModelClient, OpenAILLMConfigEntry, OpenAIWrapper
+from .cohere import CohereLLMConfigEntry
+from .gemini import GeminiLLMConfigEntry
+from .groq import GroqLLMConfigEntry
+from .mistral import MistralLLMConfigEntry
+from .ollama import OllamaLLMConfigEntry
+from .openai_utils import (
+    config_list_from_dotenv,
+    config_list_from_json,
+    config_list_from_models,
+    config_list_gpt4_gpt35,
+    config_list_openai_aoai,
+    filter_config,
+    get_config_list,
+    get_first_llm_config,
+)
+from .together import TogetherLLMConfigEntry
+
+__all__ = [
+    "AnthropicLLMConfigEntry",
+    "AzureOpenAILLMConfigEntry",
+    "BedrockLLMConfigEntry",
+    "Cache",
+    "CerebrasLLMConfigEntry",
+    "CohereLLMConfigEntry",
+    "DeepSeekLLMConfigEntry",
+    "GeminiLLMConfigEntry",
+    "GroqLLMConfigEntry",
+    "MistralLLMConfigEntry",
+    "ModelClient",
+    "OllamaLLMConfigEntry",
+    "OpenAILLMConfigEntry",
+    "OpenAIWrapper",
+    "TogetherLLMConfigEntry",
+    "config_list_from_dotenv",
+    "config_list_from_json",
+    "config_list_from_models",
+    "config_list_gpt4_gpt35",
+    "config_list_openai_aoai",
+    "filter_config",
+    "get_config_list",
+    "get_first_llm_config",
+]