agno 1.7.5__py3-none-any.whl → 1.7.6__py3-none-any.whl

agno/agent/agent.py

@@ -4369,7 +4369,6 @@ class Agent:
             # Format the system message with the session state variables
             if self.add_state_in_messages:
                 sys_message_content = self.format_message_with_state_variables(sys_message_content)
-                print("HELLO", sys_message_content)
 
             # Add the JSON output prompt if response_model is provided and the model does not support native structured outputs or JSON schema outputs
             # or if use_json_mode is True

agno/app/agui/async_router.py

@@ -16,7 +16,7 @@ from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
 from agno.agent.agent import Agent
-from agno.app.agui.utils import async_stream_agno_response_as_agui_events, get_last_user_message
+from agno.app.agui.utils import async_stream_agno_response_as_agui_events, convert_agui_messages_to_agno_messages
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
@@ -28,12 +28,12 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
 
     try:
         # Preparing the input for the Agent and emitting the run started event
-        message = get_last_user_message(run_input.messages)
+        messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Request streaming response from agent
         response_stream = await agent.arun(
-            message=message,
+            messages=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -56,12 +56,12 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
     run_id = input.run_id or str(uuid.uuid4())
     try:
         # Extract the last user message for team execution
-        user_message = get_last_user_message(input.messages) if input.messages else ""
+        messages = convert_agui_messages_to_agno_messages(input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
         # Request streaming response from team
         response_stream = await team.arun(
-            message=user_message,
+            message=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,

agno/app/agui/sync_router.py

@@ -16,7 +16,7 @@ from fastapi import APIRouter
 from fastapi.responses import StreamingResponse
 
 from agno.agent.agent import Agent
-from agno.app.agui.utils import get_last_user_message, stream_agno_response_as_agui_events
+from agno.app.agui.utils import convert_agui_messages_to_agno_messages, stream_agno_response_as_agui_events
 from agno.team.team import Team
 
 logger = logging.getLogger(__name__)
@@ -28,12 +28,12 @@ def run_agent(agent: Agent, run_input: RunAgentInput) -> Iterator[BaseEvent]:
 
     try:
         # Preparing the input for the Agent and emitting the run started event
-        message = get_last_user_message(run_input.messages)
+        messages = convert_agui_messages_to_agno_messages(run_input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=run_input.thread_id, run_id=run_id)
 
         # Request streaming response from agent
         response_stream = agent.run(
-            message=message,
+            messages=messages,
             session_id=run_input.thread_id,
             stream=True,
             stream_intermediate_steps=True,
@@ -56,12 +56,12 @@ def run_team(team: Team, input: RunAgentInput) -> Iterator[BaseEvent]:
     run_id = input.run_id or str(uuid.uuid4())
     try:
         # Extract the last user message for team execution
-        user_message = get_last_user_message(input.messages) if input.messages else ""
+        messages = convert_agui_messages_to_agno_messages(input.messages or [])
         yield RunStartedEvent(type=EventType.RUN_STARTED, thread_id=input.thread_id, run_id=run_id)
 
         # Request streaming response from team
         response_stream = team.run(
-            message=user_message,
+            message=messages,
             session_id=input.thread_id,
             stream=True,
             stream_intermediate_steps=True,

agno/app/agui/utils.py

@@ -1,5 +1,6 @@
 """Logic used by the AG-UI router."""
 
+import json
 import uuid
 from collections import deque
 from collections.abc import Iterator
@@ -17,11 +18,13 @@ from ag_ui.core import (
     TextMessageStartEvent,
     ToolCallArgsEvent,
     ToolCallEndEvent,
+    ToolCallResultEvent,
     ToolCallStartEvent,
 )
 from ag_ui.core.types import Message as AGUIMessage
 
-from agno.run.response import RunEvent, RunResponseContentEvent, RunResponseEvent
+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
 
@@ -64,13 +67,26 @@ class EventBuffer:
         return False
 
 
-def get_last_user_message(messages: Optional[List[AGUIMessage]]) -> str:
-    if not messages:
-        return ""
-    for msg in reversed(messages):
-        if msg.role == "user" and msg.content:
-            return msg.content
-    return ""
+def convert_agui_messages_to_agno_messages(messages: List[AGUIMessage]) -> List[Message]:
+    """Convert AG-UI messages to Agno messages."""
+    result = []
+    for msg in messages:
+        if msg.role == "tool":
+            result.append(Message(role="tool", tool_call_id=msg.tool_call_id, content=msg.content))
+        elif msg.role == "assistant":
+            tool_calls = None
+            if msg.tool_calls:
+                tool_calls = [call.model_dump() for call in msg.tool_calls]
+            result.append(
+                Message(
+                    role="assistant",
+                    content=msg.content,
+                    tool_calls=tool_calls,
+                )
+            )
+        elif msg.role == "user":
+            result.append(Message(role="user", content=msg.content))
+    return result
 
 
 def extract_team_response_chunk_content(response: TeamRunResponseContentEvent) -> str:
@@ -159,7 +175,7 @@ def _create_events_from_chunk(
             args_event = ToolCallArgsEvent(
                 type=EventType.TOOL_CALL_ARGS,
                 tool_call_id=tool_call.tool_call_id,  # type: ignore
-                delta=str(tool_call.tool_args),
+                delta=json.dumps(tool_call.tool_args),
             )
             events_to_emit.append(args_event)
 
@@ -174,6 +190,16 @@ def _create_events_from_chunk(
                 )
                 events_to_emit.append(end_event)
 
+                if tool_call.result is not None:
+                    result_event = ToolCallResultEvent(
+                        type=EventType.TOOL_CALL_RESULT,
+                        tool_call_id=tool_call.tool_call_id,  # type: ignore
+                        content=str(tool_call.result),
+                        role="tool",
+                        message_id=str(uuid.uuid4()),
+                    )
+                    events_to_emit.append(result_event)
+
     # Handle reasoning
     elif chunk.event == RunEvent.reasoning_started:
         step_event = StepStartedEvent(type=EventType.STEP_STARTED, step_name="reasoning")
@@ -186,7 +212,12 @@ def _create_events_from_chunk(
 
 
 def _create_completion_events(
-    event_buffer: EventBuffer, message_started: bool, message_id: str, thread_id: str, run_id: str
+    chunk: Union[RunResponseEvent, TeamRunResponseEvent],
+    event_buffer: EventBuffer,
+    message_started: bool,
+    message_id: str,
+    thread_id: str,
+    run_id: str,
 ) -> List[BaseEvent]:
     """Create events for run completion."""
     events_to_emit = []
@@ -205,6 +236,33 @@ def _create_completion_events(
         end_message_event = TextMessageEndEvent(type=EventType.TEXT_MESSAGE_END, message_id=message_id)
         events_to_emit.append(end_message_event)
 
+    # emit frontend tool calls, i.e. external_execution=True
+    if isinstance(chunk, RunResponsePausedEvent) and chunk.tools is not None:
+        for tool in chunk.tools:
+            if tool.tool_call_id is None or tool.tool_name is None:
+                continue
+
+            start_event = ToolCallStartEvent(
+                type=EventType.TOOL_CALL_START,
+                tool_call_id=tool.tool_call_id,
+                tool_call_name=tool.tool_name,
+                parent_message_id=message_id,
+            )
+            events_to_emit.append(start_event)
+
+            args_event = ToolCallArgsEvent(
+                type=EventType.TOOL_CALL_ARGS,
+                tool_call_id=tool.tool_call_id,
+                delta=json.dumps(tool.tool_args),
+            )
+            events_to_emit.append(args_event)
+
+            end_event = ToolCallEndEvent(
+                type=EventType.TOOL_CALL_END,
+                tool_call_id=tool.tool_call_id,
+            )
+            events_to_emit.append(end_event)
+
     run_finished_event = RunFinishedEvent(type=EventType.RUN_FINISHED, thread_id=thread_id, run_id=run_id)
     events_to_emit.append(run_finished_event)
 
@@ -271,8 +329,14 @@ def stream_agno_response_as_agui_events(
 
     for chunk in response_stream:
         # Handle the lifecycle end event
-        if chunk.event == RunEvent.run_completed or chunk.event == TeamRunEvent.run_completed:
-            completion_events = _create_completion_events(event_buffer, message_started, message_id, thread_id, run_id)
+        if (
+            chunk.event == RunEvent.run_completed
+            or chunk.event == TeamRunEvent.run_completed
+            or chunk.event == RunEvent.run_paused
+        ):
+            completion_events = _create_completion_events(
+                chunk, event_buffer, message_started, message_id, thread_id, run_id
+            )
             for event in completion_events:
                 events_to_emit = _emit_event_logic(event_buffer=event_buffer, event=event)
                 for emit_event in events_to_emit:
@@ -302,8 +366,14 @@ async def async_stream_agno_response_as_agui_events(
 
     async for chunk in response_stream:
         # Handle the lifecycle end event
-        if chunk.event == RunEvent.run_completed or chunk.event == TeamRunEvent.run_completed:
-            completion_events = _create_completion_events(event_buffer, message_started, message_id, thread_id, run_id)
+        if (
+            chunk.event == RunEvent.run_completed
+            or chunk.event == TeamRunEvent.run_completed
+            or chunk.event == RunEvent.run_paused
+        ):
+            completion_events = _create_completion_events(
+                chunk, event_buffer, message_started, message_id, thread_id, run_id
+            )
             for event in completion_events:
                 events_to_emit = _emit_event_logic(event_buffer=event_buffer, event=event)
                 for emit_event in events_to_emit:

agno/document/chunking/row.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from agno.document.base import Document
+from agno.document.chunking.strategy import ChunkingStrategy
+
+
+class RowChunking(ChunkingStrategy):
+    def __init__(self, skip_header: bool = False, clean_rows: bool = True):
+        self.skip_header = skip_header
+        self.clean_rows = clean_rows
+
+    def chunk(self, document: Document) -> List[Document]:
+        if not document or not document.content:
+            return []
+
+        if not isinstance(document.content, str):
+            raise ValueError("Document content must be a string")
+
+        rows = document.content.splitlines()
+
+        if self.skip_header and rows:
+            rows = rows[1:]
+            start_index = 2
+        else:
+            start_index = 1
+
+        chunks = []
+        for i, row in enumerate(rows):
+            if self.clean_rows:
+                chunk_content = " ".join(row.split())  # Normalize internal whitespace
+            else:
+                chunk_content = row.strip()
+
+            if chunk_content:  # Skip empty rows
+                meta_data = document.meta_data.copy()
+                meta_data["row_number"] = start_index + i  # Preserve logical row numbering
+                chunk_id = f"{document.id}_row_{start_index + i}" if document.id else None
+                chunks.append(Document(id=chunk_id, name=document.name, meta_data=meta_data, content=chunk_content))
+        return chunks

agno/document/reader/base.py

@@ -16,13 +16,6 @@ class Reader:
     separators: List[str] = field(default_factory=lambda: ["\n", "\n\n", "\r", "\r\n", "\n\r", "\t", " ", "  "])
     chunking_strategy: Optional[ChunkingStrategy] = None
 
-    def __init__(
-        self, chunk: bool = True, chunk_size: int = 5000, chunking_strategy: Optional[ChunkingStrategy] = None
-    ) -> None:
-        self.chunk = chunk
-        self.chunk_size = chunk_size
-        self.chunking_strategy = chunking_strategy
-
     def read(self, obj: Any) -> List[Document]:
         raise NotImplementedError
 

agno/embedder/jina.py

@@ -0,0 +1,73 @@
+from dataclasses import dataclass
+from os import getenv
+from typing import Any, Dict, List, Optional, Tuple
+
+from typing_extensions import Literal
+
+from agno.embedder.base import Embedder
+from agno.utils.log import logger
+
+try:
+    import requests
+except ImportError:
+    raise ImportError("requests not installed, use pip install requests")
+
+
+@dataclass
+class JinaEmbedder(Embedder):
+    id: str = "jina-embeddings-v3"
+    dimensions: int = 1024
+    embedding_type: Literal["float", "base64", "int8"] = "float"
+    late_chunking: bool = False
+    user: Optional[str] = None
+    api_key: Optional[str] = getenv("JINA_API_KEY")
+    base_url: str = "https://api.jina.ai/v1/embeddings"
+    headers: Optional[Dict[str, str]] = None
+    request_params: Optional[Dict[str, Any]] = None
+    timeout: Optional[float] = None
+
+    def _get_headers(self) -> Dict[str, str]:
+        if not self.api_key:
+            raise ValueError(
+                "API key is required for Jina embedder. Set JINA_API_KEY environment variable or pass api_key parameter."
+            )
+
+        headers = {"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"}
+        if self.headers:
+            headers.update(self.headers)
+        return headers
+
+    def _response(self, text: str) -> Dict[str, Any]:
+        data = {
+            "model": self.id,
+            "late_chunking": self.late_chunking,
+            "dimensions": self.dimensions,
+            "embedding_type": self.embedding_type,
+            "input": [text],  # Jina API expects a list
+        }
+        if self.user is not None:
+            data["user"] = self.user
+        if self.request_params:
+            data.update(self.request_params)
+
+        response = requests.post(self.base_url, headers=self._get_headers(), json=data, timeout=self.timeout)
+        response.raise_for_status()
+        return response.json()
+
+    def get_embedding(self, text: str) -> List[float]:
+        try:
+            result = self._response(text)
+            return result["data"][0]["embedding"]
+        except Exception as e:
+            logger.warning(f"Failed to get embedding: {e}")
+            return []
+
+    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
+        try:
+            result = self._response(text)
+            embedding = result["data"][0]["embedding"]
+            usage = result.get("usage")
+            return embedding, usage
+        except Exception as e:
+            logger.warning(f"Failed to get embedding and usage: {e}")
+            return [], None

agno/memory/agent.py

@@ -273,7 +273,7 @@ class AgentMemory(BaseModel):
 
         self.classifier.existing_memories = self.memories
         classifier_response = self.classifier.run(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 
@@ -286,7 +286,7 @@ class AgentMemory(BaseModel):
 
         self.classifier.existing_memories = self.memories
         classifier_response = await self.classifier.arun(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 

agno/memory/team.py

@@ -313,7 +313,7 @@ class TeamMemory:
 
         self.classifier.existing_memories = self.memories
         classifier_response = self.classifier.run(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False
 
@@ -326,7 +326,7 @@ class TeamMemory:
 
         self.classifier.existing_memories = self.memories
         classifier_response = await self.classifier.arun(input)
-        if classifier_response == "yes":
+        if classifier_response and classifier_response.lower() == "yes":
             return True
         return False