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

autogen/math_utils.py

@@ -0,0 +1,339 @@
+# 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 Optional
+
+
+def remove_boxed(string: str) -> Optional[str]:
+    """Source: https://github.com/hendrycks/math
+    Extract the text within a \\boxed`{...}` environment.
+
+    Example:
+    ```python
+    > remove_boxed("\\boxed{\\frac{2}{3}}")
+
+    \\frac{2}{3}
+    ```
+    """
+    left = "\\boxed{"
+    try:
+        if not all((string[: len(left)] == left, string[-1] == "}")):
+            raise AssertionError
+
+        return string[len(left) : -1]
+    except Exception:
+        return None
+
+
+def last_boxed_only_string(string: str) -> Optional[str]:
+    """Source: https://github.com/hendrycks/math
+    Extract the last \\boxed`{...}` or \\fbox`{...}` element from a string.
+    """
+    idx = string.rfind("\\boxed")
+    if idx < 0:
+        idx = string.rfind("\\fbox")
+        if idx < 0:
+            return None
+
+    i = idx
+    right_brace_idx = None
+    num_left_braces_open = 0
+    while i < len(string):
+        if string[i] == "{":
+            num_left_braces_open += 1
+        if string[i] == "}":
+            num_left_braces_open -= 1
+            if num_left_braces_open == 0:
+                right_brace_idx = i
+                break
+        i += 1
+
+    retval = None if right_brace_idx is None else string[idx : right_brace_idx + 1]
+
+    return retval
+
+
+def _fix_fracs(string: str) -> str:
+    """Source: https://github.com/hendrycks/math
+    Reformat fractions.
+
+    Examples:
+    ```
+    >>> _fix_fracs("\\frac1b")
+    \frac{1}{b}
+    >>> _fix_fracs("\\frac12")
+    \frac{1}{2}
+    >>> _fix_fracs("\\frac1{72}")
+    \frac{1}{72}
+    ```
+    """
+    substrs = string.split("\\frac")
+    new_str = substrs[0]
+    if len(substrs) > 1:
+        substrs = substrs[1:]
+        for substr in substrs:
+            new_str += "\\frac"
+            if substr[0] == "{":
+                new_str += substr
+            else:
+                try:
+                    if not len(substr) >= 2:
+                        raise AssertionError
+                except Exception:
+                    return string
+                a = substr[0]
+                b = substr[1]
+                if b != "{":
+                    if len(substr) > 2:
+                        post_substr = substr[2:]
+                        new_str += "{" + a + "}{" + b + "}" + post_substr
+                    else:
+                        new_str += "{" + a + "}{" + b + "}"
+                else:
+                    if len(substr) > 2:
+                        post_substr = substr[2:]
+                        new_str += "{" + a + "}" + b + post_substr
+                    else:
+                        new_str += "{" + a + "}" + b
+    string = new_str
+    return string
+
+
+def _fix_a_slash_b(string: str) -> str:
+    """Source: https://github.com/hendrycks/math
+    Reformat fractions formatted as a/b to \\`frac{a}{b}`.
+
+    Example:
+    ```
+    >>> _fix_a_slash_b("2/3")
+    \frac{2}{3}
+    ```
+    """
+    if len(string.split("/")) != 2:
+        return string
+    a_str = string.split("/")[0]
+    b_str = string.split("/")[1]
+    try:
+        a = int(a_str)
+        b = int(b_str)
+        if not string == f"{a}/{b}":
+            raise AssertionError
+        new_string = "\\frac{" + str(a) + "}{" + str(b) + "}"
+        return new_string
+    except Exception:
+        return string
+
+
+def _remove_right_units(string: str) -> str:
+    """Source: https://github.com/hendrycks/math
+    Remove units (on the right).
+    "\\text{ " only ever occurs (at least in the val set) when describing units.
+    """
+    if "\\text{ " in string:
+        splits = string.split("\\text{ ")
+        if not len(splits) == 2:
+            raise AssertionError
+        return splits[0]
+    else:
+        return string
+
+
+def _fix_sqrt(string: str) -> str:
+    """Source: https://github.com/hendrycks/math
+    Reformat square roots.
+
+    Example:
+    ```
+    >>> _fix_sqrt("\\sqrt3")
+    \\sqrt{3}
+    ```
+    """
+    if "\\sqrt" not in string:
+        return string
+    splits = string.split("\\sqrt")
+    new_string = splits[0]
+    for split in splits[1:]:
+        if split[0] != "{":
+            a = split[0]
+            new_substr = "\\sqrt{" + a + "}" + split[1:]
+        else:
+            new_substr = "\\sqrt" + split
+        new_string += new_substr
+    return new_string
+
+
+def _strip_string(string: str) -> str:
+    """Source: https://github.com/hendrycks/math
+    Apply the reformatting helper functions above.
+    """
+    # linebreaks
+    string = string.replace("\n", "")
+    # print(string)
+
+    # remove inverse spaces
+    string = string.replace("\\!", "")
+    # print(string)
+
+    # replace \\ with \
+    string = string.replace("\\\\", "\\")
+    # print(string)
+
+    # replace tfrac and dfrac with frac
+    string = string.replace("tfrac", "frac")
+    string = string.replace("dfrac", "frac")
+    # print(string)
+
+    # remove \left and \right
+    string = string.replace("\\left", "")
+    string = string.replace("\\right", "")
+    # print(string)
+
+    # Remove circ (degrees)
+    string = string.replace("^{\\circ}", "")
+    string = string.replace("^\\circ", "")
+
+    # remove dollar signs
+    string = string.replace("\\$", "")
+
+    # remove units (on the right)
+    string = _remove_right_units(string)
+
+    # remove percentage
+    string = string.replace("\\%", "")
+    string = string.replace("%", "")
+
+    # " 0." equivalent to " ." and "{0." equivalent to "{." Alternatively, add "0" if "." is the start of the string
+    string = string.replace(" .", " 0.")
+    string = string.replace("{.", "{0.")
+    # if empty, return empty string
+    if len(string) == 0:
+        return string
+    if string[0] == ".":
+        string = "0" + string
+
+    # to consider: get rid of e.g. "k = " or "q = " at beginning
+    if len(string.split("=")) == 2 and len(string.split("=")[0]) <= 2:
+        string = string.split("=")[1]
+
+    # fix sqrt3 --> sqrt{3}
+    string = _fix_sqrt(string)
+
+    # remove spaces
+    string = string.replace(" ", "")
+
+    # \frac1b or \frac12 --> \frac{1}{b} and \frac{1}{2}, etc.
+    # Even works with \frac1{72} (but not \frac{72}1).
+    # Also does a/b --> \\frac{a}{b}
+    string = _fix_fracs(string)
+
+    # manually change 0.5 --> \frac{1}{2}
+    if string == "0.5":
+        string = "\\frac{1}{2}"
+
+    # NOTE: X/Y changed to \frac{X}{Y} in dataset, but in simple cases fix in case the model output is X/Y
+    string = _fix_a_slash_b(string)
+
+    return string
+
+
+def get_answer(solution: Optional[str]) -> Optional[str]:
+    if solution is None:
+        return None
+    last_boxed = last_boxed_only_string(solution)
+    if last_boxed is None:
+        return None
+    answer = remove_boxed(last_boxed)
+    if answer is None:
+        return None
+    return answer
+
+
+def is_equiv(str1: Optional[str], str2: Optional[str]) -> float:
+    """Returns (as a float) whether two strings containing math are equivalent up to differences of formatting in
+    - units
+    - fractions
+    - square roots
+    - superfluous LaTeX.
+    Source: https://github.com/hendrycks/math
+    """
+    if str1 is None and str2 is None:
+        print("WARNING: Both None")
+        return 1.0
+    if str1 is None or str2 is None:
+        return 0.0
+
+    try:
+        ss1 = _strip_string(str1)
+        ss2 = _strip_string(str2)
+        return float(ss1 == ss2)
+    except Exception:
+        return float(str1 == str2)
+
+
+def is_equiv_chain_of_thought(str1: str, str2: str) -> float:
+    """Strips the solution first before calling `is_equiv`."""
+    ans1 = get_answer(str1)
+    ans2 = get_answer(str2)
+
+    return is_equiv(ans1, ans2)
+
+
+def voting_counts(responses):
+    answers = {}
+    for i in range(len(responses)):
+        equiv = i
+        if get_answer(responses[i]) is None:
+            # ignore None answers
+            continue
+        for j in answers:
+            if is_equiv_chain_of_thought(responses[i], responses[j]):
+                equiv = j
+                break
+        if equiv in answers:
+            answers[equiv] += 1
+        else:
+            answers[equiv] = 1
+    return answers
+
+
+def eval_math_responses(responses, solution=None):
+    """Select a response for a math problem using voting, and check if the response is correct if the solution is provided.
+
+    Args:
+        responses: The list of responses.
+        solution: The canonical solution.
+
+    Returns:
+        dict: The success metrics.
+    """
+    n = len(responses)
+    if not n:
+        return {
+            "expected_success": 0,
+            "success": False,
+            "success_vote": 0,
+            "voted_answer": None,
+            "votes": 0,
+        }
+    success_list = []
+    if solution is not None:
+        for i in range(n):
+            response = responses[i]
+            succeed = is_equiv_chain_of_thought(response, solution)
+            success_list.append(succeed)
+    # voting
+    answers = voting_counts(responses)
+    # find the answer with highest votes in answers
+    answer, votes = max(answers.items(), key=lambda x: x[1], default=(0, 0))
+    # check if the answer is correct
+    success_vote = is_equiv_chain_of_thought(responses[answer], solution)
+    return {
+        "expected_success": 1 - pow(1 - sum(success_list) / n, n),
+        "success": any(s for s in success_list),
+        "success_vote": success_vote,
+        "voted_answer": responses[answer],
+        "votes": votes,
+    }

