ag2 0.9.1.post0__py3-none-any.whl → 0.9.3__py3-none-any.whl

autogen/interop/litellm/litellm_config_factory.py

@@ -4,7 +4,7 @@
 
 import os
 from abc import ABC, abstractmethod
-from typing import Any, Callable, TypeVar, Union
+from typing import Any, Callable, Optional, TypeVar, Union
 
 from ...doc_utils import export_module
 from ...llm_config import LLMConfig
@@ -15,19 +15,85 @@ __all__ = ["LiteLLmConfigFactory"]
 T = TypeVar("T", bound="LiteLLmConfigFactory")
 
 
+def get_crawl4ai_version() -> Optional[str]:
+    """Get the installed crawl4ai version."""
+    try:
+        import crawl4ai
+
+        version = getattr(crawl4ai, "__version__", None)
+        return version if isinstance(version, str) else None
+    except (ImportError, AttributeError):
+        return None
+
+
+def is_crawl4ai_v05_or_higher() -> bool:
+    """Check if crawl4ai version is 0.5 or higher."""
+    version = get_crawl4ai_version()
+    if version is None:
+        return False
+
+    # Parse version string (e.g., "0.5.0" -> [0, 5, 0])
+    try:
+        version_parts = [int(x) for x in version.split(".")]
+        # Check if version >= 0.5.0
+        return version_parts >= [0, 5, 0]
+    except (ValueError, IndexError):
+        return False
+
+
 @export_module("autogen.interop")
 class LiteLLmConfigFactory(ABC):
     _factories: set["LiteLLmConfigFactory"] = set()
 
     @classmethod
     def create_lite_llm_config(cls, llm_config: Union[LLMConfig, dict[str, Any]]) -> dict[str, Any]:
+        """
+        Create a lite LLM config compatible with the installed crawl4ai version.
+
+        For crawl4ai >=0.5: Returns config with llmConfig parameter
+        For crawl4ai <0.5: Returns config with provider parameter (legacy)
+        """
         first_llm_config = get_first_llm_config(llm_config)
         for factory in LiteLLmConfigFactory._factories:
             if factory.accepts(first_llm_config):
-                return factory.create(first_llm_config)
+                base_config = factory.create(first_llm_config)
+
+                # Check crawl4ai version and adapt config accordingly
+                if is_crawl4ai_v05_or_higher():
+                    return cls._adapt_for_crawl4ai_v05(base_config)
+                else:
+                    return base_config  # Use legacy format
 
         raise ValueError("Could not find a factory for the given config.")
 
+    @classmethod
+    def _adapt_for_crawl4ai_v05(cls, base_config: dict[str, Any]) -> dict[str, Any]:
+        """
+        Adapt the config for crawl4ai >=0.5 by moving deprecated parameters
+        into an llmConfig object.
+        """
+        adapted_config = base_config.copy()
+
+        # Extract deprecated parameters
+        llm_config_params = {}
+
+        if "provider" in adapted_config:
+            llm_config_params["provider"] = adapted_config.pop("provider")
+
+        if "api_token" in adapted_config:
+            llm_config_params["api_token"] = adapted_config.pop("api_token")
+
+        # Add other parameters that should be in llmConfig
+        for param in ["base_url", "api_base", "api_version"]:
+            if param in adapted_config:
+                llm_config_params[param] = adapted_config.pop(param)
+
+        # Create the llmConfig object if we have parameters for it
+        if llm_config_params:
+            adapted_config["llmConfig"] = llm_config_params
+
+        return adapted_config
+
     @classmethod
     def register_factory(cls) -> Callable[[type[T]], type[T]]:
         def decorator(factory: type[T]) -> type[T]:

autogen/llm_config.py

@@ -138,7 +138,10 @@ class LLMConfig(metaclass=MetaLLMConfig):
         if len(filtered_config_list) == 0:
             raise ValueError(f"No config found that satisfies the filter criteria: {kwargs}")
 
-        return LLMConfig(config_list=filtered_config_list)
+        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]:

autogen/mcp/__main__.py

