fix tool calling argument

Signed-off-by: Akihiko Kuroda <akihikokuroda2020@gmail.com>

Author: akihikokuroda

docs/examples/agents/react/react_using_mellea.py

@@ -41,14 +41,15 @@ async def main():
     print(out)
 
     # Version that looks up info and formats the final response as an Email object.
-    # out, _ = await react(
-    #     goal="Write an email about the Mellea python library to Jake with the subject 'cool library'.",
-    #     context=ChatContext(),
-    #     backend=m.backend,
-    #     tools=[search_tool],
-    #     format=Email
-    # )
-    # print(out)
+    out, _ = await react(
+        goal="Write an email about the Mellea python library to Jake with the subject 'cool library'.",
+        context=ChatContext(),
+        backend=m.backend,
+        tools=[search_tool],
+        format=Email,
+        loop_budget=20,
+    )
+    print(out)
 
 
 asyncio.run(main())

mellea/backends/tools.py

@@ -499,19 +499,41 @@ def validate_tool_arguments(
         "object": dict,
     }
 
-    # Build Pydantic model from JSON schema
-    field_definitions: dict[str, Any] = {}
+    # Helper function to build Pydantic model from nested JSON schema
+    def _build_pydantic_type_from_schema(schema: dict[str, Any]) -> Any:
+        """Recursively build Pydantic type from JSON schema."""
+        json_type = schema.get("type", "string")
+
+        # Handle nested objects with properties
+        if json_type == "object" and "properties" in schema:
+            nested_properties = schema.get("properties", {})
+            nested_required = schema.get("required", [])
+            nested_fields: dict[str, Any] = {}
+
+            for nested_name, nested_schema in nested_properties.items():
+                nested_type = _build_pydantic_type_from_schema(nested_schema)
+                if nested_name in nested_required:
+                    nested_fields[nested_name] = (nested_type, ...)
+                else:
+                    nested_fields[nested_name] = (nested_type, None)
+
+            # Create a nested Pydantic model
+            return create_model(
+                f"Nested_{hash(str(schema))}",
+                __config__=ConfigDict(extra="allow"),
+                **nested_fields,
+            )
 
-    for param_name, param_schema in properties.items():
-        # Get type from JSON schema
-        json_type = param_schema.get("type", "string")
+        # Handle arrays
+        if json_type == "array":
+            item_schema = schema.get("items", {})
+            item_type = _build_pydantic_type_from_schema(item_schema)
+            return list[item_type]  # type: ignore
 
-        # Handle comma-separated types (e.g., "integer, string" for Union types)
+        # Handle comma-separated types (Union types)
         if isinstance(json_type, str) and "," in json_type:
-            # Create Union type for multiple types
             type_list = [t.strip() for t in json_type.split(",")]
             python_types = [JSON_TYPE_TO_PYTHON.get(t, Any) for t in type_list]
-            # Remove duplicates while preserving order
             seen = set()
             unique_types = []
             for t in python_types:
