agno 2.0.0a1__py3-none-any.whl → 2.0.0rc1__py3-none-any.whl

agno/tools/function.py

@@ -1,14 +1,14 @@
 from dataclasses import dataclass
 from functools import partial
 from importlib.metadata import version
-from typing import Any, Callable, Dict, List, Literal, Optional, Type, TypeVar, get_type_hints
+from typing import Any, Callable, Dict, List, Literal, Optional, Sequence, Type, TypeVar, get_type_hints
 
 from docstring_parser import parse
 from packaging.version import Version
 from pydantic import BaseModel, Field, validate_call
 
 from agno.exceptions import AgentRunException
-from agno.media import AudioArtifact, ImageArtifact, VideoArtifact
+from agno.media import Audio, AudioArtifact, File, Image, ImageArtifact, Video, VideoArtifact
 from agno.utils.log import log_debug, log_error, log_exception, log_warning
 
 T = TypeVar("T")
@@ -125,6 +125,12 @@ class Function(BaseModel):
     # The session state that the function is associated with
     _session_state: Optional[Dict[str, Any]] = None
 
+    # Media context that the function is associated with
+    _images: Optional[Sequence[Image]] = None
+    _videos: Optional[Sequence[Video]] = None
+    _audios: Optional[Sequence[Audio]] = None
+    _files: Optional[Sequence[File]] = None
+
     def to_dict(self) -> Dict[str, Any]:
         return self.model_dump(
             exclude_none=True,
@@ -150,13 +156,23 @@ class Function(BaseModel):
                 del type_hints["team"]
             if "session_state" in sig.parameters and "session_state" in type_hints:
                 del type_hints["session_state"]
+            # Remove media parameters from type hints as they are injected automatically
+            if "images" in sig.parameters and "images" in type_hints:
+                del type_hints["images"]
+            if "videos" in sig.parameters and "videos" in type_hints:
+                del type_hints["videos"]
+            if "audios" in sig.parameters and "audios" in type_hints:
+                del type_hints["audios"]
+            if "files" in sig.parameters and "files" in type_hints:
+                del type_hints["files"]
             # log_info(f"Type hints for {function_name}: {type_hints}")
 
             # Filter out return type and only process parameters
             param_type_hints = {
                 name: type_hints.get(name)
                 for name in sig.parameters
-                if name != "return" and name not in ["agent", "team", "session_state", "self"]
+                if name != "return"
+                and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
             }
 
             # Parse docstring for parameters
@@ -183,14 +199,17 @@ class Function(BaseModel):
             # See: https://platform.openai.com/docs/guides/structured-outputs/supported-schemas#all-fields-must-be-required
             if strict:
                 parameters["required"] = [
-                    name for name in parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
+                    name
+                    for name in parameters["properties"]
+                    if name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
                 ]
             else:
                 # Mark a field as required if it has no default value (this would include optional fields)
                 parameters["required"] = [
                     name
                     for name, param in sig.parameters.items()
-                    if param.default == param.empty and name not in ["agent", "team", "session_state", "self"]
+                    if param.default == param.empty
+                    and name not in ["agent", "team", "session_state", "self", "images", "videos", "audios", "files"]
                 ]
 
             # log_debug(f"JSON schema for {function_name}: {parameters}")
@@ -241,10 +260,28 @@ class Function(BaseModel):
                 del type_hints["team"]
             if "session_state" in sig.parameters and "session_state" in type_hints:
                 del type_hints["session_state"]
+            if "images" in sig.parameters and "images" in type_hints:
+                del type_hints["images"]
+            if "videos" in sig.parameters and "videos" in type_hints:
+                del type_hints["videos"]
+            if "audios" in sig.parameters and "audios" in type_hints:
+                del type_hints["audios"]
+            if "files" in sig.parameters and "files" in type_hints:
+                del type_hints["files"]
             # log_info(f"Type hints for {self.name}: {type_hints}")
 
             # Filter out return type and only process parameters
-            excluded_params = ["return", "agent", "team", "session_state", "self"]
+            excluded_params = [
+                "return",
+                "agent",
+                "team",
+                "session_state",
+                "self",
+                "images",
+                "videos",
+                "audios",
+                "files",
+            ]
             if self.requires_user_input and self.user_input_fields:
                 if len(self.user_input_fields) == 0:
                     excluded_params.extend(list(type_hints.keys()))
@@ -357,7 +394,9 @@ class Function(BaseModel):
     def process_schema_for_strict(self):
         self.parameters["additionalProperties"] = False
         self.parameters["required"] = [
-            name for name in self.parameters["properties"] if name not in ["agent", "team", "session_state", "self"]
+            name
+            for name in self.parameters["properties"]
+            if name not in ["agent", "team", "session_state", "images", "videos", "audios", "files", "self"]
         ]
 
     def _get_cache_key(self, entrypoint_args: Dict[str, Any], call_args: Optional[Dict[str, Any]] = None) -> str:
@@ -372,6 +411,14 @@ class Function(BaseModel):
             del copy_entrypoint_args["team"]
         if "session_state" in copy_entrypoint_args:
             del copy_entrypoint_args["session_state"]
+        if "images" in copy_entrypoint_args:
+            del copy_entrypoint_args["images"]
+        if "videos" in copy_entrypoint_args:
+            del copy_entrypoint_args["videos"]
+        if "audios" in copy_entrypoint_args:
+            del copy_entrypoint_args["audios"]
+        if "files" in copy_entrypoint_args:
+            del copy_entrypoint_args["files"]
         args_str = str(copy_entrypoint_args)
 
         kwargs_str = str(sorted((call_args or {}).items()))
@@ -554,6 +601,17 @@ class FunctionCall(BaseModel):
         # Check if the entrypoint has an fc argument
         if "fc" in signature(self.function.entrypoint).parameters:  # type: ignore
             entrypoint_args["fc"] = self
+
+        # Check if the entrypoint has media arguments
+        if "images" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["images"] = self.function._images
+        if "videos" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["videos"] = self.function._videos
+        if "audios" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["audios"] = self.function._audios
+        if "files" in signature(self.function.entrypoint).parameters:  # type: ignore
+            entrypoint_args["files"] = self.function._files
+
         return entrypoint_args
 
     def _build_hook_args(self, hook: Callable, name: str, func: Callable, args: Dict[str, Any]) -> Dict[str, Any]:

agno/tools/linear.py

@@ -202,7 +202,7 @@ class LinearTools(Toolkit):
         """
 
         query = """
-        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String!, $assigneeId: String!){
+        mutation IssueCreate ($title: String!, $description: String!, $teamId: String!, $projectId: String, $assigneeId: String){
           issueCreate(
             input: { title: $title, description: $description, teamId: $teamId, projectId: $projectId, assigneeId: $assigneeId}
           ) {

agno/utils/gemini.py

@@ -175,7 +175,37 @@ def convert_schema(schema_dict: Dict[str, Any], root_schema: Optional[Dict[str,
 
     elif schema_type == "array" and "items" in schema_dict:
         items = convert_schema(schema_dict["items"], root_schema)
-        return Schema(type=Type.ARRAY, description=description, items=items)
+        min_items = schema_dict.get("minItems")
+        max_items = schema_dict.get("maxItems")
+        return Schema(
+            type=Type.ARRAY,
+            description=description,
+            items=items,
+            min_items=min_items,
+            max_items=max_items,
+        )
+
+    elif schema_type == "string":
+        schema_kwargs = {
+            "type": Type.STRING,
+            "description": description,
+            "default": default,
+        }
+        if "format" in schema_dict:
+            schema_kwargs["format"] = schema_dict["format"]
+        return Schema(**schema_kwargs)
+
+    elif schema_type in ("integer", "number"):
+        schema_kwargs = {
+            "type": schema_type.upper(),
+            "description": description,
+            "default": default,
+        }
+        if "maximum" in schema_dict:
+            schema_kwargs["maximum"] = schema_dict["maximum"]
+        if "minimum" in schema_dict:
+            schema_kwargs["minimum"] = schema_dict["minimum"]
+        return Schema(**schema_kwargs)
 
     elif schema_type == "" and "anyOf" in schema_dict:
         any_of = []

agno/utils/models/claude.py

@@ -286,3 +286,52 @@ def format_messages(messages: List[Message]) -> Tuple[List[Dict[str, str]], str]
 
         chat_messages.append({"role": ROLE_MAP[message.role], "content": content})  # type: ignore
     return chat_messages, " ".join(system_messages)
+
+
+def format_tools_for_model(tools: Optional[List[Dict[str, Any]]] = None) -> Optional[List[Dict[str, Any]]]:
+    """
+    Transforms function definitions into a format accepted by the Anthropic API.
+    """
+    if not tools:
+        return None
+
+    parsed_tools: List[Dict[str, Any]] = []
+    for tool_def in tools:
+        if tool_def.get("type", "") != "function":
+            parsed_tools.append(tool_def)
+            continue
+
+        func_def = tool_def.get("function", {})
+        parameters: Dict[str, Any] = func_def.get("parameters", {})
+        properties: Dict[str, Any] = parameters.get("properties", {})
+        required: List[str] = parameters.get("required", [])
+        required_params: List[str] = required
+
+        if not required_params:
+            for param_name, param_info in properties.items():
+                param_type = param_info.get("type", "")
+                param_type_list: List[str] = [param_type] if isinstance(param_type, str) else param_type or []
+
+                if "null" not in param_type_list:
+                    required_params.append(param_name)
+
+        input_properties: Dict[str, Any] = {}
+        for param_name, param_info in properties.items():
+            # Preserve the complete schema structure for complex types
+            input_properties[param_name] = param_info.copy()
+
+            # Ensure description is present (default to empty if missing)
+            if "description" not in input_properties[param_name]:
+                input_properties[param_name]["description"] = ""
+
+        tool = {
+            "name": func_def.get("name") or "",
+            "description": func_def.get("description") or "",
+            "input_schema": {
+                "type": parameters.get("type", "object"),
+                "properties": input_properties,
+                "required": required_params,
+            },
+        }
+        parsed_tools.append(tool)
+    return parsed_tools