dao-ai 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

dao_ai/genie/cache/core.py

@@ -38,7 +38,7 @@ def execute_sql_via_warehouse(
     w: WorkspaceClient = warehouse.workspace_client
     warehouse_id: str = str(warehouse.warehouse_id)
 
-    logger.debug(f"[{layer_name}] Executing cached SQL: {sql[:100]}...")
+    logger.trace("Executing cached SQL", layer=layer_name, sql_prefix=sql[:100])
 
     statement_response: StatementResponse = w.statement_execution.execute_statement(
         statement=sql,
@@ -57,7 +57,11 @@ def execute_sql_via_warehouse(
 
     if statement_response.status.state != StatementState.SUCCEEDED:
         error_msg: str = f"SQL execution failed: {statement_response.status}"
-        logger.error(f"[{layer_name}] {error_msg}")
+        logger.error(
+            "SQL execution failed",
+            layer=layer_name,
+            status=str(statement_response.status),
+        )
         return error_msg
 
     # Convert to DataFrame

dao_ai/genie/cache/lru.py

@@ -124,7 +124,9 @@ class LRUCacheService(GenieServiceBase):
         if self._cache:
             oldest_key: str = next(iter(self._cache))
             del self._cache[oldest_key]
-            logger.debug(f"[{self.name}] Evicted: {oldest_key[:50]}...")
+            logger.trace(
+                "Evicted cache entry", layer=self.name, key_prefix=oldest_key[:50]
+            )
 
     def _get(self, key: str) -> SQLCacheEntry | None:
         """Get from cache, returning None if not found or expired."""
@@ -135,7 +137,7 @@ class LRUCacheService(GenieServiceBase):
 
         if self._is_expired(entry):
             del self._cache[key]
-            logger.debug(f"[{self.name}] Expired: {key[:50]}...")
+            logger.trace("Expired cache entry", layer=self.name, key_prefix=key[:50])
             return None
 
         self._cache.move_to_end(key)
@@ -156,9 +158,12 @@ class LRUCacheService(GenieServiceBase):
             created_at=datetime.now(),
         )
         logger.info(
-            f"[{self.name}] Stored cache entry: key='{key[:50]}...' "
-            f"sql='{response.query[:50] if response.query else 'None'}...' "
-            f"(cache_size={len(self._cache)}/{self.capacity})"
+            "Stored cache entry",
+            layer=self.name,
+            key_prefix=key[:50],
+            sql_prefix=response.query[:50] if response.query else None,
+            cache_size=len(self._cache),
+            capacity=self.capacity,
         )
 
     @mlflow.trace(name="execute_cached_sql")
@@ -175,7 +180,7 @@ class LRUCacheService(GenieServiceBase):
         w: WorkspaceClient = self.warehouse.workspace_client
         warehouse_id: str = str(self.warehouse.warehouse_id)
 
-        logger.debug(f"[{self.name}] Executing cached SQL: {sql[:100]}...")
+        logger.trace("Executing cached SQL", layer=self.name, sql_prefix=sql[:100])
 
         statement_response: StatementResponse = w.statement_execution.execute_statement(
             statement=sql,
@@ -194,7 +199,11 @@ class LRUCacheService(GenieServiceBase):
 
         if statement_response.status.state != StatementState.SUCCEEDED:
             error_msg: str = f"SQL execution failed: {statement_response.status}"
-            logger.error(f"[{self.name}] {error_msg}")
+            logger.error(
+                "SQL execution failed",
+                layer=self.name,
+                status=str(statement_response.status),
+            )
             return error_msg
 
         # Convert to DataFrame
@@ -250,8 +259,12 @@ class LRUCacheService(GenieServiceBase):
 
         if cached is not None:
             logger.info(
-                f"[{self.name}] Cache HIT: '{question[:50]}...' "
-                f"(conversation_id={conversation_id}, cache_size={self.size}/{self.capacity})"
+                "Cache HIT",
+                layer=self.name,
+                question_prefix=question[:50],
+                conversation_id=conversation_id,
+                cache_size=self.size,
+                capacity=self.capacity,
             )
 
             # Re-execute the cached SQL to get fresh data
@@ -271,8 +284,13 @@ class LRUCacheService(GenieServiceBase):
 
         # Cache miss - delegate to wrapped service
         logger.info(
-            f"[{self.name}] Cache MISS: '{question[:50]}...' "
-            f"(conversation_id={conversation_id}, cache_size={self.size}/{self.capacity}, delegating to {type(self.impl).__name__})"
+            "Cache MISS",
+            layer=self.name,
+            question_prefix=question[:50],
+            conversation_id=conversation_id,
+            cache_size=self.size,
+            capacity=self.capacity,
+            delegating_to=type(self.impl).__name__,
         )
 
         result: CacheResult = self.impl.ask_question(question, conversation_id)

dao_ai/genie/cache/semantic.py

@@ -78,7 +78,9 @@ def get_conversation_history(
         return []
     except Exception as e:
         logger.warning(
-            f"Failed to retrieve conversation history for conversation_id={conversation_id}: {e}"
+            "Failed to retrieve conversation history",
+            conversation_id=conversation_id,
+            error=str(e),
         )
         return []
 
@@ -137,10 +139,13 @@ def build_context_string(
     if estimated_tokens > max_tokens:
         # Truncate to fit max_tokens
         target_chars = max_tokens * 4
+        original_length = len(context_string)
         context_string = context_string[:target_chars] + "..."
-        logger.debug(
-            f"Truncated context string from {len(context_string)} to {target_chars} chars "
-            f"(estimated {max_tokens} tokens)"
+        logger.trace(
+            "Truncated context string",
+            original_chars=original_length,
+            target_chars=target_chars,
+            max_tokens=max_tokens,
         )
 
     return context_string
@@ -251,7 +256,9 @@ class SemanticCacheService(GenieServiceBase):
             sample_embedding: list[float] = self._embeddings.embed_query("test")
             self._embedding_dims = len(sample_embedding)
             logger.debug(
-                f"[{self.name}] Auto-detected embedding dimensions: {self._embedding_dims}"
+                "Auto-detected embedding dimensions",
+                layer=self.name,
+                dims=self._embedding_dims,
             )
         else:
             self._embedding_dims = self.parameters.embedding_dims
@@ -264,8 +271,11 @@ class SemanticCacheService(GenieServiceBase):
 
         self._setup_complete = True
         logger.debug(
-            f"[{self.name}] Semantic cache initialized for space '{self.space_id}' "
-            f"with table '{self.table_name}' (dims={self._embedding_dims})"
+            "Semantic cache initialized",
+            layer=self.name,
+            space_id=self.space_id,
+            table_name=self.table_name,
+            dims=self._embedding_dims,
         )
 
     @property
@@ -369,9 +379,11 @@ class SemanticCacheService(GenieServiceBase):
                         current_dims = row.get("atttypmod", 0)
                         if current_dims != self.embedding_dims:
                             logger.warning(
-                                f"[{self.name}] Embedding dimension mismatch: "
-                                f"table has {current_dims}, expected {self.embedding_dims}. "
-                                f"Dropping and recreating table '{self.table_name}'."
+                                "Embedding dimension mismatch, dropping and recreating table",
+                                layer=self.name,
+                                table_dims=current_dims,
+                                expected_dims=self.embedding_dims,
+                                table_name=self.table_name,
                             )
                             cur.execute(f"DROP TABLE {self.table_name}")
                 except Exception:
@@ -448,13 +460,17 @@ class SemanticCacheService(GenieServiceBase):
                             conversation_context[:target_chars] + "..."
                         )
 
-                logger.debug(
-                    f"[{self.name}] Using conversation context: {len(conversation_messages)} messages "
-                    f"(window_size={self.parameters.context_window_size})"
+                logger.trace(
+                    "Using conversation context",
+                    layer=self.name,
+                    messages_count=len(conversation_messages),
+                    window_size=self.parameters.context_window_size,
                 )
             except Exception as e:
                 logger.warning(
-                    f"[{self.name}] Failed to build conversation context, using question only: {e}"
+                    "Failed to build conversation context, using question only",
+                    layer=self.name,
+                    error=str(e),
                 )
                 conversation_context = ""
 
@@ -558,8 +574,10 @@ class SemanticCacheService(GenieServiceBase):
 
                 if row is None:
                     logger.info(
-                        f"[{self.name}] MISS (no entries): "
-                        f"question='{question[:50]}...' space='{self.space_id}'"
+                        "Cache MISS (no entries)",
+                        layer=self.name,
+                        question_prefix=question[:50],
+                        space=self.space_id,
                     )
                     return None
 
@@ -577,25 +595,33 @@ class SemanticCacheService(GenieServiceBase):
                 is_valid: bool = row.get("is_valid", False)
 
                 # Log best match info
-                logger.info(
-                    f"[{self.name}] Best match: "
-                    f"question_sim={question_similarity:.4f}, context_sim={context_similarity:.4f}, "
-                    f"combined_sim={combined_similarity:.4f}, is_valid={is_valid}, "
-                    f"question='{cached_question[:50]}...', context='{cached_context[:80]}...'"
+                logger.debug(
+                    "Best match found",
+                    layer=self.name,
+                    question_sim=f"{question_similarity:.4f}",
+                    context_sim=f"{context_similarity:.4f}",
+                    combined_sim=f"{combined_similarity:.4f}",
+                    is_valid=is_valid,
+                    cached_question_prefix=cached_question[:50],
+                    cached_context_prefix=cached_context[:80],
                 )
 
                 # Check BOTH similarity thresholds (dual embedding precision check)
                 if question_similarity < self.parameters.similarity_threshold:
                     logger.info(
-                        f"[{self.name}] MISS (question similarity too low): "
-                        f"question_sim={question_similarity:.4f} < threshold={self.parameters.similarity_threshold}"
+                        "Cache MISS (question similarity too low)",
+                        layer=self.name,
+                        question_sim=f"{question_similarity:.4f}",
+                        threshold=self.parameters.similarity_threshold,
                     )
                     return None
 
                 if context_similarity < self.parameters.context_similarity_threshold:
                     logger.info(
-                        f"[{self.name}] MISS (context similarity too low): "
-                        f"context_sim={context_similarity:.4f} < threshold={self.parameters.context_similarity_threshold}"
+                        "Cache MISS (context similarity too low)",
+                        layer=self.name,
+                        context_sim=f"{context_similarity:.4f}",
+                        threshold=self.parameters.context_similarity_threshold,
                     )
                     return None
 
@@ -605,14 +631,21 @@ class SemanticCacheService(GenieServiceBase):
                     delete_sql = f"DELETE FROM {self.table_name} WHERE id = %s"
                     cur.execute(delete_sql, (entry_id,))
                     logger.info(
-                        f"[{self.name}] MISS (expired, deleted for refresh): "
-                        f"combined_sim={combined_similarity:.4f}, ttl={ttl_seconds}s, question='{cached_question[:50]}...'"
+                        "Cache MISS (expired, deleted for refresh)",
+                        layer=self.name,
+                        combined_sim=f"{combined_similarity:.4f}",
+                        ttl_seconds=ttl_seconds,
+                        cached_question_prefix=cached_question[:50],
                     )
                     return None
 
                 logger.info(
-                    f"[{self.name}] HIT: question_sim={question_similarity:.4f}, context_sim={context_similarity:.4f}, "
-                    f"combined_sim={combined_similarity:.4f} (cached_question='{cached_question[:50]}...')"
+                    "Cache HIT",
+                    layer=self.name,
+                    question_sim=f"{question_similarity:.4f}",
+                    context_sim=f"{context_similarity:.4f}",
+                    combined_sim=f"{combined_similarity:.4f}",
+                    cached_question_prefix=cached_question[:50],
                 )
 
                 entry = SQLCacheEntry(
@@ -664,9 +697,13 @@ class SemanticCacheService(GenieServiceBase):
                     ),
                 )
                 logger.info(
-                    f"[{self.name}] Stored cache entry: question='{question[:50]}...' "
-                    f"context='{conversation_context[:80]}...' "
-                    f"sql='{response.query[:50]}...' (space={self.space_id}, table={self.table_name})"
+                    "Stored cache entry",
+                    layer=self.name,
+                    question_prefix=question[:50],
+                    context_prefix=conversation_context[:80],
+                    sql_prefix=response.query[:50] if response.query else None,
+                    space=self.space_id,
+                    table=self.table_name,
                 )
 
     @mlflow.trace(name="execute_cached_sql_semantic")
@@ -692,7 +729,7 @@ class SemanticCacheService(GenieServiceBase):
                 if statement_response.status.error is not None
                 else f"SQL execution failed with state: {statement_response.status.state}"
             )
-            logger.error(f"[{self.name}] {error_msg}")
+            logger.error("SQL execution failed", layer=self.name, error=error_msg)
             return error_msg
 
         if statement_response.result and statement_response.result.data_array:
@@ -765,7 +802,10 @@ class SemanticCacheService(GenieServiceBase):
         if cache_result is not None:
             cached, combined_similarity = cache_result
             logger.debug(
-                f"[{self.name}] Semantic cache hit (combined_similarity={combined_similarity:.3f}): {question[:50]}..."
+                "Semantic cache hit",
+                layer=self.name,
+                combined_similarity=f"{combined_similarity:.3f}",
+                question_prefix=question[:50],
             )
 
             # Re-execute the cached SQL to get fresh data
@@ -785,15 +825,17 @@ class SemanticCacheService(GenieServiceBase):
             return CacheResult(response=response, cache_hit=True, served_by=self.name)
 
         # Cache miss - delegate to wrapped service
-        logger.debug(f"[{self.name}] Miss: {question[:50]}...")
+        logger.trace("Cache miss", layer=self.name, question_prefix=question[:50])
 
         result: CacheResult = self.impl.ask_question(question, conversation_id)
 
         # Store in cache if we got a SQL query
         if result.response.query:
             logger.info(
-                f"[{self.name}] Storing new cache entry for question: '{question[:50]}...' "
-                f"(space={self.space_id})"
+                "Storing new cache entry",
+                layer=self.name,
+                question_prefix=question[:50],
+                space=self.space_id,
             )
             self._store_entry(
                 question,
@@ -804,8 +846,9 @@ class SemanticCacheService(GenieServiceBase):
             )
         elif not result.response.query:
             logger.warning(
-                f"[{self.name}] Not caching: response has no SQL query "
-                f"(question='{question[:50]}...')"
+                "Not caching: response has no SQL query",
+                layer=self.name,
+                question_prefix=question[:50],
             )
 
         return CacheResult(response=result.response, cache_hit=False, served_by=None)
@@ -824,8 +867,10 @@ class SemanticCacheService(GenieServiceBase):
 
         # If TTL is disabled, nothing can expire
         if ttl_seconds is None or ttl_seconds < 0:
-            logger.debug(
-                f"[{self.name}] TTL disabled, no entries to expire for space {self.space_id}"
+            logger.trace(
+                "TTL disabled, no entries to expire",
+                layer=self.name,
+                space=self.space_id,
             )
             return 0
 
@@ -839,8 +884,11 @@ class SemanticCacheService(GenieServiceBase):
             with conn.cursor() as cur:
                 cur.execute(delete_sql, (self.space_id, ttl_seconds))
                 deleted: int = cur.rowcount
-                logger.debug(
-                    f"[{self.name}] Deleted {deleted} expired entries for space {self.space_id}"
+                logger.trace(
+                    "Deleted expired entries",
+                    layer=self.name,
+                    deleted_count=deleted,
+                    space=self.space_id,
                 )
                 return deleted
 
@@ -854,7 +902,10 @@ class SemanticCacheService(GenieServiceBase):
                 cur.execute(delete_sql, (self.space_id,))
                 deleted: int = cur.rowcount
                 logger.debug(
-                    f"[{self.name}] Cleared {deleted} entries for space {self.space_id}"
+                    "Cleared cache entries",
+                    layer=self.name,
+                    deleted_count=deleted,
+                    space=self.space_id,
                 )
                 return deleted
 

dao_ai/hooks/core.py

@@ -25,7 +25,7 @@ def create_hooks(
     Returns:
         Sequence of callable functions
     """
-    logger.debug(f"Creating hooks from: {function_hooks}")
+    logger.trace("Creating hooks", function_hooks=function_hooks)
     hooks: list[Callable[..., Any]] = []
     if not function_hooks:
         return []
@@ -35,21 +35,21 @@ def create_hooks(
         if isinstance(function_hook, str):
             function_hook = PythonFunctionModel(name=function_hook)
         hooks.extend(function_hook.as_tools())
-    logger.debug(f"Created hooks: {hooks}")
+    logger.trace("Created hooks", hooks_count=len(hooks))
     return hooks
 
 
 def null_hook(state: dict[str, Any], config: Any) -> dict[str, Any]:
     """A no-op hook that returns an empty dict."""
-    logger.debug("Executing null hook")
+    logger.trace("Executing null hook")
     return {}
 
 
 def null_initialization_hook(config: AppConfig) -> None:
     """A no-op initialization hook."""
-    logger.debug("Executing null initialization hook")
+    logger.trace("Executing null initialization hook")
 
 
 def null_shutdown_hook(config: AppConfig) -> None:
     """A no-op shutdown hook."""
-    logger.debug("Executing null shutdown hook")
+    logger.trace("Executing null shutdown hook")

dao_ai/logging.py

@@ -0,0 +1,56 @@
+"""Logging configuration for DAO AI."""
+
+import sys
+from typing import Any
+
+from loguru import logger
+
+# Re-export logger for convenience
+__all__ = ["logger", "configure_logging"]
+
+
+def format_extra(record: dict[str, Any]) -> str:
+    """Format extra fields as key=value pairs."""
+    extra: dict[str, Any] = record["extra"]
+    if not extra:
+        return ""
+
+    formatted_pairs: list[str] = []
+    for key, value in extra.items():
+        # Handle different value types
+        if isinstance(value, str):
+            formatted_pairs.append(f"{key}={value}")
+        elif isinstance(value, (list, tuple)):
+            formatted_pairs.append(f"{key}={','.join(str(v) for v in value)}")
+        else:
+            formatted_pairs.append(f"{key}={value}")
+
+    return " | ".join(formatted_pairs)
+
+
+def configure_logging(level: str = "INFO") -> None:
+    """
+    Configure loguru logging with structured output.
+
+    Args:
+        level: The log level (e.g., "INFO", "DEBUG", "WARNING")
+    """
+    logger.remove()
+    logger.add(
+        sys.stderr,
+        level=level,
+        format=(
+            "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
+            "<level>{level: <8}</level> | "
+            "<cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - "
+            "<level>{message}</level>"
+            "{extra}"
+        ),
+    )
+
+    # Add custom formatter for extra fields
+    logger.configure(
+        patcher=lambda record: record.update(
+            extra=" | " + format_extra(record) if record["extra"] else ""
+        )
+    )

dao_ai/memory/core.py

@@ -25,11 +25,13 @@ class InMemoryStoreManager(StoreManagerBase):
         self.store_model = store_model
 
     def store(self) -> BaseStore:
-        logger.debug("Creating InMemory store")
+        embedding_model: LLMModel = self.store_model.embedding_model
 
-        index: dict[str, Any] = None
+        logger.debug(
+            "Creating in-memory store", embeddings_enabled=embedding_model is not None
+        )
 
-        embedding_model: LLMModel = self.store_model.embedding_model
+        index: dict[str, Any] = None
 
         if embedding_model:
             embeddings: Embeddings = DatabricksEmbeddings(endpoint=embedding_model.name)
@@ -39,6 +41,11 @@ class InMemoryStoreManager(StoreManagerBase):
 
             dims: int = self.store_model.dims
             index = {"dims": dims, "embed": embed_texts}
+            logger.debug(
+                "Store embeddings configured",
+                endpoint=embedding_model.name,
+                dimensions=dims,
+            )
 
         store: BaseStore = InMemoryStore(index=index)
 
@@ -59,32 +66,38 @@ class StoreManager:
     @classmethod
     def instance(cls, store_model: StoreModel) -> StoreManagerBase:
         store_manager: StoreManagerBase | None = None
-        match store_model.type:
+        match store_model.storage_type:
             case StorageType.MEMORY:
                 store_manager = cls.store_managers.get(store_model.name)
                 if store_manager is None:
                     store_manager = InMemoryStoreManager(store_model)
                     cls.store_managers[store_model.name] = store_manager
             case StorageType.POSTGRES:
-                from dao_ai.memory.postgres import PostgresStoreManager
+                # Route based on database configuration: instance_name -> Databricks, host -> Postgres
+                if store_model.database.is_lakebase:
+                    # Databricks Lakebase connection
+                    from dao_ai.memory.databricks import DatabricksStoreManager
 
-                store_manager = cls.store_managers.get(
-                    store_model.database.instance_name
-                )
-                if store_manager is None:
-                    store_manager = PostgresStoreManager(store_model)
-                    cls.store_managers[store_model.database.instance_name] = (
-                        store_manager
+                    store_manager = cls.store_managers.get(
+                        store_model.database.instance_name
                     )
-            case StorageType.LAKEBASE:
-                from dao_ai.memory.databricks import DatabricksStoreManager
-
-                store_manager = cls.store_managers.get(store_model.name)
-                if store_manager is None:
-                    store_manager = DatabricksStoreManager(store_model)
-                    cls.store_managers[store_model.name] = store_manager
+                    if store_manager is None:
+                        store_manager = DatabricksStoreManager(store_model)
+                        cls.store_managers[store_model.database.instance_name] = (
+                            store_manager
+                        )
+                else:
+                    # Standard PostgreSQL connection
+                    from dao_ai.memory.postgres import PostgresStoreManager
+
+                    # Use database name as key for standard PostgreSQL
+                    cache_key = f"{store_model.database.name}"
+                    store_manager = cls.store_managers.get(cache_key)
+                    if store_manager is None:
+                        store_manager = PostgresStoreManager(store_model)
+                        cls.store_managers[cache_key] = store_manager
             case _:
-                raise ValueError(f"Unknown store type: {store_model.type}")
+                raise ValueError(f"Unknown storage type: {store_model.storage_type}")
 
         return store_manager
 
@@ -95,7 +108,7 @@ class CheckpointManager:
     @classmethod
     def instance(cls, checkpointer_model: CheckpointerModel) -> CheckpointManagerBase:
         checkpointer_manager: CheckpointManagerBase | None = None
-        match checkpointer_model.type:
+        match checkpointer_model.storage_type:
             case StorageType.MEMORY:
                 checkpointer_manager = cls.checkpoint_managers.get(
                     checkpointer_model.name
@@ -108,32 +121,36 @@ class CheckpointManager:
                         checkpointer_manager
                     )
             case StorageType.POSTGRES:
-                from dao_ai.memory.postgres import AsyncPostgresCheckpointerManager
+                # Route based on database configuration: instance_name -> Databricks, host -> Postgres
+                if checkpointer_model.database.is_lakebase:
+                    # Databricks Lakebase connection
+                    from dao_ai.memory.databricks import DatabricksCheckpointerManager
 
-                checkpointer_manager = cls.checkpoint_managers.get(
-                    checkpointer_model.database.instance_name
-                )
-                if checkpointer_manager is None:
-                    checkpointer_manager = AsyncPostgresCheckpointerManager(
-                        checkpointer_model
-                    )
-                    cls.checkpoint_managers[
+                    checkpointer_manager = cls.checkpoint_managers.get(
                         checkpointer_model.database.instance_name
-                    ] = checkpointer_manager
-            case StorageType.LAKEBASE:
-                from dao_ai.memory.databricks import DatabricksCheckpointerManager
-
-                checkpointer_manager = cls.checkpoint_managers.get(
-                    checkpointer_model.name
-                )
-                if checkpointer_manager is None:
-                    checkpointer_manager = DatabricksCheckpointerManager(
-                        checkpointer_model
-                    )
-                    cls.checkpoint_managers[checkpointer_model.name] = (
-                        checkpointer_manager
                     )
+                    if checkpointer_manager is None:
+                        checkpointer_manager = DatabricksCheckpointerManager(
+                            checkpointer_model
+                        )
+                        cls.checkpoint_managers[
+                            checkpointer_model.database.instance_name
+                        ] = checkpointer_manager
+                else:
+                    # Standard PostgreSQL connection
+                    from dao_ai.memory.postgres import AsyncPostgresCheckpointerManager
+
+                    # Use database name as key for standard PostgreSQL
+                    cache_key = f"{checkpointer_model.database.name}"
+                    checkpointer_manager = cls.checkpoint_managers.get(cache_key)
+                    if checkpointer_manager is None:
+                        checkpointer_manager = AsyncPostgresCheckpointerManager(
+                            checkpointer_model
+                        )
+                        cls.checkpoint_managers[cache_key] = checkpointer_manager
             case _:
-                raise ValueError(f"Unknown store type: {checkpointer_model.type}")
+                raise ValueError(
+                    f"Unknown storage type: {checkpointer_model.storage_type}"
+                )
 
         return checkpointer_manager