@@ -0,0 +1,78 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+import logging
+from typing import Annotated, Literal, Optional
+
+from .. import __version__
+from ..import_utils import optional_import_block, require_optional_import
+from .mcp_proxy import MCPProxy
+
+logger = logging.getLogger(__name__)
+
+with optional_import_block():
+    import typer
+
+
+@require_optional_import(["typer"], "mcp-proxy-gen")
+def create_typer_app() -> "typer.Typer":
+    """Create a Typer app for the mcp proxy CLI."""
+    app = typer.Typer(rich_markup_mode="rich")
+
+    def version_callback(value: bool) -> None:
+        if value:
+            typer.echo(f"{__version__}")
+            raise typer.Exit()
+
+    @app.callback()
+    def callback(
+        version: Annotated[
+            Optional[bool],
+            typer.Option("--version", help="Show the version and exit.", callback=version_callback),
+        ] = None,
+    ) -> None:
+        """AG2 mcp proxy CLI - The [bold]mcp proxy[/bold] command line app. 😎
+
+        Generate mcp proxy for your [bold]AG2[/bold] projects.
+
+        Read more in the docs: ...
+        """  # noqa: D415
+
+    @app.command()
+    def create(
+        openapi_specification: Annotated[
+            Optional[str],
+            "Specification of the OpenAPI to use for the proxy generation.",
+        ] = None,
+        openapi_url: Annotated[
+            Optional[str],
+            "URL to the OpenAPI specification to use for the proxy generation.",
+        ] = None,
+        client_source_path: Annotated[
+            Optional[str],
+            "Path to the generated proxy client source code.",
+        ] = None,
+        server_url: Annotated[
+            Optional[str],
+            "Comma-separated list of server URLs to use for the proxy generation.",
+        ] = None,
+        configuration_type: Annotated[
+            Literal["json", "yaml"],
+            "Configuration type of the specification. Can be 'json' or 'yaml'.",
+        ] = "json",
+    ) -> None:
+        """Generate mcp proxy for your AG2 projects."""
+        MCPProxy.create(
+            openapi_specification=openapi_specification,
+            openapi_url=openapi_url,
+            client_source_path=client_source_path,
+            servers=[{"url": server_url}],
+            configuration_type=configuration_type,
+        )
+
+    return app
+
+
+if __name__ == "__main__":
+    app = create_typer_app()
+    app(prog_name="mcp_proxy")

autogen/mcp/mcp_proxy/__init__.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from autogen.import_utils import optional_import_block
+
+from .patch_fastapi_code_generator import (  # noqa: E402
+    SUCCESFUL_IMPORT,
+    patch_function_name_parsing,
+    patch_generate_code,
+)
+
+if SUCCESFUL_IMPORT:
+    patch_function_name_parsing()
+    patch_generate_code()
+
+from .mcp_proxy import MCPProxy  # noqa: E402
+
+__all__ = ["MCPProxy", "optional_import_block"]

autogen/mcp/mcp_proxy/fastapi_code_generator_helpers.py

@@ -0,0 +1,63 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+from collections.abc import Iterator
+from contextlib import contextmanager
+from functools import cached_property
+from typing import Optional, Union
+
+from ...import_utils import optional_import_block
+
+with optional_import_block() as result:
+    from fastapi_code_generator.parser import (
+        Argument,
+        OpenAPIParser,
+        ParameterObject,
+        ReferenceObject,
+    )
+
+SUCCESFUL_IMPORT = result.is_successful
+
+__all__ = ["SUCCESFUL_IMPORT", "patch_get_parameter_type"]
+
+
+@contextmanager
+def patch_get_parameter_type() -> Iterator[None]:
+    class ArgumentWithDescription(Argument):  # type: ignore[misc]
+        description: Optional[str] = None
+
+        @cached_property
+        def argument(self) -> str:
+            if self.description:
+                description = self.description.replace('"""', '"""')
+                type_hint = f'Annotated[{self.type_hint}, """{description}"""]'
+            else:
+                type_hint = self.type_hint
+
+            if self.default is None and self.required:
+                return f"{self.name}: {type_hint}"
+
+            return f"{self.name}: {type_hint} = {self.default}"
+
+    original_get_parameter_type = OpenAPIParser.get_parameter_type
+
+    def get_parameter_type(
+        self: OpenAPIParser,
+        parameters: Union[ReferenceObject, ParameterObject],
+        snake_case: bool,
+        path: list[str],
+    ) -> Optional[Argument]:
+        # get the original argument
+        argument = original_get_parameter_type(self, parameters, snake_case, path)
+
+        # add description to the argument
+        parameters = self.resolve_object(parameters, ParameterObject)
+        argument_with_description = ArgumentWithDescription(description=parameters.description, **argument.model_dump())
+        return argument_with_description
+
+    OpenAPIParser.get_parameter_type = get_parameter_type
+
+    try:
+        yield
+    finally:
+        OpenAPIParser.get_parameter_type = original_get_parameter_type