agno 2.3.5__py3-none-any.whl → 2.3.7__py3-none-any.whl

agno/db/postgres/async_postgres.py

@@ -32,6 +32,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 try:
     from sqlalchemy import Index, String, Table, UniqueConstraint, func, update
     from sqlalchemy.dialects import postgresql
+    from sqlalchemy.exc import ProgrammingError
     from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
     from sqlalchemy.schema import Column, MetaData
     from sqlalchemy.sql.expression import select, text
@@ -254,47 +255,63 @@ class AsyncPostgresDb(AsyncBaseDb):
         if table_type == "sessions":
             if not hasattr(self, "session_table"):
                 self.session_table = await self._get_or_create_table(
-                    table_name=self.session_table_name, table_type="sessions"
+                    table_name=self.session_table_name,
+                    table_type="sessions",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.session_table
 
         if table_type == "memories":
             if not hasattr(self, "memory_table"):
                 self.memory_table = await self._get_or_create_table(
-                    table_name=self.memory_table_name, table_type="memories"
+                    table_name=self.memory_table_name,
+                    table_type="memories",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.memory_table
 
         if table_type == "metrics":
             if not hasattr(self, "metrics_table"):
                 self.metrics_table = await self._get_or_create_table(
-                    table_name=self.metrics_table_name, table_type="metrics"
+                    table_name=self.metrics_table_name,
+                    table_type="metrics",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.metrics_table
 
         if table_type == "evals":
             if not hasattr(self, "eval_table"):
-                self.eval_table = await self._get_or_create_table(table_name=self.eval_table_name, table_type="evals")
+                self.eval_table = await self._get_or_create_table(
+                    table_name=self.eval_table_name,
+                    table_type="evals",
+                    create_table_if_not_found=create_table_if_not_found,
+                )
             return self.eval_table
 
         if table_type == "knowledge":
             if not hasattr(self, "knowledge_table"):
                 self.knowledge_table = await self._get_or_create_table(
-                    table_name=self.knowledge_table_name, table_type="knowledge"
+                    table_name=self.knowledge_table_name,
+                    table_type="knowledge",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.knowledge_table
 
         if table_type == "culture":
             if not hasattr(self, "culture_table"):
                 self.culture_table = await self._get_or_create_table(
-                    table_name=self.culture_table_name, table_type="culture"
+                    table_name=self.culture_table_name,
+                    table_type="culture",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.culture_table
 
         if table_type == "versions":
             if not hasattr(self, "versions_table"):
                 self.versions_table = await self._get_or_create_table(
-                    table_name=self.versions_table_name, table_type="versions"
+                    table_name=self.versions_table_name,
+                    table_type="versions",
+                    create_table_if_not_found=create_table_if_not_found,
                 )
             return self.versions_table
 
@@ -897,10 +914,19 @@ class AsyncPostgresDb(AsyncBaseDb):
             table = await self._get_table(table_type="memories")
 
             async with self.async_session_factory() as sess, sess.begin():
-                stmt = select(func.json_array_elements_text(table.c.topics))
-                if user_id is not None:
-                    stmt = stmt.where(table.c.user_id == user_id)
-                result = await sess.execute(stmt)
+                try:
+                    stmt = select(func.jsonb_array_elements_text(table.c.topics))
+                    if user_id is not None:
+                        stmt = stmt.where(table.c.user_id == user_id)
+                    result = await sess.execute(stmt)
+                except ProgrammingError:
+                    # Retrying with json_array_elements_text. This works in older versions,
+                    # where the topics column was of type JSON instead of JSONB
+                    stmt = select(func.json_array_elements_text(table.c.topics))
+                    if user_id is not None:
+                        stmt = stmt.where(table.c.user_id == user_id)
+                    result = await sess.execute(stmt)
+
                 records = result.fetchall()
 
                 return list(set([record[0] for record in records]))

agno/db/postgres/postgres.py

@@ -33,6 +33,7 @@ try:
     from sqlalchemy import ForeignKey, Index, String, UniqueConstraint, func, select, update
     from sqlalchemy.dialects import postgresql
     from sqlalchemy.engine import Engine, create_engine
+    from sqlalchemy.exc import ProgrammingError
     from sqlalchemy.orm import scoped_session, sessionmaker
     from sqlalchemy.schema import Column, MetaData, Table
     from sqlalchemy.sql.expression import text
@@ -1082,9 +1083,14 @@ class PostgresDb(BaseDb):
                 return []
 
             with self.Session() as sess, sess.begin():
-                stmt = select(func.json_array_elements_text(table.c.topics))
-
-                result = sess.execute(stmt).fetchall()
+                try:
+                    stmt = select(func.jsonb_array_elements_text(table.c.topics))
+                    result = sess.execute(stmt).fetchall()
+                except ProgrammingError:
+                    # Retrying with json_array_elements_text. This works in older versions,
+                    # where the topics column was of type JSON instead of JSONB
+                    stmt = select(func.json_array_elements_text(table.c.topics))
+                    result = sess.execute(stmt).fetchall()
 
                 return list(set([record[0] for record in result]))
 

agno/db/sqlite/async_sqlite.py

@@ -1114,7 +1114,7 @@ class AsyncSqliteDb(AsyncBaseDb):
 
             async with self.async_session_factory() as sess, sess.begin():
                 # Select topics from all results
-                stmt = select(func.json_array_elements_text(table.c.topics)).select_from(table)
+                stmt = select(table.c.topics)
                 result = (await sess.execute(stmt)).fetchall()
 
                 return list(set([record[0] for record in result]))

agno/db/sqlite/sqlite.py

@@ -245,9 +245,9 @@ class SqliteDb(BaseDb):
             return table
 
         except Exception as e:
-            from traceback import format_exc
+            from traceback import print_exc
 
-            print(format_exc())
+            print_exc()
             log_error(f"Could not create table '{table_name}': {e}")
             raise e
 
@@ -1109,9 +1109,8 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess, sess.begin():
                 # Select topics from all results
-                stmt = select(func.json_array_elements_text(table.c.topics)).select_from(table)
+                stmt = select(table.c.topics)
                 result = sess.execute(stmt).fetchall()
-
                 return list(set([record[0] for record in result]))
 
         except Exception as e:

agno/db/utils.py

@@ -20,6 +20,8 @@ class CustomJSONEncoder(json.JSONEncoder):
             return obj.to_dict()
         elif isinstance(obj, Metrics):
             return obj.to_dict()
+        elif isinstance(obj, type):
+            return str(obj)
 
         return super().default(obj)
 

agno/eval/accuracy.py

@@ -359,10 +359,12 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 status = Status(f"Running evaluation {i + 1}...", spinner="dots", speed=1.0, refresh_per_second=10)
                 live_log.update(status)
 
+                agent_session_id = f"eval_{self.eval_id}_{i + 1}"
+
                 if self.agent is not None:
-                    output = self.agent.run(input=eval_input).content
+                    output = self.agent.run(input=eval_input, session_id=agent_session_id).content
                 elif self.team is not None:
-                    output = self.team.run(input=eval_input).content
+                    output = self.team.run(input=eval_input, session_id=agent_session_id).content
 
                 if not output:
                     logger.error(f"Failed to generate a valid answer on iteration {i + 1}: {output}")
@@ -500,11 +502,13 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 status = Status(f"Running evaluation {i + 1}...", spinner="dots", speed=1.0, refresh_per_second=10)
                 live_log.update(status)
 
+                agent_session_id = f"eval_{self.eval_id}_{i + 1}"
+
                 if self.agent is not None:
-                    response = await self.agent.arun(input=eval_input)
+                    response = await self.agent.arun(input=eval_input, session_id=agent_session_id)
                     output = response.content
                 elif self.team is not None:
-                    response = await self.team.arun(input=eval_input)  # type: ignore
+                    response = await self.team.arun(input=eval_input, session_id=agent_session_id)  # type: ignore
                     output = response.content
 
                 if not output:

agno/integrations/discord/client.py

@@ -14,7 +14,7 @@ try:
     import discord
 
 except (ImportError, ModuleNotFoundError):
-    print("`discord.py` not installed. Please install using `pip install discord.py`")
+    raise ImportError("`discord.py` not installed. Please install using `pip install discord.py`")
 
 
 class RequiresConfirmationView(discord.ui.View):

agno/models/base.py

@@ -30,6 +30,7 @@ from agno.models.message import Citations, Message
 from agno.models.metrics import Metrics
 from agno.models.response import ModelResponse, ModelResponseEvent, ToolExecution
 from agno.run.agent import CustomEvent, RunContentEvent, RunOutput, RunOutputEvent
+from agno.run.requirement import RunRequirement
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunOutput, TeamRunOutputEvent
 from agno.run.workflow import WorkflowRunOutputEvent
@@ -423,10 +424,23 @@ class Model(ABC):
                                 ]
                                 and function_call_response.tool_executions is not None
                             ):
+                                # Record the tool execution in the model response
                                 if model_response.tool_executions is None:
                                     model_response.tool_executions = []
                                 model_response.tool_executions.extend(function_call_response.tool_executions)
 
+                                # If the tool is currently paused (HITL flow), add the requirement to the run response
+                                if (
+                                    function_call_response.event == ModelResponseEvent.tool_call_paused.value
+                                    and run_response is not None
+                                ):
+                                    current_tool_execution = function_call_response.tool_executions[-1]
+                                    if run_response.requirements is None:
+                                        run_response.requirements = []
+                                    run_response.requirements.append(
+                                        RunRequirement(tool_execution=current_tool_execution)
+                                    )
+
                             elif function_call_response.event not in [
                                 ModelResponseEvent.tool_call_started.value,
                                 ModelResponseEvent.tool_call_completed.value,
@@ -615,6 +629,19 @@ class Model(ABC):
                                 if model_response.tool_executions is None:
                                     model_response.tool_executions = []
                                 model_response.tool_executions.extend(function_call_response.tool_executions)
+
+                                # If the tool is currently paused (HITL flow), add the requirement to the run response
+                                if (
+                                    function_call_response.event == ModelResponseEvent.tool_call_paused.value
+                                    and run_response is not None
+                                ):
+                                    current_tool_execution = function_call_response.tool_executions[-1]
+                                    if run_response.requirements is None:
+                                        run_response.requirements = []
+                                    run_response.requirements.append(
+                                        RunRequirement(tool_execution=current_tool_execution)
+                                    )
+
                             elif function_call_response.event not in [
                                 ModelResponseEvent.tool_call_started.value,
                                 ModelResponseEvent.tool_call_completed.value,
@@ -1706,7 +1733,7 @@ class Model(ABC):
 
             paused_tool_executions = []
 
-            # The function cannot be executed without user confirmation
+            # The function requires user confirmation (HITL)
             if fc.function.requires_confirmation:
                 paused_tool_executions.append(
                     ToolExecution(
@@ -1716,7 +1743,8 @@ class Model(ABC):
                         requires_confirmation=True,
                     )
                 )
-            # If the function requires user input, we yield a message to the user
+
+            # The function requires user input (HITL)
             if fc.function.requires_user_input:
                 user_input_schema = fc.function.user_input_schema
                 if fc.arguments and user_input_schema:
@@ -1734,7 +1762,8 @@ class Model(ABC):
                         user_input_schema=user_input_schema,
                     )
                 )
-            # If the function is from the user control flow tools, we handle it here
+
+            # If the function is from the user control flow (HITL) tools, we handle it here
             if fc.function.name == "get_user_input" and fc.arguments and fc.arguments.get("user_input_fields"):
                 user_input_schema = []
                 for input_field in fc.arguments.get("user_input_fields", []):
@@ -1760,7 +1789,8 @@ class Model(ABC):
                         user_input_schema=user_input_schema,
                     )
                 )
-            # If the function requires external execution, we yield a message to the user
+
+            # The function requires external execution (HITL)
             if fc.function.external_execution:
                 paused_tool_executions.append(
                     ToolExecution(

agno/models/cerebras/cerebras.py

@@ -512,14 +512,16 @@ class Cerebras(Model):
 
             # Extend the list if needed
             while len(tool_calls) <= index:
-                tool_calls.append({
-                    "id": None,
-                    "type": None,
-                    "function": {
-                        "name": "",
-                        "arguments": "",
-                    },
-                })
+                tool_calls.append(
+                    {
+                        "id": None,
+                        "type": None,
+                        "function": {
+                            "name": "",
+                            "arguments": "",
+                        },
+                    }
+                )
 
             tool_call_entry = tool_calls[index]
 
@@ -540,10 +542,7 @@ class Cerebras(Model):
                     tool_call_entry["function"]["arguments"] += func_delta["arguments"]
 
         # Filter out any incomplete tool calls (missing id or function name)
-        complete_tool_calls = [
-            tc for tc in tool_calls
-            if tc.get("id") and tc.get("function", {}).get("name")
-        ]
+        complete_tool_calls = [tc for tc in tool_calls if tc.get("id") and tc.get("function", {}).get("name")]
 
         return complete_tool_calls
 

agno/models/response.py

@@ -37,7 +37,7 @@ class ToolExecution:
 
     created_at: int = field(default_factory=lambda: int(time()))
 
-    # User control flow requirements
+    # User control flow (HITL) fields
     requires_confirmation: Optional[bool] = None
     confirmed: Optional[bool] = None
     confirmation_note: Optional[str] = None

agno/os/interfaces/whatsapp/security.py

@@ -3,6 +3,8 @@ import hmac
 import os
 from typing import Optional
 
+from agno.utils.log import log_warning
+
 
 def is_development_mode() -> bool:
     """Check if the application is running in development mode."""
@@ -36,7 +38,7 @@ def validate_webhook_signature(payload: bytes, signature_header: Optional[str])
     """
     # In development mode, we can bypass signature validation
     if is_development_mode():
-        print("WARNING: Bypassing signature validation in development mode")
+        log_warning("Bypassing signature validation in development mode")
         return True
 
     if not signature_header or not signature_header.startswith("sha256="):

agno/os/routers/evals/utils.py

@@ -36,7 +36,10 @@ async def run_accuracy_eval(
         model=default_model,
     )
 
-    result = accuracy_eval.run(print_results=False, print_summary=False)
+    if isinstance(db, AsyncBaseDb):
+        result = await accuracy_eval.arun(print_results=False, print_summary=False)
+    else:
+        result = accuracy_eval.run(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run accuracy evaluation")
 
@@ -86,7 +89,11 @@ async def run_performance_eval(
         model_id=model_id,
         model_provider=model_provider,
     )
-    result = performance_eval.run(print_results=False, print_summary=False)
+
+    if isinstance(db, AsyncBaseDb):
+        result = await performance_eval.arun(print_results=False, print_summary=False)
+    else:
+        result = performance_eval.run(print_results=False, print_summary=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run performance evaluation")
 
@@ -141,7 +148,10 @@ async def run_reliability_eval(
         model_id = team.model.id if team and team.model else None
         model_provider = team.model.provider if team and team.model else None
 
-    result = reliability_eval.run(print_results=False)
+    if isinstance(db, AsyncBaseDb):
+        result = await reliability_eval.arun(print_results=False)
+    else:
+        result = reliability_eval.run(print_results=False)
     if not result:
         raise HTTPException(status_code=500, detail="Failed to run reliability evaluation")
 

agno/os/schema.py

@@ -742,10 +742,11 @@ class SessionSchema(BaseModel):
     @classmethod
     def from_dict(cls, session: Dict[str, Any]) -> "SessionSchema":
         session_name = get_session_name(session)
+        session_data = session.get("session_data", {}) or {}
         return cls(
             session_id=session.get("session_id", ""),
             session_name=session_name,
-            session_state=session.get("session_data", {}).get("session_state", None),
+            session_state=session_data.get("session_state", None),
             created_at=datetime.fromtimestamp(session.get("created_at", 0), tz=timezone.utc)
             if session.get("created_at")
             else None,

agno/run/agent.py

@@ -11,6 +11,7 @@ from agno.models.metrics import Metrics
 from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
 from agno.run.base import BaseRunOutputEvent, MessageReferences, RunStatus
+from agno.run.requirement import RunRequirement
 from agno.utils.log import logger
 from agno.utils.media import (
     reconstruct_audio_list,
@@ -273,11 +274,18 @@ class RunCompletedEvent(BaseAgentRunEvent):
 class RunPausedEvent(BaseAgentRunEvent):
     event: str = RunEvent.run_paused.value
     tools: Optional[List[ToolExecution]] = None
+    requirements: Optional[List[RunRequirement]] = None
 
     @property
     def is_paused(self):
         return True
 
+    @property
+    def active_requirements(self) -> List[RunRequirement]:
+        if not self.requirements:
+            return []
+        return [requirement for requirement in self.requirements if not requirement.is_resolved()]
+
 
 @dataclass
 class RunContinuedEvent(BaseAgentRunEvent):
@@ -539,11 +547,20 @@ class RunOutput:
 
     status: RunStatus = RunStatus.running
 
+    # User control flow (HITL) requirements to continue a run when paused, in order of arrival
+    requirements: Optional[list[RunRequirement]] = None
+
     # === FOREIGN KEY RELATIONSHIPS ===
     # These fields establish relationships to parent workflow/step structures
     # and should be treated as foreign keys for data integrity
     workflow_step_id: Optional[str] = None  # FK: Points to StepOutput.step_id
 
+    @property
+    def active_requirements(self) -> list[RunRequirement]:
+        if not self.requirements:
+            return []
+        return [requirement for requirement in self.requirements if not requirement.is_resolved()]
+
     @property
     def is_paused(self):
         return self.status == RunStatus.paused

agno/run/requirement.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, List, Optional
+from uuid import uuid4
+
+from agno.models.response import ToolExecution, UserInputField
+
+if TYPE_CHECKING:
+    pass
+
+
+@dataclass
+class RunRequirement:
+    """Requirement to complete a paused run (used in HITL flows)"""
+
+    tool_execution: Optional[ToolExecution] = None
+    created_at: datetime = datetime.now(timezone.utc)
+
+    # User confirmation
+    confirmation: Optional[bool] = None
+    confirmation_note: Optional[str] = None
+
+    # User input
+    user_input_schema: Optional[List[UserInputField]] = None
+
+    # External execution
+    external_execution_result: Optional[str] = None
+
+    def __init__(self, tool_execution: ToolExecution):
+        self.id = str(uuid4())
+        self.tool_execution = tool_execution
+        self.user_input_schema = tool_execution.user_input_schema
+
+    @property
+    def needs_confirmation(self) -> bool:
+        if self.confirmation is not None:
+            return False
+        if not self.tool_execution:
+            return False
+        if self.tool_execution.confirmed is True:
+            return True
+
+        return self.tool_execution.requires_confirmation or False
+
+    @property
+    def needs_user_input(self) -> bool:
+        if not self.tool_execution:
+            return False
+        if self.tool_execution.answered is True:
+            return False
+        if self.user_input_schema and not all(field.value is not None for field in self.user_input_schema):
+            return True
+
+        return self.tool_execution.requires_user_input or False
+
+    @property
+    def needs_external_execution(self) -> bool:
+        if not self.tool_execution:
+            return False
+        if self.external_execution_result is not None:
+            return True
+
+        return self.tool_execution.external_execution_required or False
+
+    def confirm(self):
+        if not self.needs_confirmation:
+            raise ValueError("This requirement does not require confirmation")
+        self.confirmation = True
+        if self.tool_execution:
+            self.tool_execution.confirmed = True
+
+    def reject(self):
+        if not self.needs_confirmation:
+            raise ValueError("This requirement does not require confirmation")
+        self.confirmation = False
+        if self.tool_execution:
+            self.tool_execution.confirmed = False
+
+    def set_external_execution_result(self, result: str):
+        if not self.needs_external_execution:
+            raise ValueError("This requirement does not require external execution")
+        self.external_execution_result = result
+        if self.tool_execution:
+            self.tool_execution.result = result
+
+    def update_tool(self):
+        if not self.tool_execution:
+            return
+        if self.confirmation is True:
+            self.tool_execution.confirmed = True
+        elif self.confirmation is False:
+            self.tool_execution.confirmed = False
+        else:
+            raise ValueError("This requirement does not require confirmation or user input")
+
+    def is_resolved(self) -> bool:
+        """Return True if the requirement has been resolved"""
+        return not self.needs_confirmation and not self.needs_user_input and not self.needs_external_execution

agno/run/team.py

@@ -12,6 +12,7 @@ from agno.models.response import ToolExecution
 from agno.reasoning.step import ReasoningStep
 from agno.run.agent import RunEvent, RunOutput, RunOutputEvent, run_output_event_from_dict
 from agno.run.base import BaseRunOutputEvent, MessageReferences, RunStatus
+from agno.run.requirement import RunRequirement
 from agno.utils.log import log_error
 from agno.utils.media import (
     reconstruct_audio_list,
@@ -515,11 +516,20 @@ class TeamRunOutput:
 
     status: RunStatus = RunStatus.running
 
+    # User control flow (HITL) requirements to continue a run when paused, in order of arrival
+    requirements: Optional[list[RunRequirement]] = None
+
     # === FOREIGN KEY RELATIONSHIPS ===
     # These fields establish relationships to parent workflow/step structures
     # and should be treated as foreign keys for data integrity
     workflow_step_id: Optional[str] = None  # FK: Points to StepOutput.step_id
 
+    @property
+    def active_requirements(self) -> list[RunRequirement]:
+        if not self.requirements:
+            return []
+        return [requirement for requirement in self.requirements if not requirement.is_resolved()]
+
     @property
     def is_paused(self):
         return self.status == RunStatus.paused

agno/session/team.py

@@ -46,7 +46,6 @@ class TeamSession:
         session_dict = asdict(self)
 
         session_dict["runs"] = [run.to_dict() for run in self.runs] if self.runs else None
-        print(session_dict["runs"])
         session_dict["summary"] = self.summary.to_dict() if self.summary else None
 
         return session_dict

agno/table.py

@@ -7,4 +7,4 @@ conn = sqlite3.connect(db_path)
 cur = conn.cursor()
 cur.execute(f"DROP TABLE IF EXISTS {table_name}")
 conn.commit()
-conn.close()
+conn.close()