agno 2.3.9__py3-none-any.whl → 2.3.11__py3-none-any.whl

agno/db/sqlite/async_sqlite.py

@@ -31,7 +31,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Column, MetaData, String, Table, func, select, text, update
+    from sqlalchemy import Column, MetaData, String, Table, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker, create_async_engine
     from sqlalchemy.schema import Index, UniqueConstraint
@@ -1825,7 +1825,7 @@ class AsyncSqliteDb(AsyncBaseDb):
             Optional[KnowledgeRow]: The upserted knowledge row, or None if the operation fails.
         """
         try:
-            table = await self._get_table(table_type="knowledge")
+            table = await self._get_table(table_type="knowledge", create_table_if_not_found=True)
             if table is None:
                 return None
 
@@ -2196,10 +2196,7 @@ class AsyncSqliteDb(AsyncBaseDb):
                 await sess.execute(table.delete())
 
         except Exception as e:
-            from agno.utils.log import log_warning
-
-            log_warning(f"Exception deleting all cultural artifacts: {e}")
-            raise e
+            log_error(f"Exception deleting all cultural artifacts: {e}")
 
     async def delete_cultural_knowledge(self, id: str) -> None:
         """Delete a cultural artifact from the database.
@@ -2227,7 +2224,6 @@ class AsyncSqliteDb(AsyncBaseDb):
 
         except Exception as e:
             log_error(f"Error deleting cultural artifact: {e}")
