agno 2.2.8__py3-none-any.whl → 2.2.9__py3-none-any.whl

agno/db/surrealdb/surrealdb.py

@@ -116,12 +116,24 @@ class SurrealDb(BaseDb):
             "workflows": self._workflows_table_name,
         }
 
-    def _table_exists(self, table_name: str) -> bool:
+    def table_exists(self, table_name: str) -> bool:
+        """Check if a table with the given name exists in the SurrealDB database.
+
+        Args:
+            table_name: Name of the table to check
+
+        Returns:
+            bool: True if the table exists in the database, False otherwise
+        """
         response = self._query_one("INFO FOR DB", {}, dict)
         if response is None:
             raise Exception("Failed to retrieve database information")
         return table_name in response.get("tables", [])
 
+    def _table_exists(self, table_name: str) -> bool:
+        """Deprecated: Use table_exists() instead."""
+        return self.table_exists(table_name)
+
     def _create_table(self, table_type: TableType, table_name: str):
         query = get_schema(table_type, table_name)
         self.client.query(query)

agno/knowledge/reader/docx_reader.py

@@ -62,7 +62,6 @@ class DocxReader(Reader):
                     content=doc_content,
                 )
             ]
-
             if self.chunk:
                 chunked_documents = []
                 for document in documents:

agno/models/azure/ai_foundry.py

@@ -60,6 +60,7 @@ class AzureAIFoundry(Model):
     stop: Optional[Union[str, List[str]]] = None
     seed: Optional[int] = None
     model_extras: Optional[Dict[str, Any]] = None
+    strict_output: bool = True  # When True, guarantees schema adherence for structured outputs. When False, attempts to follow schema as a guide but may occasionally deviate
     request_params: Optional[Dict[str, Any]] = None
     # Client parameters
     api_key: Optional[str] = None
@@ -116,7 +117,7 @@ class AzureAIFoundry(Model):
                         name=response_format.__name__,
                         schema=response_format.model_json_schema(),  # type: ignore
                         description=response_format.__doc__,
-                        strict=True,
+                        strict=self.strict_output,
                     ),
                 )
 

agno/models/cerebras/cerebras.py

@@ -51,6 +51,7 @@ class Cerebras(Model):
     temperature: Optional[float] = None
     top_p: Optional[float] = None
     top_k: Optional[int] = None
+    strict_output: bool = True  # When True, guarantees schema adherence for structured outputs. When False, attempts to follow schema as a guide but may occasionally deviate
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
     extra_body: Optional[Any] = None
@@ -191,10 +192,10 @@ class Cerebras(Model):
                 and response_format.get("type") == "json_schema"
                 and isinstance(response_format.get("json_schema"), dict)
             ):
-                # Ensure json_schema has strict=True as required by Cerebras API
+                # Ensure json_schema has strict parameter set
                 schema = response_format["json_schema"]
                 if isinstance(schema.get("schema"), dict) and "strict" not in schema:
-                    schema["strict"] = True
+                    schema["strict"] = self.strict_output
 
                 request_params["response_format"] = response_format
 

agno/models/openai/chat.py

@@ -65,6 +65,7 @@ class OpenAIChat(Model):
     user: Optional[str] = None
     top_p: Optional[float] = None
     service_tier: Optional[str] = None  # "auto" | "default" | "flex" | "priority", defaults to "auto" when not set
+    strict_output: bool = True  # When True, guarantees schema adherence for structured outputs. When False, attempts to follow schema as a guide but may occasionally deviate
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
     extra_body: Optional[Any] = None
@@ -215,7 +216,7 @@ class OpenAIChat(Model):
                     "json_schema": {
                         "name": response_format.__name__,
                         "schema": schema,
-                        "strict": True,
+                        "strict": self.strict_output,
                     },
                 }
             else:

agno/models/openai/responses.py

@@ -53,6 +53,7 @@ class OpenAIResponses(Model):
     truncation: Optional[Literal["auto", "disabled"]] = None
     user: Optional[str] = None
     service_tier: Optional[Literal["auto", "default", "flex", "priority"]] = None
