Update pydantic and dataclass in function handling

Author: dirkbrnd

libs/agno/agno/agent/agent.py

@@ -6157,7 +6157,6 @@ def register_agent(self) -> None:
             if not self.session_id:
                 self.session_id = str(uuid4())
 
-            log_debug(f"Creating Agent on Platform: {self.name}, {self.agent_id}, {self.team_id}, {self.workflow_id}")
             create_agent(
                 agent=AgentCreate(
                     name=self.name,
@@ -6168,7 +6167,6 @@ def register_agent(self) -> None:
                     config=self.get_agent_config_dict(),
                 )
             )
-            log_debug(f"Agent created: {self.name}, {self.agent_id}, {self.team_id}, {self.workflow_id}")
         except Exception as e:
             log_warning(f"Could not create Agent: {e}")
 
@@ -6180,7 +6178,6 @@ async def _aregister_agent(self) -> None:
         from agno.api.agent import AgentCreate, acreate_agent
 
         try:
-            log_debug(f"Creating Agent on Platform: {self.name}, {self.agent_id}, {self.team_id},")
             await acreate_agent(
                 agent=AgentCreate(
                     name=self.name,
@@ -6193,7 +6190,6 @@ async def _aregister_agent(self) -> None:
             )
         except Exception as e:
             log_debug(f"Could not create Agent app: {e}")
-        log_debug(f"Agent app created: {self.name}, {self.agent_id}, {self.team_id},")
 
     def _log_agent_run(self, session_id: str, user_id: Optional[str] = None) -> None:
         self.set_monitoring()

libs/agno/agno/api/agent.py

@@ -48,6 +48,7 @@ async def acreate_agent_run(run: AgentRunCreate, monitor: bool = False) -> None:
             )
         except Exception as e:
             log_debug(f"Could not create Agent run: {e}")
+    return
 
 
 def create_agent(agent: AgentCreate) -> None:
@@ -60,8 +61,11 @@ def create_agent(agent: AgentCreate) -> None:
                 ApiRoutes.AGENT_CREATE,
                 json=agent.model_dump(exclude_none=True),
             )
+            
+            log_debug(f"Created Agent on Platform. ID: {agent.agent_id}")
         except Exception as e:
             log_debug(f"Could not create Agent: {e}")
+    return
 
 
 async def acreate_agent(agent: AgentCreate) -> None:
@@ -74,5 +78,7 @@ async def acreate_agent(agent: AgentCreate) -> None:
                 ApiRoutes.AGENT_CREATE,
                 json=agent.model_dump(exclude_none=True),
             )
+            log_debug(f"Created Agent on Platform. ID: {agent.agent_id}")
         except Exception as e:
             log_debug(f"Could not create Agent: {e}")
+    return

libs/agno/agno/models/openai/chat.py

