Merge pull request #848 from garylin2099/ci_dev

add async fn type to tool schema

metagpt/environment/base_env.py

@@ -4,7 +4,7 @@
 
 import asyncio
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Iterable, Optional, Set, Union
+from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Set, Union
 
 from pydantic import BaseModel, ConfigDict, Field, SerializeAsAny, model_validator
 
@@ -104,7 +104,7 @@ class Environment(ExtEnv):
 
     desc: str = Field(default="")  # 环境描述
     roles: dict[str, SerializeAsAny["Role"]] = Field(default_factory=dict, validate_default=True)
-    member_addrs: dict["Role", Set] = Field(default_factory=dict, exclude=True)
+    member_addrs: Dict["Role", Set] = Field(default_factory=dict, exclude=True)
     history: str = ""  # For debug
     context: Context = Field(default_factory=Context, exclude=True)
 

metagpt/tools/tool_convert.py

@@ -15,18 +15,19 @@ def convert_code_to_tool_schema(obj, include: list[str] = []):
             # method_doc = inspect.getdoc(method)
             method_doc = get_class_method_docstring(obj, name)
             if method_doc:
-                function_type = "function" if not inspect.iscoroutinefunction(method) else "async_function"
-                schema["methods"][name] = {"type": function_type, **docstring_to_schema(method_doc)}
+                schema["methods"][name] = function_docstring_to_schema(method, method_doc)
 
     elif inspect.isfunction(obj):
-        schema = {
-            "type": "function",
-            **docstring_to_schema(docstring),
-        }
+        schema = function_docstring_to_schema(obj, docstring)
 
     return schema
 
 
+def function_docstring_to_schema(fn_obj, docstring):
+    function_type = "function" if not inspect.iscoroutinefunction(fn_obj) else "async_function"
+    return {"type": function_type, **docstring_to_schema(docstring)}
+
+
 def docstring_to_schema(docstring: str):
     if docstring is None:
         return {}

tests/metagpt/tools/test_tool_convert.py

@@ -95,12 +95,26 @@ def dummy_fn(df: pd.DataFrame) -> dict:
     pass
 
 
+async def dummy_async_fn(df: pd.DataFrame) -> dict:
+    """
+    A dummy async function for test
+
+    Args:
+        df (pd.DataFrame): test args.
+
+    Returns:
+        dict: test returns.
+    """
+    pass
+
+
 def test_convert_code_to_tool_schema_class():
     expected = {
         "type": "class",
         "description": "Completing missing values with simple strategies.",
         "methods": {
             "__init__": {
+                "type": "function",
                 "description": "Initialize self.",
                 "parameters": {
                     "properties": {
@@ -121,6 +135,7 @@ def test_convert_code_to_tool_schema_class():
                 },
             },
             "fit": {
+                "type": "function",
                 "description": "Fit the FillMissingValue model.",
                 "parameters": {
                     "properties": {"df": {"type": "pd.DataFrame", "description": "The input DataFrame."}},
@@ -128,6 +143,7 @@ def test_convert_code_to_tool_schema_class():
                 },
             },
             "transform": {
+                "type": "function",
                 "description": "Transform the input DataFrame with the fitted model.",
                 "parameters": {
                     "properties": {"df": {"type": "pd.DataFrame", "description": "The input DataFrame."}},
@@ -152,3 +168,8 @@ def test_convert_code_to_tool_schema_function():
     }
     schema = convert_code_to_tool_schema(dummy_fn)
     assert schema == expected
+
+
+def test_convert_code_to_tool_schema_async_function():
+    schema = convert_code_to_tool_schema(dummy_async_fn)
+    assert schema.get("type") == "async_function"