+    strict_output: bool = True  # When True, guarantees schema adherence for structured outputs. When False, attempts to follow schema as a guide but may occasionally deviate
     extra_headers: Optional[Any] = None
     extra_query: Optional[Any] = None
     extra_body: Optional[Any] = None
@@ -229,7 +230,7 @@ class OpenAIResponses(Model):
                     "type": "json_schema",
                     "name": response_format.__name__,
                     "schema": schema,
-                    "strict": True,
+                    "strict": self.strict_output,
                 }
             else:
                 # JSON mode

agno/os/app.py

@@ -1,7 +1,7 @@
 from contextlib import asynccontextmanager
 from functools import partial
 from os import getenv
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 from uuid import uuid4
 
 from fastapi import APIRouter, FastAPI, HTTPException
@@ -109,6 +109,7 @@ class AgentOS:
         base_app: Optional[FastAPI] = None,
         on_route_conflict: Literal["preserve_agentos", "preserve_base_app", "error"] = "preserve_agentos",
         telemetry: bool = True,
+        auto_provision_dbs: bool = True,
         os_id: Optional[str] = None,  # Deprecated
         enable_mcp: bool = False,  # Deprecated
         fastapi_app: Optional[FastAPI] = None,  # Deprecated
@@ -148,7 +149,7 @@ class AgentOS:
         self.a2a_interface = a2a_interface
         self.knowledge = knowledge
         self.settings: AgnoAPISettings = settings or AgnoAPISettings()
-
+        self.auto_provision_dbs = auto_provision_dbs
         self._app_set = False
 
         if base_app:
@@ -552,11 +553,12 @@ class AgentOS:
         }
 
     def _auto_discover_databases(self) -> None:
-        """Auto-discover the databases used by all contextual agents, teams and workflows."""
-        from agno.db.base import AsyncBaseDb, BaseDb
+        """Auto-discover and initialize the databases used by all contextual agents, teams and workflows."""
 
-        dbs: Dict[str, Union[BaseDb, AsyncBaseDb]] = {}
-        knowledge_dbs: Dict[str, Union[BaseDb, AsyncBaseDb]] = {}  # Track databases specifically used for knowledge
+        dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb]]] = {}
+        knowledge_dbs: Dict[
+            str, List[Union[BaseDb, AsyncBaseDb]]
+        ] = {}  # Track databases specifically used for knowledge
 
         for agent in self.agents or []:
             if agent.db:
@@ -587,48 +589,97 @@ class AgentOS:
         self.dbs = dbs
         self.knowledge_dbs = knowledge_dbs
 
