ag2 0.9.8.post1__py3-none-any.whl → 0.9.10__py3-none-any.whl

autogen/coding/docker_commandline_code_executor.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import atexit
 import logging
-import sys
 import uuid
 from hashlib import md5
 from pathlib import Path
@@ -18,6 +17,7 @@ from typing import Any, ClassVar
 
 import docker
 from docker.errors import ImageNotFound
+from typing_extensions import Self
 
 from ..code_utils import TIMEOUT_MSG, _cmd
 from ..doc_utils import export_module
@@ -25,11 +25,6 @@ from .base import CodeBlock, CodeExecutor, CodeExtractor, CommandLineCodeResult
 from .markdown_code_extractor import MarkdownCodeExtractor
 from .utils import _get_file_name_from_content, silence_pip
 
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 
 def _wait_for_ready(container: Any, timeout: int = 60, stop_time: float = 0.1) -> None:
     elapsed_time = 0.0

autogen/coding/factory.py

@@ -43,5 +43,14 @@ class CodeExecutorFactory:
             from .local_commandline_code_executor import LocalCommandLineCodeExecutor
 
             return LocalCommandLineCodeExecutor(**code_execution_config.get("commandline-local", {}))
+        elif executor == "yepcode":
+            try:
+                from .yepcode_code_executor import YepCodeCodeExecutor
+            except ImportError as e:
+                raise ImportError(
+                    "Missing dependencies for YepCodeCodeExecutor. Please install with: pip install ag2[yepcode]"
+                ) from e
+
+            return YepCodeCodeExecutor(**code_execution_config.get("yepcode", {}))
         else:
             raise ValueError(f"Unknown code executor {executor}")

autogen/coding/jupyter/docker_jupyter_server.py

@@ -10,20 +10,14 @@ import atexit
 import io
 import logging
 import secrets
-import sys
 import uuid
 from pathlib import Path
 from types import TracebackType
 
 import docker
+from typing_extensions import Self
 
 from ...doc_utils import export_module
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
 from ..docker_commandline_code_executor import _wait_for_ready
 from .base import JupyterConnectable, JupyterConnectionInfo
 from .import_utils import require_jupyter_kernel_gateway_installed

autogen/coding/jupyter/jupyter_client.py

@@ -8,23 +8,16 @@ from __future__ import annotations
 
 import datetime
 import json
-import sys
 import uuid
 from dataclasses import dataclass
 from types import TracebackType
 from typing import Any, cast
 
-from ...doc_utils import export_module
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
-
-
 import requests
 from requests.adapters import HTTPAdapter, Retry
+from typing_extensions import Self
 
+from ...doc_utils import export_module
 from ...import_utils import optional_import_block, require_optional_import
 from .base import JupyterConnectionInfo
 

autogen/coding/jupyter/jupyter_code_executor.py

@@ -7,18 +7,13 @@
 import base64
 import json
 import os
-import sys
 import uuid
 from pathlib import Path
 from types import TracebackType
 
-from ...doc_utils import export_module
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing_extensions import Self
 
+from ...doc_utils import export_module
 from ..base import CodeBlock, CodeExecutor, CodeExtractor, IPythonCodeResult
 from ..markdown_code_extractor import MarkdownCodeExtractor
 from ..utils import silence_pip

autogen/coding/jupyter/local_jupyter_server.py

@@ -14,13 +14,9 @@ import subprocess
 import sys
 from types import TracebackType
 
-from ...doc_utils import export_module
-
-if sys.version_info >= (3, 11):
-    from typing import Self
-else:
-    from typing_extensions import Self
+from typing_extensions import Self
 
+from ...doc_utils import export_module
 from .base import JupyterConnectable, JupyterConnectionInfo
 from .import_utils import require_jupyter_kernel_gateway_installed
 from .jupyter_client import JupyterClient

autogen/coding/local_commandline_code_executor.py