@@ -520,15 +542,36 @@ def validate_tool_arguments(
                     unique_types.append(t)
 
             if len(unique_types) == 1:
-                param_type = unique_types[0]
+                return unique_types[0]
             else:
                 from functools import reduce
                 from operator import or_
 
-                param_type = reduce(or_, unique_types)
-        else:
-            # Map to Python type
-            param_type = JSON_TYPE_TO_PYTHON.get(json_type, Any)
+                return reduce(or_, unique_types)
+
+        # Handle anyOf (union types in JSON schema)
+        if "anyOf" in schema:
+            types_list = []
+            for sub_schema in schema["anyOf"]:
+                sub_type = _build_pydantic_type_from_schema(sub_schema)
+                types_list.append(sub_type)
+
+            if len(types_list) == 1:
+                return types_list[0]
+            else:
+                from functools import reduce
+                from operator import or_
+
+                return reduce(or_, types_list)
+
+        # Simple type mapping
+        return JSON_TYPE_TO_PYTHON.get(json_type, Any)
+
+    # Build Pydantic model from JSON schema
+    field_definitions: dict[str, Any] = {}
+
+    for param_name, param_schema in properties.items():
+        param_type = _build_pydantic_type_from_schema(param_schema)
 
         # Determine if parameter is required
         if param_name in required_fields:
@@ -784,14 +827,20 @@ class Property(SubscriptableBaseModel):
                     items (Any | None): Schema for array element types, if applicable.
                     description (str | None): Human-readable description of this parameter.
                     enum (Sequence[Any] | None): Allowed values for this parameter, if constrained.
+                    properties (Mapping[str, Any] | None): Nested properties for object types.
+                    required (Sequence[str] | None): Required fields for nested objects.
+                    title (str | None): Title for the property schema.
                 """
 
-                model_config = ConfigDict(arbitrary_types_allowed=True)
+                model_config = ConfigDict(arbitrary_types_allowed=True, extra="allow")
 
                 type: str | Sequence[str] | None = None
                 items: Any | None = None
                 description: str | None = None
                 enum: Sequence[Any] | None = None
+                properties: Mapping[str, Any] | None = None
+                required: Sequence[str] | None = None
+                title: str | None = None
 
             properties: Mapping[str, Property] | None = None
 
@@ -851,7 +900,7 @@ def convert_function_to_ollama_tool(
 ) -> OllamaTool:
     """Convert a Python callable to an Ollama-compatible tool schema.
 
-    Imported from Ollama.
+    Imported from Ollama, with enhancements to support Pydantic BaseModel parameters.
 
     Args:
         func: The Python callable to convert.
@@ -861,6 +910,8 @@ def convert_function_to_ollama_tool(
         An ``OllamaTool`` instance representing the function as an OpenAI-compatible
         tool schema.
     """
+    import copy
+
     doc_string_hash = str(hash(inspect.getdoc(func)))
     parsed_docstring = _parse_docstring(inspect.getdoc(func))
     schema = type(
@@ -876,21 +927,60 @@ def convert_function_to_ollama_tool(
         },
     ).model_json_schema()  # type: ignore
 
+    # Helper to resolve $ref references
+    def resolve_ref(ref_path: str, defs: dict) -> dict:
+        """Resolve a $ref path like '#/$defs/Email' to the actual schema."""
+        if ref_path.startswith("#/$defs/"):
+            def_name = ref_path.split("/")[-1]
+            return defs.get(def_name, {})
+        elif ref_path.startswith("#/definitions/"):
+            def_name = ref_path.split("/")[-1]
+            return defs.get(def_name, {})
+        return {}
+
+    defs = schema.get("$defs", schema.get("definitions", {}))
+
     for k, v in schema.get("properties", {}).items():
-        # If type is missing, the default is string
-        types = (
-            {t.get("type", "string") for t in v.get("anyOf")}
-            if "anyOf" in v
-            else {v.get("type", "string")}
-        )
-        if "null" in types:
-            schema["required"].remove(k)
-            types.discard("null")
-
-        schema["properties"][k] = {
-            "description": parsed_docstring[k],
-            "type": ", ".join(types),
-        }
+        # Check if this property has a $ref (reference to a definition)
+        if "$ref" in v:
+            # Resolve the reference and inline it
+            ref_schema = resolve_ref(v["$ref"], defs)
+            if ref_schema:
+                # Inline the referenced schema (deep copy to avoid mutations)
+                inlined = copy.deepcopy(ref_schema)
+                # Add description from docstring if available
+                if parsed_docstring.get(k):
+                    inlined["description"] = parsed_docstring[k]
+                schema["properties"][k] = inlined
+            else:
+                # Fallback if we can't resolve
+                schema["properties"][k] = {
+                    "description": parsed_docstring[k],
+                    "type": "object",
+                }
+        # Check if this property is a nested object (has 'properties' or complex types)
+        elif "properties" in v or "allOf" in v or "anyOf" in v:
+            # This is a complex/nested type - preserve the full schema
+            # Only add description if we have one
+            if parsed_docstring.get(k):
+                v["description"] = parsed_docstring[k]
+            schema["properties"][k] = v
+        else:
+            # Simple type - use the original flattening logic
+            types = (
+                {t.get("type", "string") for t in v.get("anyOf")}
+                if "anyOf" in v
+                else {v.get("type", "string")}
+            )
+            if "null" in types:
+                if k in schema.get("required", []):
+                    schema["required"].remove(k)
+                types.discard("null")
+
+            schema["properties"][k] = {
+                "description": parsed_docstring[k],
+                "type": ", ".join(types),
+            }
 
     tool = OllamaTool(
         type="function",