-            raise e
 
     async def get_cultural_knowledge(
         self, id: str, deserialize: Optional[bool] = True
@@ -2263,7 +2259,7 @@ class AsyncSqliteDb(AsyncBaseDb):
 
         except Exception as e:
             log_error(f"Exception reading from cultural artifacts table: {e}")
-            raise e
+            return None
 
     async def get_all_cultural_knowledge(
         self,
@@ -2337,7 +2333,7 @@ class AsyncSqliteDb(AsyncBaseDb):
 
         except Exception as e:
             log_error(f"Error reading from cultural artifacts table: {e}")
-            raise e
+            return [] if deserialize else ([], 0)
 
     async def upsert_cultural_knowledge(
         self, cultural_knowledge: CulturalKnowledge, deserialize: Optional[bool] = True
@@ -2357,7 +2353,7 @@ class AsyncSqliteDb(AsyncBaseDb):
             Exception: If an error occurs during upsert.
         """
         try:
-            table = await self._get_table(table_type="culture")
+            table = await self._get_table(table_type="culture", create_table_if_not_found=True)
             if table is None:
                 return None
 
@@ -2440,86 +2436,113 @@ class AsyncSqliteDb(AsyncBaseDb):
             # Fallback if spans table doesn't exist
             return select(table, literal(0).label("total_spans"), literal(0).label("error_count"))
 
-    async def create_trace(self, trace: "Trace") -> None:
-        """Create a single trace record in the database.
+    def _get_trace_component_level_expr(self, workflow_id_col, team_id_col, agent_id_col, name_col):
+        """Build a SQL CASE expression that returns the component level for a trace.
+
+        Component levels (higher = more important):
+            - 3: Workflow root (.run or .arun with workflow_id)
+            - 2: Team root (.run or .arun with team_id)
+            - 1: Agent root (.run or .arun with agent_id)
+            - 0: Child span (not a root)
+
+        Args:
+            workflow_id_col: SQL column/expression for workflow_id
+            team_id_col: SQL column/expression for team_id
+            agent_id_col: SQL column/expression for agent_id
+            name_col: SQL column/expression for name
+
+        Returns:
+            SQLAlchemy CASE expression returning the component level as an integer.
+        """
+        from sqlalchemy import and_, case, or_
+
+        is_root_name = or_(name_col.contains(".run"), name_col.contains(".arun"))
+
+        return case(
+            # Workflow root (level 3)
+            (and_(workflow_id_col.isnot(None), is_root_name), 3),
+            # Team root (level 2)
+            (and_(team_id_col.isnot(None), is_root_name), 2),
+            # Agent root (level 1)
+            (and_(agent_id_col.isnot(None), is_root_name), 1),
+            # Child span or unknown (level 0)
+            else_=0,
+        )
+
+    async def upsert_trace(self, trace: "Trace") -> None:
+        """Create or update a single trace record in the database.
+
+        Uses INSERT ... ON CONFLICT DO UPDATE (upsert) to handle concurrent inserts
+        atomically and avoid race conditions.
 
         Args:
             trace: The Trace object to store (one per trace_id).
         """
+        from sqlalchemy import case
+
         try:
             table = await self._get_table(table_type="traces", create_table_if_not_found=True)
             if table is None:
                 return
 
-            async with self.async_session_factory() as sess, sess.begin():
-                # Check if trace exists
-                result = await sess.execute(select(table).where(table.c.trace_id == trace.trace_id))
-                existing = result.fetchone()
-
-                if existing:
-                    # workflow (level 3) > team (level 2) > agent (level 1) > child/unknown (level 0)
-
-                    def get_component_level(workflow_id, team_id, agent_id, name):
-                        # Check if name indicates a root span
-                        is_root_name = ".run" in name or ".arun" in name
-
-                        if not is_root_name:
-                            return 0  # Child span (not a root)
-                        elif workflow_id:
-                            return 3  # Workflow root
-                        elif team_id:
-                            return 2  # Team root
-                        elif agent_id:
-                            return 1  # Agent root
-                        else:
-                            return 0  # Unknown
-
-                    existing_level = get_component_level(
-                        existing.workflow_id, existing.team_id, existing.agent_id, existing.name
-                    )
-                    new_level = get_component_level(trace.workflow_id, trace.team_id, trace.agent_id, trace.name)
+            trace_dict = trace.to_dict()
+            trace_dict.pop("total_spans", None)
+            trace_dict.pop("error_count", None)
 
-                    # Only update name if new trace is from a higher or equal level
-                    should_update_name = new_level > existing_level
-
-                    # Parse existing start_time to calculate correct duration
-                    existing_start_time_str = existing.start_time
-                    if isinstance(existing_start_time_str, str):
-                        existing_start_time = datetime.fromisoformat(existing_start_time_str.replace("Z", "+00:00"))
-                    else:
-                        existing_start_time = trace.start_time
-
-                    recalculated_duration_ms = int((trace.end_time - existing_start_time).total_seconds() * 1000)
-
-                    update_values = {
-                        "end_time": trace.end_time.isoformat(),
-                        "duration_ms": recalculated_duration_ms,
-                        "status": trace.status,
-                        "name": trace.name if should_update_name else existing.name,
-                    }
+            async with self.async_session_factory() as sess, sess.begin():
+                # Use upsert to handle concurrent inserts atomically
+                # On conflict, update fields while preserving existing non-null context values
+                # and keeping the earliest start_time
+                insert_stmt = sqlite.insert(table).values(trace_dict)
+
+                # Build component level expressions for comparing trace priority
+                new_level = self._get_trace_component_level_expr(
+                    insert_stmt.excluded.workflow_id,
+                    insert_stmt.excluded.team_id,
+                    insert_stmt.excluded.agent_id,
+                    insert_stmt.excluded.name,
+                )
+                existing_level = self._get_trace_component_level_expr(
+                    table.c.workflow_id,
+                    table.c.team_id,
+                    table.c.agent_id,
+                    table.c.name,
+                )
 
-                    # Update context fields ONLY if new value is not None (preserve non-null values)
-                    if trace.run_id is not None:
-                        update_values["run_id"] = trace.run_id
-                    if trace.session_id is not None:
-                        update_values["session_id"] = trace.session_id
-                    if trace.user_id is not None:
-                        update_values["user_id"] = trace.user_id
-                    if trace.agent_id is not None:
-                        update_values["agent_id"] = trace.agent_id
-                    if trace.team_id is not None:
-                        update_values["team_id"] = trace.team_id
-                    if trace.workflow_id is not None:
-                        update_values["workflow_id"] = trace.workflow_id
-
-                    stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
-                    await sess.execute(stmt)
-                else:
-                    trace_dict = trace.to_dict()
-                    trace_dict.pop("total_spans", None)
-                    trace_dict.pop("error_count", None)
-                    stmt = sqlite.insert(table).values(trace_dict)
-                    await sess.execute(stmt)
+                # Build the ON CONFLICT DO UPDATE clause
+                # Use MIN for start_time, MAX for end_time to capture full trace duration
+                # SQLite stores timestamps as ISO strings, so string comparison works for ISO format
+                # Duration is calculated as: (MAX(end_time) - MIN(start_time)) in milliseconds
+                # SQLite doesn't have epoch extraction, so we calculate duration using julianday
+                upsert_stmt = insert_stmt.on_conflict_do_update(
+                    index_elements=["trace_id"],
+                    set_={
+                        "end_time": func.max(table.c.end_time, insert_stmt.excluded.end_time),
+                        "start_time": func.min(table.c.start_time, insert_stmt.excluded.start_time),
+                        # Calculate duration in milliseconds using julianday (SQLite-specific)
+                        # julianday returns days, so multiply by 86400000 to get milliseconds
+                        "duration_ms": (
+                            func.julianday(func.max(table.c.end_time, insert_stmt.excluded.end_time))
+                            - func.julianday(func.min(table.c.start_time, insert_stmt.excluded.start_time))
+                        )
+                        * 86400000,
+                        "status": insert_stmt.excluded.status,
+                        # Update name only if new trace is from a higher-level component
+                        # Priority: workflow (3) > team (2) > agent (1) > child spans (0)
+                        "name": case(
+                            (new_level > existing_level, insert_stmt.excluded.name),
+                            else_=table.c.name,
+                        ),
+                        # Preserve existing non-null context values using COALESCE
+                        "run_id": func.coalesce(insert_stmt.excluded.run_id, table.c.run_id),
+                        "session_id": func.coalesce(insert_stmt.excluded.session_id, table.c.session_id),
+                        "user_id": func.coalesce(insert_stmt.excluded.user_id, table.c.user_id),
+                        "agent_id": func.coalesce(insert_stmt.excluded.agent_id, table.c.agent_id),
+                        "team_id": func.coalesce(insert_stmt.excluded.team_id, table.c.team_id),
+                        "workflow_id": func.coalesce(insert_stmt.excluded.workflow_id, table.c.workflow_id),
+                    },
+                )
+                await sess.execute(upsert_stmt)
 
         except Exception as e:
             log_error(f"Error creating trace: {e}")

agno/db/sqlite/sqlite.py

@@ -31,7 +31,7 @@ from agno.utils.log import log_debug, log_error, log_info, log_warning
 from agno.utils.string import generate_id
 
 try:
-    from sqlalchemy import Column, MetaData, String, Table, func, select, text, update
+    from sqlalchemy import Column, MetaData, String, Table, func, select, text
     from sqlalchemy.dialects import sqlite
     from sqlalchemy.engine import Engine, create_engine
     from sqlalchemy.orm import scoped_session, sessionmaker
@@ -2145,85 +2145,113 @@ class SqliteDb(BaseDb):
             # Fallback if spans table doesn't exist
             return select(table, literal(0).label("total_spans"), literal(0).label("error_count"))
 
-    def create_trace(self, trace: "Trace") -> None:
-        """Create a single trace record in the database.
+    def _get_trace_component_level_expr(self, workflow_id_col, team_id_col, agent_id_col, name_col):
+        """Build a SQL CASE expression that returns the component level for a trace.
+
+        Component levels (higher = more important):
+            - 3: Workflow root (.run or .arun with workflow_id)
+            - 2: Team root (.run or .arun with team_id)
+            - 1: Agent root (.run or .arun with agent_id)
+            - 0: Child span (not a root)
+
+        Args:
+            workflow_id_col: SQL column/expression for workflow_id
+            team_id_col: SQL column/expression for team_id
+            agent_id_col: SQL column/expression for agent_id
+            name_col: SQL column/expression for name
+
+        Returns:
+            SQLAlchemy CASE expression returning the component level as an integer.
+        """
+        from sqlalchemy import and_, case, or_
+
+        is_root_name = or_(name_col.contains(".run"), name_col.contains(".arun"))
+
+        return case(
+            # Workflow root (level 3)
+            (and_(workflow_id_col.isnot(None), is_root_name), 3),
+            # Team root (level 2)
+            (and_(team_id_col.isnot(None), is_root_name), 2),
+            # Agent root (level 1)
+            (and_(agent_id_col.isnot(None), is_root_name), 1),
+            # Child span or unknown (level 0)
+            else_=0,
+        )
+
+    def upsert_trace(self, trace: "Trace") -> None:
+        """Create or update a single trace record in the database.
+
+        Uses INSERT ... ON CONFLICT DO UPDATE (upsert) to handle concurrent inserts
+        atomically and avoid race conditions.
 
         Args:
             trace: The Trace object to store (one per trace_id).
         """
+        from sqlalchemy import case
+
         try:
             table = self._get_table(table_type="traces", create_table_if_not_found=True)
             if table is None:
                 return
 
-            with self.Session() as sess, sess.begin():
-                # Check if trace exists
-                existing = sess.execute(table.select().where(table.c.trace_id == trace.trace_id)).fetchone()
-
-                if existing:
-                    # workflow (level 3) > team (level 2) > agent (level 1) > child/unknown (level 0)
-
-                    def get_component_level(workflow_id, team_id, agent_id, name):
-                        # Check if name indicates a root span
-                        is_root_name = ".run" in name or ".arun" in name
-
-                        if not is_root_name:
-                            return 0  # Child span (not a root)
-                        elif workflow_id:
-                            return 3  # Workflow root
-                        elif team_id:
-                            return 2  # Team root
-                        elif agent_id:
-                            return 1  # Agent root
-                        else:
-                            return 0  # Unknown
-
-                    existing_level = get_component_level(
-                        existing.workflow_id, existing.team_id, existing.agent_id, existing.name
-                    )
-                    new_level = get_component_level(trace.workflow_id, trace.team_id, trace.agent_id, trace.name)
-
-                    # Only update name if new trace is from a higher or equal level
-                    should_update_name = new_level > existing_level
+            trace_dict = trace.to_dict()
+            trace_dict.pop("total_spans", None)
+            trace_dict.pop("error_count", None)
 
-                    # Parse existing start_time to calculate correct duration
-                    existing_start_time_str = existing.start_time
-                    if isinstance(existing_start_time_str, str):
-                        existing_start_time = datetime.fromisoformat(existing_start_time_str.replace("Z", "+00:00"))
-                    else:
-                        existing_start_time = trace.start_time
-
-                    recalculated_duration_ms = int((trace.end_time - existing_start_time).total_seconds() * 1000)
-
-                    update_values = {
-                        "end_time": trace.end_time.isoformat(),
-                        "duration_ms": recalculated_duration_ms,
-                        "status": trace.status,
-                        "name": trace.name if should_update_name else existing.name,
-                    }
+            with self.Session() as sess, sess.begin():
+                # Use upsert to handle concurrent inserts atomically
+                # On conflict, update fields while preserving existing non-null context values
+                # and keeping the earliest start_time
+                insert_stmt = sqlite.insert(table).values(trace_dict)
+
+                # Build component level expressions for comparing trace priority
+                new_level = self._get_trace_component_level_expr(
+                    insert_stmt.excluded.workflow_id,
+                    insert_stmt.excluded.team_id,
+                    insert_stmt.excluded.agent_id,
+                    insert_stmt.excluded.name,
+                )
+                existing_level = self._get_trace_component_level_expr(
+                    table.c.workflow_id,
+                    table.c.team_id,
+                    table.c.agent_id,
+                    table.c.name,
+                )
 
-                    # Update context fields ONLY if new value is not None (preserve non-null values)
-                    if trace.run_id is not None:
-                        update_values["run_id"] = trace.run_id
-                    if trace.session_id is not None:
-                        update_values["session_id"] = trace.session_id
-                    if trace.user_id is not None:
-                        update_values["user_id"] = trace.user_id
-                    if trace.agent_id is not None:
-                        update_values["agent_id"] = trace.agent_id
-                    if trace.team_id is not None:
-                        update_values["team_id"] = trace.team_id
-                    if trace.workflow_id is not None:
-                        update_values["workflow_id"] = trace.workflow_id
-
-                    stmt = update(table).where(table.c.trace_id == trace.trace_id).values(**update_values)
-                    sess.execute(stmt)
-                else:
-                    trace_dict = trace.to_dict()
-                    trace_dict.pop("total_spans", None)
-                    trace_dict.pop("error_count", None)
-                    stmt = sqlite.insert(table).values(trace_dict)
-                    sess.execute(stmt)
+                # Build the ON CONFLICT DO UPDATE clause
+                # Use MIN for start_time, MAX for end_time to capture full trace duration
+                # SQLite stores timestamps as ISO strings, so string comparison works for ISO format
+                # Duration is calculated as: (MAX(end_time) - MIN(start_time)) in milliseconds
+                # SQLite doesn't have epoch extraction, so we calculate duration using julianday
+                upsert_stmt = insert_stmt.on_conflict_do_update(
+                    index_elements=["trace_id"],
+                    set_={
+                        "end_time": func.max(table.c.end_time, insert_stmt.excluded.end_time),
+                        "start_time": func.min(table.c.start_time, insert_stmt.excluded.start_time),
+                        # Calculate duration in milliseconds using julianday (SQLite-specific)
+                        # julianday returns days, so multiply by 86400000 to get milliseconds
+                        "duration_ms": (
+                            func.julianday(func.max(table.c.end_time, insert_stmt.excluded.end_time))
+                            - func.julianday(func.min(table.c.start_time, insert_stmt.excluded.start_time))
+                        )
+                        * 86400000,
+                        "status": insert_stmt.excluded.status,
+                        # Update name only if new trace is from a higher-level component
+                        # Priority: workflow (3) > team (2) > agent (1) > child spans (0)
+                        "name": case(
+                            (new_level > existing_level, insert_stmt.excluded.name),
+                            else_=table.c.name,
+                        ),
+                        # Preserve existing non-null context values using COALESCE
+                        "run_id": func.coalesce(insert_stmt.excluded.run_id, table.c.run_id),
+                        "session_id": func.coalesce(insert_stmt.excluded.session_id, table.c.session_id),
+                        "user_id": func.coalesce(insert_stmt.excluded.user_id, table.c.user_id),
+                        "agent_id": func.coalesce(insert_stmt.excluded.agent_id, table.c.agent_id),
+                        "team_id": func.coalesce(insert_stmt.excluded.team_id, table.c.team_id),
+                        "workflow_id": func.coalesce(insert_stmt.excluded.workflow_id, table.c.workflow_id),
+                    },
+                )
+                sess.execute(upsert_stmt)
 
         except Exception as e:
             log_error(f"Error creating trace: {e}")

agno/db/surrealdb/surrealdb.py

@@ -1390,8 +1390,8 @@ class SurrealDb(BaseDb):
         return deserialize_eval_run_record(raw)
 
     # --- Traces ---
-    def create_trace(self, trace: "Trace") -> None:
-        """Create a single trace record in the database.
+    def upsert_trace(self, trace: "Trace") -> None:
+        """Create or update a single trace record in the database.
 
         Args:
             trace: The Trace object to store (one per trace_id).

agno/eval/accuracy.py

@@ -282,7 +282,8 @@ Remember: You must only compare the agent_output to the expected_output. The exp
     ) -> Optional[AccuracyEvaluation]:
         """Orchestrate the evaluation process."""
         try:
-            accuracy_agent_response = evaluator_agent.run(evaluation_input).content
+            response = evaluator_agent.run(evaluation_input, stream=False)
+            accuracy_agent_response = response.content
             if accuracy_agent_response is None or not isinstance(accuracy_agent_response, AccuracyAgentResponse):
                 raise EvalError(f"Evaluator Agent returned an invalid response: {accuracy_agent_response}")
             return AccuracyEvaluation(
@@ -306,7 +307,7 @@ Remember: You must only compare the agent_output to the expected_output. The exp
     ) -> Optional[AccuracyEvaluation]:
         """Orchestrate the evaluation process asynchronously."""
         try:
-            response = await evaluator_agent.arun(evaluation_input)
+            response = await evaluator_agent.arun(evaluation_input, stream=False)
             accuracy_agent_response = response.content
             if accuracy_agent_response is None or not isinstance(accuracy_agent_response, AccuracyAgentResponse):
                 raise EvalError(f"Evaluator Agent returned an invalid response: {accuracy_agent_response}")
@@ -362,9 +363,11 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 agent_session_id = f"eval_{self.eval_id}_{i + 1}"
 
                 if self.agent is not None:
-                    output = self.agent.run(input=eval_input, session_id=agent_session_id).content
+                    agent_response = self.agent.run(input=eval_input, session_id=agent_session_id, stream=False)
+                    output = agent_response.content
                 elif self.team is not None:
-                    output = self.team.run(input=eval_input, session_id=agent_session_id).content
+                    team_response = self.team.run(input=eval_input, session_id=agent_session_id, stream=False)
+                    output = team_response.content
 
                 if not output:
                     logger.error(f"Failed to generate a valid answer on iteration {i + 1}: {output}")
@@ -505,11 +508,11 @@ Remember: You must only compare the agent_output to the expected_output. The exp
                 agent_session_id = f"eval_{self.eval_id}_{i + 1}"
 
                 if self.agent is not None:
-                    response = await self.agent.arun(input=eval_input, session_id=agent_session_id)
-                    output = response.content
+                    agent_response = await self.agent.arun(input=eval_input, session_id=agent_session_id, stream=False)
+                    output = agent_response.content
                 elif self.team is not None:
-                    response = await self.team.arun(input=eval_input, session_id=agent_session_id)  # type: ignore
-                    output = response.content
+                    team_response = await self.team.arun(input=eval_input, session_id=agent_session_id, stream=False)
+                    output = team_response.content
 
                 if not output:
                     logger.error(f"Failed to generate a valid answer on iteration {i + 1}: {output}")

agno/eval/agent_as_judge.py

@@ -281,24 +281,25 @@ class AgentAsJudgeEval(BaseEval):
                 </output>
             """)
 
-            response = evaluator_agent.run(prompt).content
-            if not isinstance(response, (NumericJudgeResponse, BinaryJudgeResponse)):
-                raise EvalError(f"Invalid response: {response}")
+            response = evaluator_agent.run(prompt, stream=False)
+            judge_response = response.content
+            if not isinstance(judge_response, (NumericJudgeResponse, BinaryJudgeResponse)):
+                raise EvalError(f"Invalid response: {judge_response}")
 
             # Determine pass/fail based on scoring strategy and response type
-            if isinstance(response, NumericJudgeResponse):
-                score = response.score
+            if isinstance(judge_response, NumericJudgeResponse):
+                score = judge_response.score
                 passed = score >= self.threshold
             else:  # BinaryJudgeResponse
                 score = None
-                passed = response.passed
+                passed = judge_response.passed
 
             evaluation = AgentAsJudgeEvaluation(
                 input=input,
                 output=output,
                 criteria=self.criteria,
                 score=score,
-                reason=response.reason,
+                reason=judge_response.reason,
                 passed=passed,
             )
 
@@ -332,7 +333,7 @@ class AgentAsJudgeEval(BaseEval):
                 </output>
             """)
 
-            response = await evaluator_agent.arun(prompt)
+            response = await evaluator_agent.arun(prompt, stream=False)
             judge_response = response.content
             if not isinstance(judge_response, (NumericJudgeResponse, BinaryJudgeResponse)):
                 raise EvalError(f"Invalid response: {judge_response}")

agno/knowledge/chunking/fixed.py

@@ -53,5 +53,8 @@ class FixedSizeChunking(ChunkingStrategy):
                 )
             )
             chunk_number += 1
-            start = end - self.overlap
+            # Ensure start always advances by at least 1 to prevent infinite loops
+            # when overlap is large relative to chunk_size
+            new_start = max(start + 1, end - self.overlap)
+            start = new_start
         return chunked_documents

agno/knowledge/embedder/openai.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from typing_extensions import Literal
 
 from agno.knowledge.embedder.base import Embedder
-from agno.utils.log import log_warning, log_info
+from agno.utils.log import log_info, log_warning
 
 try:
     from openai import AsyncOpenAI

agno/knowledge/knowledge.py

@@ -1960,8 +1960,8 @@ class Knowledge:
             content_row.updated_at = int(time.time())
             self.contents_db.upsert_knowledge_content(knowledge_row=content_row)
 
-            if self.vector_db and content.metadata:
-                self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata)
+            if self.vector_db:
+                self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata or {})
 
             return content_row.to_dict()
 
@@ -2006,8 +2006,8 @@ class Knowledge:
             else:
                 self.contents_db.upsert_knowledge_content(knowledge_row=content_row)
 
-            if self.vector_db and content.metadata:
-                self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata)
+            if self.vector_db:
+                self.vector_db.update_metadata(content_id=content.id, metadata=content.metadata or {})
 
             return content_row.to_dict()
 
@@ -2783,6 +2783,24 @@ class Knowledge:
         """Get all currently loaded readers (only returns readers that have been used)."""
         if self.readers is None:
             self.readers = {}
+        elif not isinstance(self.readers, dict):
+            # Defensive check: if readers is not a dict (e.g., was set to a list), convert it
+            if isinstance(self.readers, list):
+                readers_dict: Dict[str, Reader] = {}
+                for reader in self.readers:
+                    if isinstance(reader, Reader):
+                        reader_key = self._generate_reader_key(reader)
+                        # Handle potential duplicate keys by appending index if needed
+                        original_key = reader_key
+                        counter = 1
+                        while reader_key in readers_dict:
+                            reader_key = f"{original_key}_{counter}"
+                            counter += 1
+                        readers_dict[reader_key] = reader
+                self.readers = readers_dict
+            else:
+                # For any other unexpected type, reset to empty dict
+                self.readers = {}
 
         return self.readers