@@ -339,68 +339,3 @@ $functions"""
     def restart(self) -> None:
         """(Experimental) Restart the code executor."""
         warnings.warn("Restarting local command line code executor is not supported. No action is taken.")
-
-
-# From stack overflow: https://stackoverflow.com/a/52087847/2214524
-class _DeprecatedClassMeta(type):
-    def __new__(cls, name, bases, classdict, *args, **kwargs):  # type: ignore[no-untyped-def]
-        alias = classdict.get("_DeprecatedClassMeta__alias")
-
-        if alias is not None:
-
-            def new(cls, *args, **kwargs):  # type: ignore[no-untyped-def]
-                alias = cls._DeprecatedClassMeta__alias
-
-                if alias is not None:
-                    warnings.warn(
-                        f"{cls.__name__} has been renamed to {alias.__name__}, the alias will be removed in the future",
-                        DeprecationWarning,
-                        stacklevel=2,
-                    )
-
-                return alias(*args, **kwargs)
-
-            classdict["__new__"] = new
-            classdict["_DeprecatedClassMeta__alias"] = alias
-
-        fixed_bases = []
-
-        for b in bases:
-            alias = getattr(b, "_DeprecatedClassMeta__alias", None)
-
-            if alias is not None:
-                warnings.warn(
-                    f"{b.__name__} has been renamed to {alias.__name__}, the alias will be removed in the future",
-                    DeprecationWarning,
-                    stacklevel=2,
-                )
-
-            # Avoid duplicate base classes.
-            b = alias or b
-            if b not in fixed_bases:
-                fixed_bases.append(b)
-
-        fixed_bases = tuple(fixed_bases)  # type: ignore[assignment]
-
-        return super().__new__(cls, name, fixed_bases, classdict, *args, **kwargs)  # type: ignore[call-overload]
-
-    def __instancecheck__(cls, instance):  # type: ignore[no-untyped-def]
-        return any(cls.__subclasscheck__(c) for c in {type(instance), instance.__class__})  # type: ignore[no-untyped-call]
-
-    def __subclasscheck__(cls, subclass):  # type: ignore[no-untyped-def]
-        if subclass is cls:
-            return True
-        else:
-            return issubclass(subclass, cls._DeprecatedClassMeta__alias)  # type: ignore[attr-defined]
-
-
-class LocalCommandlineCodeExecutor(metaclass=_DeprecatedClassMeta):
-    """LocalCommandlineCodeExecutor renamed to LocalCommandLineCodeExecutor"""
-
-    _DeprecatedClassMeta__alias = LocalCommandLineCodeExecutor
-
-
-class CommandlineCodeResult(metaclass=_DeprecatedClassMeta):
-    """CommandlineCodeResult renamed to CommandLineCodeResult"""
-
-    _DeprecatedClassMeta__alias = CommandLineCodeResult

autogen/coding/yepcode_code_executor.py

@@ -0,0 +1,197 @@
+# 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
+"""YepCode code executor implementation."""
+
+import os
+from collections.abc import Callable
+from typing import ClassVar
+
+from pydantic import Field
+
+from ..doc_utils import export_module
+from .base import CodeBlock, CodeExecutor, CodeExtractor, CodeResult
+from .markdown_code_extractor import MarkdownCodeExtractor
+
+try:
+    from dotenv import load_dotenv
+
+    _load_dotenv: Callable[[], bool] | None = load_dotenv
+except ImportError:
+    _load_dotenv = None
+
+try:
+    from yepcode_run import YepCodeApiConfig, YepCodeRun
+except ImportError:
+    YepCodeRun = None
+    YepCodeApiConfig = None
+
+
+@export_module("autogen.coding")
+class YepCodeCodeResult(CodeResult):
+    """A code result class for YepCode executor."""
+
+    execution_id: str | None = Field(default=None, description="The YepCode execution ID for this result.")
+
+
+@export_module("autogen.coding")
+class YepCodeCodeExecutor(CodeExecutor):
+    """A code executor class that executes code using YepCode's serverless runtime.
+
+    This executor runs code in YepCode's secure, production-grade sandboxes.
+    It supports Python and JavaScript execution with access to any external library with automatic discovery and installation.
+
+    The executor executes code blocks serially in the order they are received.
+    Each code block is executed in a separate YepCode execution environment.
+    Currently supports Python and JavaScript languages.
+
+    Args:
+        api_token (Optional[str]): YepCode API token. If None, will try to get from YEPCODE_API_TOKEN environment variable.
+        timeout (int): The timeout for code execution in seconds. Default is 60.
+        remove_on_done (bool): Whether to remove the execution after completion. Default is False.
+        sync_execution (bool): Whether to wait for execution to complete. Default is True.
+
+    Raises:
+        ImportError: If yepcode-run package is not installed.
+        ValueError: If YepCode API token is not provided or timeout is invalid.
+        RuntimeError: If YepCode runner initialization fails.
+    """
+
+    SUPPORTED_LANGUAGES: ClassVar[list[str]] = ["python", "javascript"]
+
+    def __init__(
+        self,
+        api_token: str | None = None,
+        timeout: int = 60,
+        remove_on_done: bool = False,
+        sync_execution: bool = True,
+    ):
+        if YepCodeRun is None or YepCodeApiConfig is None:
+            raise ImportError(
+                "Missing dependencies for YepCodeCodeExecutor. Please install with: pip install ag2[yepcode]"
+            )
+
+        if timeout < 1:
+            raise ValueError("Timeout must be greater than or equal to 1.")
+
+        # Load environment variables from .env file if dotenv is available
+        if _load_dotenv is not None:
+            _load_dotenv()
+
+        # Get API token from parameter or environment
+        self._api_token = api_token or os.getenv("YEPCODE_API_TOKEN")
+        if not self._api_token:
+            raise ValueError(
+                "YepCode API token is required. Provide it via api_token parameter or YEPCODE_API_TOKEN environment variable."
+            )
+
+        self._timeout = timeout
+        self._remove_on_done = remove_on_done
+        self._sync_execution = sync_execution
+
+        try:
+            config = YepCodeApiConfig(api_token=self._api_token)
+            self._runner = YepCodeRun(config)
+        except Exception as e:
+            raise RuntimeError(f"Failed to initialize YepCode runner: {str(e)}") from e
+
+    @property
+    def code_extractor(self) -> CodeExtractor:
+        """(Experimental) Export a code extractor that can be used by an agent."""
+        return MarkdownCodeExtractor()
+
+    @property
+    def timeout(self) -> int:
+        """The timeout for code execution."""
+        return self._timeout
+
+    def _normalize_language(self, language: str) -> str:
+        """Normalize language name to YepCode format."""
+        lang = language.lower()
+        if lang in ["js", "javascript"]:
+            return "javascript"
+        elif lang in ["python", "py"]:
+            return "python"
+        else:
+            return lang
+
+    def execute_code_blocks(self, code_blocks: list[CodeBlock]) -> YepCodeCodeResult:
+        """Execute the code blocks and return the result.
+
+        Args:
+            code_blocks (List[CodeBlock]): The code blocks to execute.
+
+        Returns:
+            YepCodeCodeResult: The result of the code execution.
+        """
+        if not code_blocks:
+            return YepCodeCodeResult(exit_code=0, output="")
+
+        outputs: list[str] = []
+        last_execution_id: str | None = None
+
+        for code_block in code_blocks:
+            lang = self._normalize_language(code_block.language)
+
+            if lang not in ["python", "javascript"]:
+                return YepCodeCodeResult(
+                    exit_code=1,
+                    output=f"Unsupported language: {code_block.language}. Supported languages: {', '.join(self.SUPPORTED_LANGUAGES)}",
+                )
+
+            try:
+                # Execute code using YepCode
+                execution = self._runner.run(
+                    code_block.code,
+                    {
+                        "language": lang,
+                        "removeOnDone": self._remove_on_done,
+                        "timeout": self._timeout * 1000,  # Convert to milliseconds
+                    },
+                )
+
+                last_execution_id = execution.id
+
+                if self._sync_execution:
+                    # Wait for execution to complete
+                    execution.wait_for_done()
+
+                    logs_output = ""
+                    # Get logs
+                    if execution.logs:
+                        logs_output = "\n\nExecution logs:\n" + "\n".join([
+                            f"{log.timestamp} - {log.level}: {log.message}" for log in execution.logs
+                        ])
+
+                    # Check if execution was successful
+                    if execution.error:
+                        output = f"Execution failed with error:\n{execution.error}{logs_output}"
+
+                        return YepCodeCodeResult(exit_code=1, output=output, execution_id=execution.id)
+
+                    # Get output
+                    output = ""
+                    if execution.return_value:
+                        output = f"Execution result:\n{execution.return_value}"
+
+                    output += logs_output
+
+                    outputs.append(output)
+                else:
+                    outputs.append(f"Execution started with ID: {execution.id}")
+
+            except Exception as e:
+                return YepCodeCodeResult(
+                    exit_code=1,
+                    output=f"Error executing code: {str(e)}",
+                    execution_id=last_execution_id,
+                )
+
+        return YepCodeCodeResult(exit_code=0, output="\n===\n".join(outputs), execution_id=last_execution_id)
+
+    def restart(self) -> None:
+        """Restart the code executor."""
+        pass

autogen/environments/docker_python_environment.py

@@ -10,7 +10,7 @@ import tempfile
 import uuid
 from typing import Any
 
-from asyncer import asyncify
+from anyio import to_thread
 
 from .python_environment import PythonEnvironment
 
@@ -320,7 +320,7 @@ class DockerPythonEnvironment(PythonEnvironment):
                 os.makedirs(script_dir, exist_ok=True)
 
             # Write the code to the script file on the host
-            await asyncify(self._write_to_file)(host_script_path, code)
+            await to_thread.run_sync(self._write_to_file, host_script_path, code)
 
             # Path to the script in the container
             container_script_path = f"/workspace/{rel_path}"
@@ -329,7 +329,7 @@ class DockerPythonEnvironment(PythonEnvironment):
             exec_cmd = ["docker", "exec", self._container_name, "python", container_script_path]
 
             # Run the command with a timeout
-            result = await asyncify(self._run_subprocess_with_timeout)(exec_cmd, timeout)
+            result = await to_thread.run_sync(self._run_subprocess_with_timeout, exec_cmd, timeout)
 
             return {
                 "success": result[0],

autogen/environments/system_python_environment.py

@@ -8,7 +8,7 @@ import subprocess
 import sys
 from typing import Any
 
-from asyncer import asyncify
+from anyio import to_thread
 
 from .python_environment import PythonEnvironment
 
@@ -62,14 +62,14 @@ class SystemPythonEnvironment(PythonEnvironment):
             if script_dir:
                 os.makedirs(script_dir, exist_ok=True)
 
-            # Write the code to the script file using asyncify (from base class)
-            await asyncify(self._write_to_file)(script_path, code)
+            # Write the code to the script file using anyio.to_thread.run_sync (from base class)
+            await to_thread.run_sync(self._write_to_file, script_path, code)
 
             logging.info(f"Wrote code to {script_path}")
 
             try:
-                # Execute directly with subprocess using asyncify for better reliability
-                result = await asyncify(self._run_subprocess)([python_executable, script_path], timeout)
+                # Execute directly with subprocess using anyio.to_thread.run_sync for better reliability
+                result = await to_thread.run_sync(self._run_subprocess, [python_executable, script_path], timeout)
 
                 # Main execution result
                 return {

autogen/environments/venv_python_environment.py

@@ -9,7 +9,7 @@ import sys
 import tempfile
 from typing import Any
 
-from asyncer import asyncify
+from anyio import to_thread
 
 from .python_environment import PythonEnvironment
 
@@ -132,14 +132,14 @@ class VenvPythonEnvironment(PythonEnvironment):
             if script_dir:
                 os.makedirs(script_dir, exist_ok=True)
 
-            # Write the code to the script file using asyncify (from base class)
-            await asyncify(self._write_to_file)(script_path, code)
+            # Write the code to the script file using anyio.to_thread.run_sync (from base class)
+            await to_thread.run_sync(self._write_to_file, script_path, code)
 
             logging.info(f"Wrote code to {script_path}")
 
             try:
-                # Execute directly with subprocess using asyncify for better reliability
-                result = await asyncify(self._run_subprocess)([python_executable, script_path], timeout)
+                # Execute directly with subprocess using anyio.to_thread.run_sync for better reliability
+                result = await to_thread.run_sync(self._run_subprocess, [python_executable, script_path], timeout)
 
                 # Main execution result
                 return {

autogen/events/agent_events.py

@@ -946,7 +946,7 @@ class GenerateCodeExecutionReplyEvent(BaseEvent):
         else:
             f(
                 colored(
-                    f"\n>>>>>>>> EXECUTING {num_code_blocks} CODE BLOCKS (inferred languages are [{', '.join([x for x in self.code_blocks])}])...",
+                    f"\n>>>>>>>> EXECUTING {num_code_blocks} CODE BLOCKS (inferred languages are [{', '.join(list(self.code_blocks))}])...",
                     "red",
                 ),
                 flush=True,

autogen/events/client_events.py

@@ -62,7 +62,7 @@ def _change_usage_summary_format(
         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 = dict(v.items())
                 current_usage["model"] = k
                 usage_summary_altered_format["usages"].append(current_usage)
             else:

autogen/fast_depends/utils.py

@@ -26,6 +26,16 @@ P = ParamSpec("P")
 T = TypeVar("T")
 
 
+def asyncify(func: Callable[P, T]) -> Callable[P, Awaitable[T]]:
+    if is_coroutine_callable(func):
+        return cast(Callable[P, Awaitable[T]], func)
+
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+        return await run_in_threadpool(func, *args, **kwargs)
+
+    return wrapper
+
+
 async def run_async(
     func: Callable[P, T] | Callable[P, Awaitable[T]],
     *args: P.args,

autogen/graph_utils.py

@@ -24,7 +24,7 @@ def has_self_loops(allowed_speaker_transitions: dict[str, list[Agent]]) -> bool:
     Returns:
         True if there are self loops in the allowed_speaker_transitions_Dict.
     """
