agno 2.4.0__py3-none-any.whl → 2.4.2__py3-none-any.whl

agno/db/sqlite/async_sqlite.py

@@ -263,95 +263,86 @@ class AsyncSqliteDb(AsyncBaseDb):
 
     async def _get_table(self, table_type: str, create_table_if_not_found: Optional[bool] = False) -> Optional[Table]:
         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=table_type,
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.session_table = await self._get_or_create_table(
+                table_name=self.session_table_name,
+                table_type=table_type,
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.session_table
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.memory_table = await self._get_or_create_table(
+                table_name=self.memory_table_name,
+                table_type="memories",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.memory_table
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.metrics_table = await self._get_or_create_table(
+                table_name=self.metrics_table_name,
+                table_type="metrics",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.metrics_table
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            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
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.knowledge_table = await self._get_or_create_table(
+                table_name=self.knowledge_table_name,
+                table_type="knowledge",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.knowledge_table
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.culture_table = await self._get_or_create_table(
+                table_name=self.culture_table_name,
+                table_type="culture",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.culture_table
 
         elif 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",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.versions_table = await self._get_or_create_table(
+                table_name=self.versions_table_name,
+                table_type="versions",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.versions_table
 
         elif table_type == "traces":
-            if not hasattr(self, "traces_table"):
-                self.traces_table = await self._get_or_create_table(
-                    table_name=self.trace_table_name,
-                    table_type="traces",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.traces_table = await self._get_or_create_table(
+                table_name=self.trace_table_name,
+                table_type="traces",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.traces_table
 
         elif table_type == "spans":
-            if not hasattr(self, "spans_table"):
-                # Ensure traces table exists first (spans has FK to traces)
+            # Ensure traces table exists first (spans has FK to traces)
+            if create_table_if_not_found:
                 await self._get_table(table_type="traces", create_table_if_not_found=True)
-                self.spans_table = await self._get_or_create_table(
-                    table_name=self.span_table_name,
-                    table_type="spans",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.spans_table = await self._get_or_create_table(
+                table_name=self.span_table_name,
+                table_type="spans",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.spans_table
 
         elif table_type == "learnings":
-            if not hasattr(self, "learnings_table"):
-                self.learnings_table = await self._get_or_create_table(
-                    table_name=self.learnings_table_name,
-                    table_type="learnings",
-                    create_table_if_not_found=create_table_if_not_found,
-                )
+            self.learnings_table = await self._get_or_create_table(
+                table_name=self.learnings_table_name,
+                table_type="learnings",
+                create_table_if_not_found=create_table_if_not_found,
+            )
             return self.learnings_table
 
         else:

agno/db/sqlite/sqlite.py

@@ -3475,7 +3475,7 @@ class SqliteDb(BaseDb):
 
         Args:
             component_id: The component ID.
-            version: Specific version number. If None, uses current.
+            version: Specific version number. If None, uses current or latest draft.
             label: Config label to lookup. Ignored if version is provided.
 
         Returns:
@@ -3490,16 +3490,22 @@ class SqliteDb(BaseDb):
 
             with self.Session() as sess:
                 # Always verify component exists and is not deleted
-                component = sess.execute(
-                    select(components_table.c.current_version).where(
-                        components_table.c.component_id == component_id,
-                        components_table.c.deleted_at.is_(None),
+                component_row = (
+                    sess.execute(
+                        select(components_table.c.current_version, components_table.c.component_id).where(
+                            components_table.c.component_id == component_id,
+                            components_table.c.deleted_at.is_(None),
+                        )
                     )
-                ).fetchone()
+                    .mappings()
+                    .one_or_none()
+                )
 
-                if component is None:
+                if component_row is None:
                     return None
 
+                current_version = component_row["current_version"]
+
                 if version is not None:
                     stmt = select(configs_table).where(
                         configs_table.c.component_id == component_id,
@@ -3510,12 +3516,19 @@ class SqliteDb(BaseDb):
                         configs_table.c.component_id == component_id,
                         configs_table.c.label == label,
                     )
-                else:
-                    if component.current_version is None:
-                        return None
+                elif current_version is not None:
+                    # Use the current published version
                     stmt = select(configs_table).where(
                         configs_table.c.component_id == component_id,
-                        configs_table.c.version == component.current_version,
+                        configs_table.c.version == current_version,
+                    )
+                else:
+                    # No current_version set (draft only) - get the latest version
+                    stmt = (
+                        select(configs_table)
+                        .where(configs_table.c.component_id == component_id)
+                        .order_by(configs_table.c.version.desc())
+                        .limit(1)
                     )
 
                 result = sess.execute(stmt).fetchone()

agno/integrations/discord/client.py

@@ -7,7 +7,7 @@ import requests
 from agno.agent.agent import Agent, RunOutput
 from agno.media import Audio, File, Image, Video
 from agno.team.team import Team, TeamRunOutput
-from agno.utils.log import log_info, log_warning
+from agno.utils.log import log_error, log_info, log_warning
 from agno.utils.message import get_text_from_message
 
 try:
@@ -126,6 +126,11 @@ class DiscordClient:
                         audio=[Audio(url=message_audio)] if message_audio else None,
                         files=[File(content=message_file)] if message_file else None,
                     )
+                    if agent_response.status == "ERROR":
+                        log_error(agent_response.content)
+                        agent_response.content = (
+                            "Sorry, there was an error processing your message. Please try again later."
+                        )
                     await self._handle_response_in_thread(agent_response, thread)
                 elif self.team:
                     self.team.additional_context = additional_context
@@ -138,6 +143,12 @@ class DiscordClient:
                         audio=[Audio(url=message_audio)] if message_audio else None,
                         files=[File(content=message_file)] if message_file else None,
                     )
+                    if team_response.status == "ERROR":
+                        log_error(team_response.content)
+                        team_response.content = (
+                            "Sorry, there was an error processing your message. Please try again later."
+                        )
+
                     await self._handle_response_in_thread(team_response, thread)
 
     async def handle_hitl(