-    def _register_db_with_validation(self, registered_dbs: Dict[str, Any], db: Union[BaseDb, AsyncBaseDb]) -> None:
-        """Register a database in the contextual OS after validating it is not conflicting with registered databases"""
-        if db.id in registered_dbs:
-            existing_db = registered_dbs[db.id]
-            if not self._are_db_instances_compatible(existing_db, db):
-                raise ValueError(
-                    f"Database ID conflict detected: Two different database instances have the same ID '{db.id}'. "
-                    f"Database instances with the same ID must point to the same database with identical configuration."
+        # Initialize/scaffold all discovered databases
+        if self.auto_provision_dbs:
+            import asyncio
+            import concurrent.futures
+
+            try:
+                # If we're already in an event loop, run in a separate thread
+                asyncio.get_running_loop()
+
+                def run_in_new_loop():
+                    new_loop = asyncio.new_event_loop()
+                    asyncio.set_event_loop(new_loop)
+                    try:
+                        return new_loop.run_until_complete(self._initialize_databases())
+                    finally:
+                        new_loop.close()
+
+                with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor:
+                    future = executor.submit(run_in_new_loop)
+                    future.result()  # Wait for completion
+
+            except RuntimeError:
+                # No event loop running, use asyncio.run
+                asyncio.run(self._initialize_databases())
+
+    async def _initialize_databases(self) -> None:
+        """Initialize all discovered databases and create all Agno tables that don't exist yet."""
+        from itertools import chain
+
+        # Collect all database instances and remove duplicates by identity
+        unique_dbs = list(
+            {
+                id(db): db
+                for db in chain(
+                    chain.from_iterable(self.dbs.values()), chain.from_iterable(self.knowledge_dbs.values())
                 )
-        registered_dbs[db.id] = db
-
-    def _are_db_instances_compatible(self, db1: Union[BaseDb, AsyncBaseDb], db2: Union[BaseDb, AsyncBaseDb]) -> bool:
-        """
-        Return True if the two given database objects are compatible
-        Two database objects are compatible if they point to the same database with identical configuration.
-        """
-        # If they're the same object reference, they're compatible
-        if db1 is db2:
-            return True
-
-        if type(db1) is not type(db2):
-            return False
-
-        if hasattr(db1, "db_url") and hasattr(db2, "db_url"):
-            if db1.db_url != db2.db_url:  # type: ignore
-                return False
-
-        if hasattr(db1, "db_file") and hasattr(db2, "db_file"):
-            if db1.db_file != db2.db_file:  # type: ignore
-                return False
+            }.values()
+        )
 
-        # If table names are different, they're not compatible
-        if (
-            db1.session_table_name != db2.session_table_name
-            or db1.memory_table_name != db2.memory_table_name
-            or db1.metrics_table_name != db2.metrics_table_name
-            or db1.eval_table_name != db2.eval_table_name
-            or db1.knowledge_table_name != db2.knowledge_table_name
-        ):
-            return False
+        # Separate sync and async databases
+        sync_dbs: List[Tuple[str, BaseDb]] = []
+        async_dbs: List[Tuple[str, AsyncBaseDb]] = []
+
+        for db in unique_dbs:
+            target = async_dbs if isinstance(db, AsyncBaseDb) else sync_dbs
+            target.append((db.id, db))  # type: ignore
+
+        # Initialize sync databases
+        for db_id, db in sync_dbs:
+            try:
+                if hasattr(db, "_create_all_tables") and callable(getattr(db, "_create_all_tables")):
+                    db._create_all_tables()
+                else:
+                    log_debug(f"No table initialization needed for {db.__class__.__name__}")
+
+            except Exception as e:
+                log_warning(f"Failed to initialize {db.__class__.__name__} (id: {db_id}): {e}")
+
+        # Initialize async databases
+        for db_id, db in async_dbs:
+            try:
+                log_debug(f"Initializing async {db.__class__.__name__} (id: {db_id})")
+
+                if hasattr(db, "_create_all_tables") and callable(getattr(db, "_create_all_tables")):
+                    await db._create_all_tables()
+                else:
+                    log_debug(f"No table initialization needed for async {db.__class__.__name__}")
+
+            except Exception as e:
+                log_warning(f"Failed to initialize async database {db.__class__.__name__} (id: {db_id}): {e}")
+
+    def _get_db_table_names(self, db: BaseDb) -> Dict[str, str]:
+        """Get the table names for a database"""
+        table_names = {
+            "session_table_name": db.session_table_name,
+            "culture_table_name": db.culture_table_name,
+            "memory_table_name": db.memory_table_name,
+            "metrics_table_name": db.metrics_table_name,
+            "evals_table_name": db.eval_table_name,
+            "knowledge_table_name": db.knowledge_table_name,
+        }
+        return {k: v for k, v in table_names.items() if v is not None}
 
-        return True
+    def _register_db_with_validation(
+        self, registered_dbs: Dict[str, List[Union[BaseDb, AsyncBaseDb]]], db: Union[BaseDb, AsyncBaseDb]
+    ) -> None:
+        """Register a database in the contextual OS after validating it is not conflicting with registered databases"""
+        if db.id in registered_dbs:
+            registered_dbs[db.id].append(db)
+        else:
+            registered_dbs[db.id] = [db]
 
     def _auto_discover_knowledge_instances(self) -> None:
         """Auto-discover the knowledge instances used by all contextual agents, teams and workflows."""
@@ -665,13 +716,15 @@ class AgentOS:
             session_config.dbs = []
 
         dbs_with_specific_config = [db.db_id for db in session_config.dbs]
-
-        for db_id in self.dbs.keys():
+        for db_id, dbs in self.dbs.items():
             if db_id not in dbs_with_specific_config:
+                # Collect unique table names from all databases with the same id
+                unique_tables = list(set(db.session_table_name for db in dbs))
                 session_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=SessionDomainConfig(display_name=db_id),
+                        tables=unique_tables,
                     )
                 )
 
