agno 1.8.1__tar.gz → 1.8.2__tar.gz

{agno-1.8.1 → agno-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 1.8.1
+Version: 1.8.2
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 License: Copyright (c) Agno, Inc.

agno-1.8.2/agno/__init__.py

@@ -0,0 +1,8 @@
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("agno")
+except PackageNotFoundError:
+    __version__ = "0.0.0"
+
+__all__ = ["__version__"]

{agno-1.8.1 → agno-1.8.2}/agno/agent/agent.py

@@ -1476,7 +1476,7 @@ class Agent:
 
         # Read existing session from storage
         if self.context is not None:
-            self.resolve_run_context()
+            await self.aresolve_run_context()
 
         # Prepare arguments for the model
         self.set_default_model()
@@ -2152,7 +2152,7 @@ class Agent:
 
         # Read existing session from storage
         if self.context is not None:
-            self.resolve_run_context()
+            await self.aresolve_run_context()
 
         # Prepare arguments for the model
         self.set_default_model()

{agno-1.8.1 → agno-1.8.2}/agno/agent/metrics.py

@@ -69,7 +69,10 @@ class SessionMetrics:
             # Add values from other
             if other.prompt_tokens_details:
                 for key, value in other.prompt_tokens_details.items():
-                    result.prompt_tokens_details[key] = result.prompt_tokens_details.get(key, 0) + value
+                    existing_value = result.prompt_tokens_details.get(key, 0)
+                    if not isinstance(existing_value, int):
+                        continue
+                    result.prompt_tokens_details[key] = existing_value + value
 
         # Handle completion_tokens_details similarly
         if self.completion_tokens_details or other.completion_tokens_details:

{agno-1.8.1 → agno-1.8.2}/agno/app/agui/utils.py

@@ -27,6 +27,7 @@ from agno.models.message import Message
 from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent, RunResponsePausedEvent
 from agno.run.team import RunResponseContentEvent as TeamRunResponseContentEvent
 from agno.run.team import TeamRunEvent, TeamRunResponseEvent
+from agno.utils.message import get_text_from_message
 
 
 @dataclass
@@ -106,17 +107,23 @@ def extract_team_response_chunk_content(response: TeamRunResponseContentEvent) -
                     members_content.append(f"Team member: {member_content}")
     members_response = "\n".join(members_content) if members_content else ""
 
-    return str(response.content) + members_response
+    # Handle structured outputs
+    main_content = get_text_from_message(response.content) if response.content is not None else ""
+
+    return main_content + members_response
 
 
 def extract_response_chunk_content(response: RunResponseContentEvent) -> str:
     """Given a response stream chunk, find and extract the content."""
+
     if hasattr(response, "messages") and response.messages:  # type: ignore
         for msg in reversed(response.messages):  # type: ignore
             if hasattr(msg, "role") and msg.role == "assistant" and hasattr(msg, "content") and msg.content:
-                return str(msg.content)
+                # Handle structured outputs from messages
+                return get_text_from_message(msg.content)
 
-    return str(response.content) if response.content else ""
+    # Handle structured outputs
+    return get_text_from_message(response.content) if response.content is not None else ""
 
 
 def _create_events_from_chunk(
@@ -202,11 +209,11 @@ def _create_events_from_chunk(
 
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
-        step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_started_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
+        events_to_emit.append(step_started_event)
     elif chunk.event == RunEvent.reasoning_completed:
-        step_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
-        events_to_emit.append(step_event)
+        step_finished_event = StepFinishedEvent(type=EventType.STEP_FINISHED, step_name="reasoning")
+        events_to_emit.append(step_finished_event)
 
     return events_to_emit, message_started
 
@@ -220,7 +227,7 @@ def _create_completion_events(
     run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # End remaining active tool calls if needed
     for tool_call_id in list(event_buffer.active_tool_call_ids):
@@ -271,7 +278,7 @@ def _create_completion_events(
 
 def _emit_event_logic(event: BaseEvent, event_buffer: EventBuffer) -> List[BaseEvent]:
     """Process an event through the buffer and return events to actually emit."""
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     if event_buffer.is_blocked():
         # Handle events related to the current blocking tool call

{agno-1.8.1 → agno-1.8.2}/agno/app/discord/client.py

@@ -8,6 +8,7 @@ from agno.agent.agent import Agent, RunResponse
 from agno.media import Audio, File, Image, Video
 from agno.team.team import Team, TeamRunResponse
 from agno.utils.log import log_info, log_warning
+from agno.utils.message import get_text_from_message
 
 try:
     import discord
@@ -167,7 +168,10 @@ class DiscordClient:
                 thread=thread, message=f"Reasoning: \n{response.reasoning_content}", italics=True
             )
 
-        await self._send_discord_messages(thread=thread, message=str(response.content))
+        # Handle structured outputs properly
+        content_message = get_text_from_message(response.content) if response.content is not None else ""
+
+        await self._send_discord_messages(thread=thread, message=content_message)
 
     async def _send_discord_messages(self, thread: discord.channel, message: str, italics: bool = False):  # type: ignore
         if len(message) < 1500:

{agno-1.8.1 → agno-1.8.2}/agno/app/playground/async_router.py

@@ -528,6 +528,7 @@ def get_async_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return agent_sessions
@@ -751,6 +752,7 @@ def get_async_playground_router(
                     "session_id": session.session_id,
                     "session_name": session.session_data.get("session_name") if session.session_data else None,
                     "created_at": session.created_at,
+                    "updated_at": session.updated_at,
                 }  # type: ignore
             )
         return workflow_sessions
@@ -945,6 +947,7 @@ def get_async_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return team_sessions

{agno-1.8.1 → agno-1.8.2}/agno/app/playground/schemas.py

@@ -91,6 +91,7 @@ class AgentSessionsResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class MemoryResponse(BaseModel):
@@ -115,6 +116,7 @@ class WorkflowSessionResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class WorkflowGetResponse(BaseModel):
@@ -213,6 +215,7 @@ class TeamSessionResponse(BaseModel):
     session_id: Optional[str] = None
     session_name: Optional[str] = None
     created_at: Optional[int] = None
+    updated_at: Optional[int] = None
 
 
 class TeamRenameRequest(BaseModel):

{agno-1.8.1 → agno-1.8.2}/agno/app/playground/sync_router.py

@@ -528,6 +528,7 @@ def get_sync_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return agent_sessions
@@ -743,6 +744,7 @@ def get_sync_playground_router(
                     "session_id": session.session_id,
                     "session_name": session.session_data.get("session_name") if session.session_data else None,
                     "created_at": session.created_at,
+                    "updated_at": session.updated_at,
                 }  # type: ignore
             )
         return workflow_sessions
@@ -940,6 +942,7 @@ def get_sync_playground_router(
                     session_id=session.session_id,
                     session_name=session.session_data.get("session_name") if session.session_data else None,
                     created_at=session.created_at,
+                    updated_at=session.updated_at,
                 )
             )
         return team_sessions

{agno-1.8.1 → agno-1.8.2}/agno/models/anthropic/claude.py

@@ -11,7 +11,7 @@ from agno.models.base import Model
 from agno.models.message import Citations, DocumentCitation, Message, UrlCitation
 from agno.models.response import ModelResponse
 from agno.utils.log import log_debug, log_error, log_warning
-from agno.utils.models.claude import MCPServerConfiguration, format_messages
+from agno.utils.models.claude import MCPServerConfiguration, format_messages, format_tools_for_model
 
 try:
     from anthropic import (
@@ -176,59 +176,12 @@ class Claude(Model):
                 request_kwargs["system"] = [{"text": system_message, "type": "text"}]
 
         if tools:
-            request_kwargs["tools"] = self._format_tools_for_model(tools)
+            request_kwargs["tools"] = format_tools_for_model(tools)
 
         if request_kwargs:
             log_debug(f"Calling {self.provider} with request parameters: {request_kwargs}", log_level=2)
         return request_kwargs
 
-    def _format_tools_for_model(self, 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_params: List[str] = []
-
-            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, Dict[str, Union[str, List[str]]]] = {}
-            for param_name, param_info in properties.items():
-                input_properties[param_name] = {
-                    "description": param_info.get("description", ""),
-                }
-                if "type" not in param_info and "anyOf" in param_info:
-                    input_properties[param_name]["anyOf"] = param_info["anyOf"]
-                else:
-                    input_properties[param_name]["type"] = param_info.get("type", "")
-
-            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
-
     def invoke(
         self,
         messages: List[Message],
@@ -570,16 +523,7 @@ class Claude(Model):
                 }
 
         elif isinstance(response, ContentBlockStopEvent):
-            # Handle completed thinking content
-            if response.content_block.type == "thinking":  # type: ignore
-                model_response.thinking = response.content_block.thinking  # type: ignore
-                # Store signature if available
-                if hasattr(response.content_block, "signature"):  # type: ignore
-                    model_response.provider_data = {
-                        "signature": response.content_block.signature,  # type: ignore
-                    }
-            # Handle tool calls
-            elif response.content_block.type == "tool_use":  # type: ignore
+            if response.content_block.type == "tool_use":  # type: ignore
                 tool_use = response.content_block  # type: ignore
                 tool_name = tool_use.name
                 tool_input = tool_use.input

{agno-1.8.1 → agno-1.8.2}/agno/models/aws/bedrock.py

@@ -179,14 +179,10 @@ class AwsBedrock(Model):
                 required = []
 
                 for param_name, param_info in func_def.get("parameters", {}).get("properties", {}).items():
-                    param_type = param_info.get("type")
-                    if isinstance(param_type, list):
-                        param_type = [t for t in param_type if t != "null"][0]
+                    properties[param_name] = param_info.copy()
 
-                    properties[param_name] = {
-                        "type": param_type or "string",
-                        "description": param_info.get("description") or "",
-                    }
+                    if "description" not in properties[param_name]:
+                        properties[param_name]["description"] = ""
 
                     if "null" not in (
                         param_info.get("type") if isinstance(param_info.get("type"), list) else [param_info.get("type")]

{agno-1.8.1 → agno-1.8.2}/agno/tools/firecrawl.py

@@ -6,7 +6,8 @@ from agno.tools import Toolkit
 from agno.utils.log import logger
 
 try:
-    from firecrawl import FirecrawlApp, ScrapeOptions  # type: ignore[attr-defined]
+    from firecrawl import FirecrawlApp  # type: ignore[attr-defined]
+    from firecrawl.types import ScrapeOptions
 except ImportError:
     raise ImportError("`firecrawl-py` not installed. Please install using `pip install firecrawl-py`")
 
@@ -87,7 +88,7 @@ class FirecrawlTools(Toolkit):
         if self.formats:
             params["formats"] = self.formats
 
-        scrape_result = self.app.scrape_url(url, **params)
+        scrape_result = self.app.scrape(url, **params)
         return json.dumps(scrape_result.model_dump(), cls=CustomJSONEncoder)
 
     def crawl_website(self, url: str, limit: Optional[int] = None) -> str:
@@ -108,7 +109,7 @@ class FirecrawlTools(Toolkit):
 
         params["poll_interval"] = self.poll_interval
 
-        crawl_result = self.app.crawl_url(url, **params)
+        crawl_result = self.app.crawl(url, **params)
         return json.dumps(crawl_result.model_dump(), cls=CustomJSONEncoder)
 
     def map_website(self, url: str) -> str:
@@ -118,7 +119,7 @@ class FirecrawlTools(Toolkit):
             url (str): The URL to map.
 
         """
-        map_result = self.app.map_url(url)
+        map_result = self.app.map(url)
         return json.dumps(map_result.model_dump(), cls=CustomJSONEncoder)
 
     def search(self, query: str, limit: Optional[int] = None):

{agno-1.8.1 → agno-1.8.2}/agno/tools/linear.py

@@ -217,7 +217,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-1.8.1 → agno-1.8.2}/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-1.8.1 → agno-1.8.2}/agno/utils/models/claude.py

@@ -284,3 +284,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

{agno-1.8.1 → agno-1.8.2}/agno/workflow/v2/workflow.py

@@ -3273,7 +3273,8 @@ class Workflow:
         """Update executor with workflow_session_state"""
         if self.workflow_session_state is not None:
             # Update session_state with workflow_session_state
-            executor.workflow_session_state = self.workflow_session_state
+            if hasattr(executor, "workflow_session_state"):
+                executor.workflow_session_state = self.workflow_session_state
 
     def _save_run_to_storage(self, workflow_run_response: WorkflowRunResponse) -> None:
         """Helper method to save workflow run response to storage"""

{agno-1.8.1 → agno-1.8.2}/agno.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agno
-Version: 1.8.1
+Version: 1.8.2
 Summary: Agno: a lightweight library for building Multi-Agent Systems
 Author-email: Ashpreet Bedi <ashpreet@agno.com>
 License: Copyright (c) Agno, Inc.

{agno-1.8.1 → agno-1.8.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agno"
-version = "1.8.1"
+version = "1.8.2"
 description = "Agno: a lightweight library for building Multi-Agent Systems"
 requires-python = ">=3.7,<4"
 readme = "README.md"