@@ -185,7 +185,7 @@ def get_request_kwargs(
         # Add tools
         if tools is not None and len(tools) > 0:
             request_params["tools"] = tools
-
+            
             if tool_choice is not None:
                 request_params["tool_choice"] = tool_choice
 

libs/agno/agno/utils/json_schema.py

@@ -1,5 +1,7 @@
 from typing import Any, Dict, Optional, Union, get_args, get_origin
 
+from pydantic import BaseModel
+
 from agno.utils.log import logger
 
 
@@ -38,13 +40,86 @@ def get_json_type_for_py_type(arg: str) -> str:
     return "object"
 
 
-def get_json_schema_for_arg(t: Any) -> Optional[Dict[str, Any]]:
+def inline_pydantic_schema(schema: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively inline Pydantic model schemas by replacing $ref with actual schema.
+    """
+    if not isinstance(schema, dict):
+        return schema
+
+    def resolve_ref(ref: str, defs: Dict[str, Any]) -> Dict[str, Any]:
+        """Resolve a $ref to its actual schema."""
+        if not ref.startswith("#/$defs/"):
+            return {"type": "object"}  # Fallback for external refs
+
+        def_name = ref.split("/")[-1]
+        if def_name in defs:
+            return defs[def_name]
+        return {"type": "object"}  # Fallback if definition not found
+
+    def process_schema(s: Dict[str, Any], defs: Dict[str, Any]) -> Dict[str, Any]:
+        """Process a schema dictionary, resolving all references."""
+        if not isinstance(s, dict):
+            return s
+
+        # Handle $ref
+        if "$ref" in s:
+            return resolve_ref(s["$ref"], defs)
+
+        # Create a new dict to avoid modifying the input
+        result = s.copy()
+
+        # Handle arrays
+        if "items" in result:
+            result["items"] = process_schema(result["items"], defs)
+
+        # Handle object properties
+        if "properties" in result:
+            for prop_name, prop_schema in result["properties"].items():
+                result["properties"][prop_name] = process_schema(prop_schema, defs)
+
+        # Handle anyOf (for Union types)
+        if "anyOf" in result:
+            result["anyOf"] = [process_schema(sub_schema, defs) for sub_schema in result["anyOf"]]
+
+        # Handle allOf (for inheritance)
+        if "allOf" in result:
+            result["allOf"] = [process_schema(sub_schema, defs) for sub_schema in result["allOf"]]
+
+        # Handle additionalProperties
+        if "additionalProperties" in result:
+            result["additionalProperties"] = process_schema(result["additionalProperties"], defs)
+
+        # Handle propertyNames
+        if "propertyNames" in result:
+            result["propertyNames"] = process_schema(result["propertyNames"], defs)
+
+        return result
+
+    # Store definitions for later use
+    definitions = schema.pop("$defs", {})
+
+    # First, resolve any nested references in definitions
+    resolved_definitions = {}
+    for def_name, def_schema in definitions.items():
+        resolved_definitions[def_name] = process_schema(def_schema, definitions)
+
+    # Process the main schema with resolved definitions
+    result = process_schema(schema, resolved_definitions)
+
+    # Remove any remaining definitions
+    if "$defs" in result:
+        del result["$defs"]
+
+    return result
+
+
+def get_json_schema_for_arg(type_hint: Any) -> Optional[Dict[str, Any]]:
     # log_info(f"Getting JSON schema for arg: {t}")
-    type_args = get_args(t)
+    type_args = get_args(type_hint)
     # log_info(f"Type args: {type_args}")
-    type_origin = get_origin(t)
+    type_origin = get_origin(type_hint)
     # log_info(f"Type origin: {type_origin}")
-
     if type_origin is not None:
         if type_origin in (list, tuple, set, frozenset):
             json_schema_for_items = get_json_schema_for_arg(type_args[0]) if type_args else {"type": "string"}
@@ -65,7 +140,39 @@ def get_json_schema_for_arg(t: Any) -> Optional[Dict[str, Any]]:
                     continue
             return {"anyOf": types} if types else None
 
-    json_schema: Dict[str, Any] = {"type": get_json_type_for_py_type(t.__name__)}
+    elif issubclass(type_hint, BaseModel):
+        # Get the schema and inline it
+        schema = type_hint.model_json_schema()
+        return inline_pydantic_schema(schema)
+    elif hasattr(type_hint, "__dataclass_fields__"):
+        # Convert dataclass to JSON schema
+        properties = {}
+        required = []
+
+        for field_name, field in type_hint.__dataclass_fields__.items():
+            field_type = field.type
+            field_schema = get_json_schema_for_arg(field_type)
+            
+            if "anyOf" in field_schema and any(schema["type"] == "null" for schema in field_schema["anyOf"]):
+                field_schema["type"] = next(schema["type"] for schema in field_schema["anyOf"] if schema["type"] != "null")
+                field_schema.pop("anyOf")
+            else:
+                required.append(field_name)
+
+            if field_schema:
+                properties[field_name] = field_schema
+
+        arg_json_schema = {
+            "type": "object",
+            "properties": properties,
+            "additionalProperties": False
+        }
+
+        if required:
+            arg_json_schema["required"] = required
+        return arg_json_schema
+
+    json_schema: Dict[str, Any] = {"type": get_json_type_for_py_type(type_hint.__name__)}
     if json_schema["type"] == "object":
         json_schema["properties"] = {}
         json_schema["additionalProperties"] = False
@@ -83,38 +190,37 @@ def get_json_schema(
         json_schema["additionalProperties"] = False
 
     # We only include the fields in the type_hints dict
-    for k, v in type_hints.items():
+    for parameter_name, type_hint in type_hints.items():
         # log_info(f"Parsing arg: {k} | {v}")
-        if k == "return":
+        if parameter_name == "return":
             continue
 
         try:
             # Check if type is Optional (Union with NoneType)
-            type_origin = get_origin(v)
-            type_args = get_args(v)
+            type_origin = get_origin(type_hint)
+            type_args = get_args(type_hint)
             is_optional = type_origin is Union and len(type_args) == 2 and any(arg is type(None) for arg in type_args)
 
             # Get the actual type if it's Optional
             if is_optional:
-                v = next(arg for arg in type_args if arg is not type(None))
+                type_hint = next(arg for arg in type_args if arg is not type(None))
 
-            # Handle cases with no type hint
-            if v:
-                arg_json_schema = get_json_schema_for_arg(v)
+            if type_hint:
+                arg_json_schema = get_json_schema_for_arg(type_hint)
             else:
                 arg_json_schema = {}
 
             if arg_json_schema is not None:
                 # Add description
-                if param_descriptions and k in param_descriptions and param_descriptions[k]:
-                    arg_json_schema["description"] = param_descriptions[k]
+                if param_descriptions and parameter_name in param_descriptions and param_descriptions[parameter_name]:
+                    arg_json_schema["description"] = param_descriptions[parameter_name]
 
-                json_schema["properties"][k] = arg_json_schema
+                json_schema["properties"][parameter_name] = arg_json_schema
 
             else:
-                logger.warning(f"Could not parse argument {k} of type {v}")
+                logger.warning(f"Could not parse argument {parameter_name} of type {type_hint}")
         except Exception as e:
-            logger.error(f"Error processing argument {k}: {str(e)}")
+            logger.error(f"Error processing argument {parameter_name}: {str(e)}")
             continue
 
     return json_schema

libs/agno/agno/workflow/workflow.py

@@ -680,15 +680,14 @@ def register_workflow(self, force: bool = False) -> None:
             from agno.api.workflows import create_workflow
 
             workflow_config = self.to_config_dict()
-            log_debug(f"Registering workflow: {self.name} (ID: {self.workflow_id})")
             # Register the workflow as an app
             create_workflow(
                 workflow=WorkflowCreate(
                     name=self.name, workflow_id=self.workflow_id, app_id=self.app_id, config=workflow_config
                 )
             )
 
-            log_debug(f"Successfully registered workflow: {self.name} (ID: {self.workflow_id})")
+            log_debug(f"Registered workflow: {self.name} (ID: {self.workflow_id})")
         except Exception as e:
             log_warning(f"Failed to register workflow: {e}")