@@ -685,12 +738,15 @@ class AgentOS:
 
         dbs_with_specific_config = [db.db_id for db in memory_config.dbs]
 
-        for db_id in self.dbs.keys():
+        for db_id, dbs in self.dbs.items():
             if db_id not in dbs_with_specific_config:
+                # Collect unique table names from all databases with the same id
+                unique_tables = list(set(db.memory_table_name for db in dbs))
                 memory_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=MemoryDomainConfig(display_name=db_id),
+                        tables=unique_tables,
                     )
                 )
 
@@ -724,12 +780,15 @@ class AgentOS:
 
         dbs_with_specific_config = [db.db_id for db in metrics_config.dbs]
 
-        for db_id in self.dbs.keys():
+        for db_id, dbs in self.dbs.items():
             if db_id not in dbs_with_specific_config:
+                # Collect unique table names from all databases with the same id
+                unique_tables = list(set(db.metrics_table_name for db in dbs))
                 metrics_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=MetricsDomainConfig(display_name=db_id),
+                        tables=unique_tables,
                     )
                 )
 
@@ -743,12 +802,15 @@ class AgentOS:
 
         dbs_with_specific_config = [db.db_id for db in evals_config.dbs]
 
-        for db_id in self.dbs.keys():
+        for db_id, dbs in self.dbs.items():
             if db_id not in dbs_with_specific_config:
+                # Collect unique table names from all databases with the same id
+                unique_tables = list(set(db.eval_table_name for db in dbs))
                 evals_config.dbs.append(
                     DatabaseConfig(
                         db_id=db_id,
                         domain_config=EvalsDomainConfig(display_name=db_id),
+                        tables=unique_tables,
                     )
                 )
 

agno/os/config.py

@@ -44,6 +44,7 @@ class DatabaseConfig(BaseModel, Generic[DomainConfigType]):
 
     db_id: str
     domain_config: Optional[DomainConfigType] = None
+    tables: Optional[List[str]] = None
 
 
 class EvalsConfig(EvalsDomainConfig):

agno/os/interfaces/agui/router.py

@@ -19,6 +19,7 @@ from agno.agent.agent import Agent
 from agno.os.interfaces.agui.utils import (
     async_stream_agno_response_as_agui_events,
     convert_agui_messages_to_agno_messages,
+    validate_agui_state,
 )
 from agno.team.team import Team
 
@@ -39,6 +40,9 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
         if run_input.forwarded_props and isinstance(run_input.forwarded_props, dict):
             user_id = run_input.forwarded_props.get("user_id")
 