-    return any([key in value for key, value in allowed_speaker_transitions.items()])
+    return any(key in value for key, value in allowed_speaker_transitions.items())
 
 
 def check_graph_validity(
@@ -58,17 +58,15 @@ def check_graph_validity(
         raise ValueError("allowed_speaker_transitions_dict must be a dictionary.")
 
     # All values must be lists of Agent or empty
-    if not all([isinstance(value, list) for value in allowed_speaker_transitions_dict.values()]):
+    if not all(isinstance(value, list) for value in allowed_speaker_transitions_dict.values()):
         raise ValueError("allowed_speaker_transitions_dict must be a dictionary with lists as values.")
 
     # Check 2. Every key exists in agents
-    if not all([key in agents for key in allowed_speaker_transitions_dict]):
+    if not all(key in agents for key in allowed_speaker_transitions_dict):
         raise ValueError("allowed_speaker_transitions_dict has keys not in agents.")
 
     # Check 3. Every value is a list of Agents or empty list (not string).
-    if not all([
-        all([isinstance(agent, Agent) for agent in value]) for value in allowed_speaker_transitions_dict.values()
-    ]):
+    if not all(all(isinstance(agent, Agent) for agent in value) for value in allowed_speaker_transitions_dict.values()):
         raise ValueError("allowed_speaker_transitions_dict has values that are not lists of Agents.")
 
     # Warnings
@@ -129,7 +127,7 @@ def invert_disallowed_to_allowed(
         allowed_speaker_transitions_dict: A dictionary of keys and list as values. The keys are the names of the agents, and the values are the names of the agents that the key agent can transition to.
     """
     # Create a fully connected allowed_speaker_transitions_dict of all agents
-    allowed_speaker_transitions_dict = {agent: [other_agent for other_agent in agents] for agent in agents}
+    allowed_speaker_transitions_dict = {agent: list(agents) for agent in agents}
 
     # Remove edges from allowed_speaker_transitions_dict according to the disallowed_speaker_transitions_dict
     for key, value in disallowed_speaker_transitions_dict.items():

autogen/import_utils.py

@@ -14,6 +14,10 @@ from logging import getLogger
 from pathlib import Path
 from typing import Any, Generic, Optional, TypeVar
 
+from packaging import version
+
+from .fast_depends.utils import is_coroutine_callable
+
 __all__ = [
     "optional_import_block",
     "patch_object",
@@ -53,25 +57,34 @@ class ModuleInfo:
                     # Aka similarly named module in the autogen or test directory
                     return f"'{self.name}' is not installed."
 
-        installed_version = (
+        # Ensure that the retrieved version is a string. Some packages might unexpectedly
+        # have a __version__ attribute that is not a string (e.g., a module).
+        raw_version_attr = (
             sys.modules[self.name].__version__ if hasattr(sys.modules[self.name], "__version__") else None
         )
+        installed_version = raw_version_attr if isinstance(raw_version_attr, str) else None
         if installed_version is None and (self.min_version or self.max_version):
             return f"'{self.name}' is installed, but the version is not available."
 
-        if self.min_version:
-            msg = f"'{self.name}' is installed, but the installed version {installed_version} is too low (required '{self}')."
-            if not self.min_inclusive and installed_version == self.min_version:
-                return msg
-            if self.min_inclusive and installed_version < self.min_version:  # type: ignore[operator]
-                return msg
-
-        if self.max_version:
-            msg = f"'{self.name}' is installed, but the installed version {installed_version} is too high (required '{self}')."
-            if not self.max_inclusive and installed_version == self.max_version:
-                return msg
-            if self.max_inclusive and installed_version > self.max_version:  # type: ignore[operator]
-                return msg
+        if installed_version:
+            # Convert to version object for comparison
+            installed_ver = version.parse(installed_version)
+
+            if self.min_version:
+                min_ver = version.parse(self.min_version)
+                msg = f"'{self.name}' is installed, but the installed version {installed_version} is too low (required '{self}')."
+                if not self.min_inclusive and installed_ver == min_ver:
+                    return msg
+                if self.min_inclusive and installed_ver < min_ver:
+                    return msg
+
+            if self.max_version:
+                max_ver = version.parse(self.max_version)
+                msg = f"'{self.name}' is installed, but the installed version {installed_version} is too high (required '{self}')."
+                if not self.max_inclusive and installed_ver == max_ver:
+                    return msg
+                if self.max_inclusive and installed_ver > max_ver:
+                    return msg
 
         return None
 
@@ -470,7 +483,7 @@ def run_for_optional_imports(modules: str | Iterable[str], dep_target: str) -> C
         if isinstance(o, type):
             wrapped = require_optional_import(modules, dep_target)(o)
         else:
-            if inspect.iscoroutinefunction(o):
+            if is_coroutine_callable(o):
 
                 @wraps(o)
                 async def wrapped(*args: Any, **kwargs: Any) -> Any:

autogen/interop/pydantic_ai/pydantic_ai.py

@@ -63,19 +63,22 @@ class PydanticAIInteroperability:
 
         @wraps(f)
         def wrapper(*args: Any, **kwargs: Any) -> Any:
-            if tool_typed.current_retry >= max_retries:
+            current_retry = 0 if ctx_typed is None else ctx_typed.retries.get(tool_typed.name, 0)
+
+            if current_retry >= max_retries:
                 raise ValueError(f"{tool_typed.name} failed after {max_retries} retries")
 
             try:
                 if ctx_typed is not None:
                     kwargs.pop("ctx", None)
-                    ctx_typed.retry = tool_typed.current_retry
+                    ctx_typed.retry = current_retry
                     result = f(**kwargs, ctx=ctx_typed)  # type: ignore[call-arg]
+                    ctx_typed.retries[tool_typed.name] = 0
                 else:
                     result = f(**kwargs)  # type: ignore[call-arg]
-                tool_typed.current_retry = 0
             except Exception as e:
-                tool_typed.current_retry += 1
+                if ctx_typed is not None:
+                    ctx_typed.retries[tool_typed.name] += 1
                 raise e
 
             return result
@@ -151,7 +154,7 @@ class PydanticAIInteroperability:
             name=pydantic_ai_tool.name,
             description=pydantic_ai_tool.description,
             func_or_tool=func,
-            parameters_json_schema=pydantic_ai_tool._parameters_json_schema,
+            parameters_json_schema=pydantic_ai_tool.function_schema.json_schema,
         )
 
     @classmethod