autogen/mcp/__init__.py

@@ -0,0 +1,7 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from .mcp_client import create_toolkit
+
+__all__ = ["create_toolkit"]

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_client.py

@@ -0,0 +1,208 @@
+# Copyright (c) 2023 - 2025, AG2ai, Inc., AG2ai open-source projects maintainers and core contributors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Annotated, Any, Optional, Union
+
+import anyio
+from pydantic import BaseModel
+
+from ..doc_utils import export_module
+from ..import_utils import optional_import_block, require_optional_import
+from ..tools import Tool, Toolkit
+
+with optional_import_block():
+    from mcp import ClientSession
+    from mcp.types import (
+        CallToolResult,
+        ReadResourceResult,
+        ResourceTemplate,
+        TextContent,
+    )
+    from mcp.types import (
+        Tool as MCPTool,
+    )
+
+__all__ = ["ResultSaved", "create_toolkit"]
+
+
+class MCPClient:
+    @staticmethod
+    def _convert_call_tool_result(  # type: ignore[no-any-unimported]
+        call_tool_result: "CallToolResult",  # type: ignore[no-any-unimported]
+    ) -> tuple[Union[str, list[str]], Any]:
+        text_contents: list[TextContent] = []  # type: ignore[no-any-unimported]
+        non_text_contents = []
+        for content in call_tool_result.content:
+            if isinstance(content, TextContent):
+                text_contents.append(content)
+            else:
+                non_text_contents.append(content)
+
+        tool_content: Union[str, list[str]] = [content.text for content in text_contents]
+        if len(text_contents) == 1:
+            tool_content = tool_content[0]
+
+        if call_tool_result.isError:
+            raise ValueError(f"Tool call failed: {tool_content}")
+
+        return tool_content, non_text_contents or None
+
+    @classmethod
+    @require_optional_import("mcp", "mcp")
+    def convert_tool(  # type: ignore[no-any-unimported]
+        cls, tool: Any, session: "ClientSession", **kwargs: Any
+    ) -> Tool:
+        if not isinstance(tool, MCPTool):
+            raise ValueError(f"Expected an instance of `mcp.types.Tool`, got {type(tool)}")
+
+        # needed for type checking
+        mcp_tool: MCPTool = tool  # type: ignore[no-any-unimported]
+
+        async def call_tool(  # type: ignore[no-any-unimported]
+            **arguments: dict[str, Any],
+        ) -> tuple[Union[str, list[str]], Any]:
+            call_tool_result = await session.call_tool(tool.name, arguments)
+            return MCPClient._convert_call_tool_result(call_tool_result)
+
+        ag2_tool = Tool(
+            name=mcp_tool.name,
+            description=mcp_tool.description,
+            func_or_tool=call_tool,
+            parameters_json_schema=mcp_tool.inputSchema,
+        )
+        return ag2_tool
+
+    @classmethod
+    @require_optional_import("mcp", "mcp")
+    def convert_resource(  # type: ignore[no-any-unimported]
+        cls,
+        resource_template: Any,
+        session: "ClientSession",
+        resource_download_folder: Optional[Path],
+        **kwargs: Any,
+    ) -> Tool:
+        if not isinstance(resource_template, ResourceTemplate):
+            raise ValueError(f"Expected an instance of `mcp.types.ResourceTemplate`, got {type(resource_template)}")
+
+        # needed for type checking
+        mcp_resource: ResourceTemplate = resource_template  # type: ignore[no-any-unimported]
+
+        uri_description = f"""A URI template (according to RFC 6570) that can be used to construct resource URIs.
+Here is the correct format for the URI template:
+{mcp_resource.uriTemplate}
+"""
+
+        async def call_resource(uri: Annotated[str, uri_description]) -> Union[ReadResourceResult, ResultSaved]:  # type: ignore[no-any-unimported]
+            result = await session.read_resource(uri)
+
+            if not resource_download_folder:
+                return result
+
+            timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+            filename = uri.split("://")[-1] + f"_{timestamp}"
+            file_path = resource_download_folder / filename
+
+            async with await anyio.open_file(file_path, "w") as f:
+                await f.write(result.model_dump_json(indent=4))
+
+            return ResultSaved(
+                explanation=f"Request for uri {uri} was saved to {file_path}",
+                file_path=file_path,
+            )
+
+        # Wrap resource as AG2 tool
+        ag2_tool = Tool(
+            name=mcp_resource.name,
+            description=mcp_resource.description,
+            func_or_tool=call_resource,
+        )
+        return ag2_tool
+
+    @classmethod
+    @require_optional_import("mcp", "mcp")
+    async def load_mcp_toolkit(
+        cls,
+        session: "ClientSession",
+        *,
+        use_mcp_tools: bool,
+        use_mcp_resources: bool,
+        resource_download_folder: Optional[Path],
+    ) -> Toolkit:  # type: ignore[no-any-unimported]
+        """Load all available MCP tools and convert them to AG2 Toolkit."""
+        all_ag2_tools: list[Tool] = []
+
+        if use_mcp_tools:
+            tools = await session.list_tools()
+            ag2_tools: list[Tool] = [cls.convert_tool(tool=tool, session=session) for tool in tools.tools]
+            all_ag2_tools.extend(ag2_tools)
+
+        if use_mcp_resources:
+            resource_templates = await session.list_resource_templates()
+            ag2_resources: list[Tool] = [
+                cls.convert_resource(
+                    resource_template=resource_template,
+                    session=session,
+                    resource_download_folder=resource_download_folder,
+                )
+                for resource_template in resource_templates.resourceTemplates
+            ]
+            all_ag2_tools.extend(ag2_resources)
+
+        return Toolkit(tools=all_ag2_tools)
+
+    @classmethod
+    def get_unsupported_reason(cls) -> Optional[str]:
+        if sys.version_info < (3, 10):
+            return "This submodule is only supported for Python versions 3.10 and above"
+
+        with optional_import_block() as result:
+            import mcp  # noqa: F401
+
+        if not result.is_successful:
+            return "Please install `mcp` extra to use this module:\n\n\tpip install ag2[mcp]"
+
+        return None
+
+
+@export_module("autogen.mcp")
+async def create_toolkit(
+    session: "ClientSession",
+    *,
+    use_mcp_tools: bool = True,
+    use_mcp_resources: bool = True,
+    resource_download_folder: Optional[Union[Path, str]] = None,
+) -> Toolkit:  # type: ignore[no-any-unimported]
+    """Create a toolkit from the MCP client session.
+
+    Args:
+        session (ClientSession): The MCP client session.
+        use_mcp_tools (bool): Whether to include MCP tools in the toolkit.
+        use_mcp_resources (bool): Whether to include MCP resources in the toolkit.
+        resource_download_folder (Optional[Union[Path, str]]): The folder to download files to.
+    Returns:
+        Toolkit: The toolkit containing the converted tools.
+    """
+    if resource_download_folder:
+        if isinstance(resource_download_folder, str):
+            resource_download_folder = Path(resource_download_folder)
+        await anyio.to_thread.run_sync(lambda: resource_download_folder.mkdir(parents=True, exist_ok=True))
+
+    return await MCPClient.load_mcp_toolkit(
+        session=session,
+        use_mcp_tools=use_mcp_tools,
+        use_mcp_resources=use_mcp_resources,
+        resource_download_folder=resource_download_folder,
+    )
+
+
+@export_module("autogen.mcp.mcp_client")
+class ResultSaved(BaseModel):
+    """Result saved to a file"""
+
+    explanation: str
+    file_path: Path

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"]