+        # Validating the session state is of the expected type (dict)
+        session_state = validate_agui_state(run_input.state, run_input.thread_id)
+
         # Request streaming response from agent
         response_stream = agent.arun(
             input=messages,
@@ -46,6 +50,7 @@ async def run_agent(agent: Agent, run_input: RunAgentInput) -> AsyncIterator[Bas
             stream=True,
             stream_events=True,
             user_id=user_id,
+            session_state=session_state,
         )
 
         # Stream the response content in AG-UI format
@@ -75,6 +80,9 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
         if input.forwarded_props and isinstance(input.forwarded_props, dict):
             user_id = input.forwarded_props.get("user_id")
 
+        # Validating the session state is of the expected type (dict)
+        session_state = validate_agui_state(input.state, input.thread_id)
+
         # Request streaming response from team
         response_stream = team.arun(
             input=messages,
@@ -82,6 +90,7 @@ async def run_team(team: Team, input: RunAgentInput) -> AsyncIterator[BaseEvent]
             stream=True,
             stream_steps=True,
             user_id=user_id,
+            session_state=session_state,
         )
 
         # Stream the response content in AG-UI format

agno/os/interfaces/agui/utils.py

@@ -3,8 +3,8 @@
 import json
 import uuid
 from collections.abc import Iterator
-from dataclasses import dataclass
-from typing import AsyncIterator, List, Set, Tuple, Union
+from dataclasses import asdict, dataclass, is_dataclass
+from typing import Any, AsyncIterator, Dict, List, Optional, Set, Tuple, Union
 
 from ag_ui.core import (
     BaseEvent,
@@ -22,14 +22,48 @@ from ag_ui.core import (
     ToolCallStartEvent,
 )
 from ag_ui.core.types import Message as AGUIMessage
+from pydantic import BaseModel
 
 from agno.models.message import Message
 from agno.run.agent import RunContentEvent, RunEvent, RunOutputEvent, RunPausedEvent
 from agno.run.team import RunContentEvent as TeamRunContentEvent
 from agno.run.team import TeamRunEvent, TeamRunOutputEvent
+from agno.utils.log import log_warning
 from agno.utils.message import get_text_from_message
 
 
+def validate_agui_state(state: Any, thread_id: str) -> Optional[Dict[str, Any]]:
+    """Validate the given AGUI state is of the expected type (dict)."""
+    if state is None:
+        return None
+
+    if isinstance(state, dict):
+        return state
+
+    if isinstance(state, BaseModel):
+        try:
+            return state.model_dump()
+        except Exception:
+            pass
+
+    if is_dataclass(state):
+        try:
+            return asdict(state)  # type: ignore
+        except Exception:
+            pass
+
+    if hasattr(state, "to_dict") and callable(getattr(state, "to_dict")):
+        try:
+            result = state.to_dict()  # type: ignore
+            if isinstance(result, dict):
+                return result
+        except Exception:
+            pass
+
+    log_warning(f"AGUI state must be a dict, got {type(state).__name__}. State will be ignored. Thread: {thread_id}")
+    return None
+
+
 @dataclass
 class EventBuffer:
     """Buffer to manage event ordering constraints, relevant when mapping Agno responses to AG-UI events."""
@@ -264,7 +298,19 @@ def _create_events_from_chunk(
 
     # Handle custom events
     elif chunk.event == RunEvent.custom_event:
-        custom_event = CustomEvent(name=chunk.event, value=chunk.content)
+        # Use the name of the event class if available, otherwise default to the CustomEvent
+        try:
+            custom_event_name = chunk.__class__.__name__
+        except Exception:
+            custom_event_name = chunk.event
+
+        # Use the complete Agno event as value if parsing it works, else the event content field
+        try:
+            custom_event_value = chunk.to_dict()
+        except Exception:
+            custom_event_value = chunk.content  # type: ignore
+
+        custom_event = CustomEvent(name=custom_event_name, value=custom_event_value)
         events_to_emit.append(custom_event)
 
     return events_to_emit, message_started, message_id

agno/os/mcp.py

@@ -57,7 +57,7 @@ def get_mcp_server(
             os_id=os.id or "AgentOS",
             description=os.description,
             available_models=os.config.available_models if os.config else [],
-            databases=[db.id for db in os.dbs.values()],
+            databases=[db.id for db_list in os.dbs.values() for db in db_list],
             chat=os.config.chat if os.config else None,
             session=os._get_session_config(),
             memory=os._get_memory_config(),
@@ -103,7 +103,7 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             sessions = await db.get_sessions(
@@ -136,7 +136,7 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             sessions = await db.get_sessions(
@@ -169,7 +169,7 @@ def get_mcp_server(
         sort_by: str = "created_at",
         sort_order: str = "desc",
     ):
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             sessions = await db.get_sessions(
@@ -202,7 +202,7 @@ def get_mcp_server(
         user_id: str,
         topics: Optional[List[str]] = None,
     ) -> UserMemorySchema:
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         user_memory = db.upsert_user_memory(
             memory=UserMemory(
                 memory_id=str(uuid4()),
@@ -224,7 +224,7 @@ def get_mcp_server(
         sort_order: str = "desc",
         db_id: Optional[str] = None,
     ):
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             user_memories = await db.get_user_memories(
@@ -251,7 +251,7 @@ def get_mcp_server(
         memory: str,
         user_id: str,
     ) -> UserMemorySchema:
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             user_memory = await db.upsert_user_memory(
@@ -281,7 +281,7 @@ def get_mcp_server(
         db_id: str,
         memory_id: str,
     ) -> None:
-        db = get_db(os.dbs, db_id)
+        db = await get_db(os.dbs, db_id)
         if isinstance(db, AsyncBaseDb):
             db = cast(AsyncBaseDb, db)
             await db.delete_user_memory(memory_id=memory_id)

agno/os/router.py

@@ -1,5 +1,4 @@
 import json
-from itertools import chain
 from typing import TYPE_CHECKING, Any, AsyncGenerator, Callable, Dict, List, Optional, Union, cast
 from uuid import uuid4
 
@@ -73,33 +72,52 @@ async def _get_request_kwargs(request: Request, endpoint_func: Callable) -> Dict
     form_data = await request.form()
     sig = inspect.signature(endpoint_func)
     known_fields = set(sig.parameters.keys())
-    kwargs = {key: value for key, value in form_data.items() if key not in known_fields}
+    kwargs: Dict[str, Any] = {key: value for key, value in form_data.items() if key not in known_fields}
 
     # Handle JSON parameters. They are passed as strings and need to be deserialized.
     if session_state := kwargs.get("session_state"):
         try:
-            session_state_dict = json.loads(session_state)  # type: ignore
-            kwargs["session_state"] = session_state_dict
+            if isinstance(session_state, str):
+                session_state_dict = json.loads(session_state)  # type: ignore
+                kwargs["session_state"] = session_state_dict
         except json.JSONDecodeError:
             kwargs.pop("session_state")
             log_warning(f"Invalid session_state parameter couldn't be loaded: {session_state}")
 
     if dependencies := kwargs.get("dependencies"):
         try:
-            dependencies_dict = json.loads(dependencies)  # type: ignore
-            kwargs["dependencies"] = dependencies_dict
+            if isinstance(dependencies, str):
+                dependencies_dict = json.loads(dependencies)  # type: ignore
+                kwargs["dependencies"] = dependencies_dict
         except json.JSONDecodeError:
             kwargs.pop("dependencies")
             log_warning(f"Invalid dependencies parameter couldn't be loaded: {dependencies}")
 
     if metadata := kwargs.get("metadata"):
         try:
-            metadata_dict = json.loads(metadata)  # type: ignore
-            kwargs["metadata"] = metadata_dict
+            if isinstance(metadata, str):
+                metadata_dict = json.loads(metadata)  # type: ignore
+                kwargs["metadata"] = metadata_dict
         except json.JSONDecodeError:
             kwargs.pop("metadata")
             log_warning(f"Invalid metadata parameter couldn't be loaded: {metadata}")
 
+    if knowledge_filters := kwargs.get("knowledge_filters"):
+        try:
+            if isinstance(knowledge_filters, str):
+                knowledge_filters_dict = json.loads(knowledge_filters)  # type: ignore
+                kwargs["knowledge_filters"] = knowledge_filters_dict
+        except json.JSONDecodeError:
+            kwargs.pop("knowledge_filters")
+            log_warning(f"Invalid knowledge_filters parameter couldn't be loaded: {knowledge_filters}")
+
+    # Parse boolean and null values
+    for key, value in kwargs.items():
+        if isinstance(value, str) and value.lower() in ["true", "false"]:
+            kwargs[key] = value.lower() == "true"
+        elif isinstance(value, str) and value.lower() in ["null", "none"]:
+            kwargs[key] = None
+
     return kwargs
 
 
@@ -652,7 +670,7 @@ def get_base_router(
             os_id=os.id or "Unnamed OS",
             description=os.description,
             available_models=os.config.available_models if os.config else [],
-            databases=list({db.id for db in chain(os.dbs.values(), os.knowledge_dbs.values())}),
+            databases=list({db.id for db_id, dbs in os.dbs.items() for db in dbs}),
             chat=os.config.chat if os.config else None,
             session=os._get_session_config(),
             memory=os._get_memory_config(),