dao-ai 0.0.21__py3-none-any.whl → 0.0.22__py3-none-any.whl

dao_ai/config.py

@@ -23,6 +23,7 @@ from databricks.sdk.credentials_provider import (
     ModelServingUserCredentials,
 )
 from databricks.sdk.service.catalog import FunctionInfo, TableInfo
+from databricks.sdk.service.database import DatabaseInstance
 from databricks.vector_search.client import VectorSearchClient
 from databricks.vector_search.index import VectorSearchIndex
 from databricks_langchain import (
@@ -703,15 +704,18 @@ class WarehouseModel(BaseModel, IsDatabricksResource):
 
 
 class DatabaseModel(BaseModel, IsDatabricksResource):
-    model_config = ConfigDict(frozen=True)
+    model_config = ConfigDict(use_enum_values=True, extra="forbid")
     name: str
+    instance_name: Optional[str] = None
     description: Optional[str] = None
-    host: Optional[AnyVariable]
+    host: Optional[AnyVariable] = None
     database: Optional[AnyVariable] = "databricks_postgres"
     port: Optional[AnyVariable] = 5432
     connection_kwargs: Optional[dict[str, Any]] = Field(default_factory=dict)
     max_pool_size: Optional[int] = 10
-    timeout_seconds: Optional[int] = 5
+    timeout_seconds: Optional[int] = 10
+    capacity: Optional[Literal["CU_1", "CU_2"]] = "CU_2"
+    node_count: Optional[int] = None
     user: Optional[AnyVariable] = None
     password: Optional[AnyVariable] = None
     client_id: Optional[AnyVariable] = None
@@ -725,11 +729,44 @@ class DatabaseModel(BaseModel, IsDatabricksResource):
     def as_resources(self) -> Sequence[DatabricksResource]:
         return [
             DatabricksLakebase(
-                database_instance_name=self.name,
+                database_instance_name=self.instance_name,
                 on_behalf_of_user=self.on_behalf_of_user,
             )
         ]
 
+    @model_validator(mode="after")
+    def update_instance_name(self):
+        if self.instance_name is None:
+            self.instance_name = self.name
+
+        return self
+
+    @model_validator(mode="after")
+    def update_user(self):
+        if self.client_id or self.user:
+            return self
+
+        self.user = self.workspace_client.current_user.me().user_name
+        if not self.user:
+            raise ValueError(
+                "Unable to determine current user. Please provide a user name or OAuth credentials."
+            )
+
+        return self
+
+    @model_validator(mode="after")
+    def update_host(self):
+        if self.host is not None:
+            return self
+
+        existing_instance: DatabaseInstance = (
+            self.workspace_client.database.get_database_instance(
+                name=self.instance_name
+            )
+        )
+        self.host = existing_instance.read_write_dns
+        return self
+
     @model_validator(mode="after")
     def validate_auth_methods(self):
         oauth_fields: Sequence[Any] = [
@@ -739,7 +776,7 @@ class DatabaseModel(BaseModel, IsDatabricksResource):
         ]
         has_oauth: bool = all(field is not None for field in oauth_fields)
 
-        pat_fields: Sequence[Any] = [self.user, self.password]
+        pat_fields: Sequence[Any] = [self.user]
         has_user_auth: bool = all(field is not None for field in pat_fields)
 
         if has_oauth and has_user_auth:
@@ -758,7 +795,14 @@ class DatabaseModel(BaseModel, IsDatabricksResource):
         return self
 
     @property
-    def connection_url(self) -> str:
+    def connection_params(self) -> dict[str, Any]:
+        """
+        Get database connection parameters as a dictionary.
+
+        Returns a dict with connection parameters suitable for psycopg ConnectionPool.
+        If username is configured, it will be included; otherwise it will be omitted
+        to allow Lakebase to authenticate using the token's identity.
+        """
         from dao_ai.providers.base import ServiceProvider
         from dao_ai.providers.databricks import DatabricksProvider
 
@@ -766,7 +810,7 @@ class DatabaseModel(BaseModel, IsDatabricksResource):
 
         if self.client_id and self.client_secret and self.workspace_host:
             username = value_of(self.client_id)
-        else:
+        elif self.user:
             username = value_of(self.user)
 
         host: str = value_of(self.host)
@@ -779,11 +823,48 @@ class DatabaseModel(BaseModel, IsDatabricksResource):
             workspace_host=value_of(self.workspace_host),
             pat=value_of(self.password),
         )
-        token: str = provider.create_token()
 
-        return (
-            f"postgresql://{username}:{token}@{host}:{port}/{database}?sslmode=require"
-        )
+        token: str = provider.lakebase_password_provider(self.instance_name)
+
+        # Build connection parameters dictionary
+        params: dict[str, Any] = {
+            "dbname": database,
+            "host": host,
+            "port": port,
+            "password": token,
+            "sslmode": "require",
+        }
+
+        # Only include user if explicitly configured
+        if username:
+            params["user"] = username
+            logger.debug(
+                f"Connection params: dbname={database} user={username} host={host} port={port} password=******** sslmode=require"
+            )
+        else:
+            logger.debug(
+                f"Connection params: dbname={database} host={host} port={port} password=******** sslmode=require (using token identity)"
+            )
+
+        return params
+
+    @property
+    def connection_url(self) -> str:
+        """
+        Get database connection URL as a string (for backwards compatibility).
+
+        Note: It's recommended to use connection_params instead for better flexibility.
+        """
+        params = self.connection_params
+        parts = [f"{k}={v}" for k, v in params.items()]
+        return " ".join(parts)
+
+    def create(self, w: WorkspaceClient | None = None) -> None:
+        from dao_ai.providers.databricks import DatabricksProvider
+
+        provider: DatabricksProvider = DatabricksProvider()
+        provider.create_lakebase(self)
+        provider.create_lakebase_instance_role(self)
 
 
 class SearchParametersModel(BaseModel):
@@ -1093,6 +1174,7 @@ class AgentModel(BaseModel):
 class SupervisorModel(BaseModel):
     model_config = ConfigDict(use_enum_values=True, extra="forbid")
     model: LLMModel
+    tools: list[ToolModel] = Field(default_factory=list)
     prompt: Optional[str] = None
 
 

dao_ai/graph.py

@@ -27,6 +27,7 @@ from dao_ai.nodes import (
 )
 from dao_ai.prompts import make_prompt
 from dao_ai.state import Context, IncomingState, OutgoingState, SharedState
+from dao_ai.tools import create_tools
 
 
 def route_message(state: SharedState) -> str:
@@ -91,6 +92,8 @@ def _create_supervisor_graph(config: AppConfig) -> CompiledStateGraph:
     orchestration: OrchestrationModel = config.app.orchestration
     supervisor: SupervisorModel = orchestration.supervisor
 
+    tools += create_tools(orchestration.supervisor.tools)
+
     store: BaseStore = None
     if orchestration.memory and orchestration.memory.store:
         store = orchestration.memory.store.as_store()

dao_ai/memory/core.py

@@ -70,10 +70,14 @@ class StoreManager:
             case StorageType.POSTGRES:
                 from dao_ai.memory.postgres import PostgresStoreManager
 
-                store_manager = cls.store_managers.get(store_model.database.name)
+                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.name] = store_manager
+                    cls.store_managers[store_model.database.instance_name] = (
+                        store_manager
+                    )
             case _:
                 raise ValueError(f"Unknown store type: {store_model.type}")
 
@@ -102,15 +106,15 @@ class CheckpointManager:
                 from dao_ai.memory.postgres import AsyncPostgresCheckpointerManager
 
                 checkpointer_manager = cls.checkpoint_managers.get(
-                    checkpointer_model.database.name
+                    checkpointer_model.database.instance_name
                 )
                 if checkpointer_manager is None:
                     checkpointer_manager = AsyncPostgresCheckpointerManager(
                         checkpointer_model
                     )
-                    cls.checkpoint_managers[checkpointer_model.database.name] = (
-                        checkpointer_manager
-                    )
+                    cls.checkpoint_managers[
+                        checkpointer_model.database.instance_name
+                    ] = checkpointer_manager
             case _:
                 raise ValueError(f"Unknown store type: {checkpointer_model.type}")
 

dao_ai/memory/postgres.py

@@ -20,6 +20,59 @@ from dao_ai.memory.base import (
 )
 
 
+def _create_pool(
+    connection_params: dict[str, Any],
+    database_name: str,
+    max_pool_size: int,
+    timeout_seconds: int,
+    kwargs: dict,
+) -> ConnectionPool:
+    """Create a connection pool using the provided connection parameters."""
+    logger.debug(
+        f"Connection params for {database_name}: {', '.join(k + '=' + (str(v) if k != 'password' else '***') for k, v in connection_params.items())}"
+    )
+
+    # Merge connection_params into kwargs for psycopg
+    connection_kwargs = kwargs | connection_params
+    pool = ConnectionPool(
+        conninfo="",  # Empty conninfo, params come from kwargs
+        min_size=1,
+        max_size=max_pool_size,
+        open=False,
+        timeout=timeout_seconds,
+        kwargs=connection_kwargs,
+    )
+    pool.open(wait=True, timeout=timeout_seconds)
+    logger.info(f"Successfully connected to {database_name}")
+    return pool
+
+
+async def _create_async_pool(
+    connection_params: dict[str, Any],
+    database_name: str,
+    max_pool_size: int,
+    timeout_seconds: int,
+    kwargs: dict,
+) -> AsyncConnectionPool:
+    """Create an async connection pool using the provided connection parameters."""
+    logger.debug(
+        f"Connection params for {database_name}: {', '.join(k + '=' + (str(v) if k != 'password' else '***') for k, v in connection_params.items())}"
+    )
+
+    # Merge connection_params into kwargs for psycopg
+    connection_kwargs = kwargs | connection_params
+    pool = AsyncConnectionPool(
+        conninfo="",  # Empty conninfo, params come from kwargs
+        max_size=max_pool_size,
+        open=False,
+        timeout=timeout_seconds,
+        kwargs=connection_kwargs,
+    )
+    await pool.open(wait=True, timeout=timeout_seconds)
+    logger.info(f"Successfully connected to {database_name}")
+    return pool
+
+
 class AsyncPostgresPoolManager:
     _pools: dict[str, AsyncConnectionPool] = {}
     _lock: asyncio.Lock = asyncio.Lock()
@@ -27,7 +80,7 @@ class AsyncPostgresPoolManager:
     @classmethod
     async def get_pool(cls, database: DatabaseModel) -> AsyncConnectionPool:
         connection_key: str = database.name
-        connection_url: str = database.connection_url
+        connection_params: dict[str, Any] = database.connection_params
 
         async with cls._lock:
             if connection_key in cls._pools:
@@ -41,23 +94,17 @@ class AsyncPostgresPoolManager:
                 "autocommit": True,
             } | database.connection_kwargs or {}
 
-            pool: AsyncConnectionPool = AsyncConnectionPool(
-                conninfo=connection_url,
-                max_size=database.max_pool_size,
-                open=False,
-                timeout=database.timeout_seconds,
+            # Create connection pool
+            pool: AsyncConnectionPool = await _create_async_pool(
+                connection_params=connection_params,
+                database_name=database.name,
+                max_pool_size=database.max_pool_size,
+                timeout_seconds=database.timeout_seconds,
                 kwargs=kwargs,
             )
 
-            try:
-                await pool.open(wait=True, timeout=database.timeout_seconds)
-                cls._pools[connection_key] = pool
-                return pool
-            except Exception as e:
-                logger.error(
-                    f"Failed to create PostgreSQL pool for {database.name}: {e}"
-                )
-                raise e
+            cls._pools[connection_key] = pool
+            return pool
 
     @classmethod
     async def close_pool(cls, database: DatabaseModel):
@@ -218,7 +265,7 @@ class PostgresPoolManager:
     @classmethod
     def get_pool(cls, database: DatabaseModel) -> ConnectionPool:
         connection_key: str = str(database.name)
-        connection_url: str = database.connection_url
+        connection_params: dict[str, Any] = database.connection_params
 
         with cls._lock:
             if connection_key in cls._pools:
@@ -232,23 +279,17 @@ class PostgresPoolManager:
                 "autocommit": True,
             } | database.connection_kwargs or {}
 
-            pool: ConnectionPool = ConnectionPool(
-                conninfo=connection_url,
-                max_size=database.max_pool_size,
-                open=False,
-                timeout=database.timeout_seconds,
+            # Create connection pool
+            pool: ConnectionPool = _create_pool(
+                connection_params=connection_params,
+                database_name=database.name,
+                max_pool_size=database.max_pool_size,
+                timeout_seconds=database.timeout_seconds,
                 kwargs=kwargs,
             )
 
-            try:
-                pool.open(wait=True, timeout=database.timeout_seconds)
-                cls._pools[connection_key] = pool
-                return pool
-            except Exception as e:
-                logger.error(
-                    f"Failed to create PostgreSQL pool for {database.name}: {e}"
-                )
-                raise e
+            cls._pools[connection_key] = pool
+            return pool
 
     @classmethod
     def close_pool(cls, database: DatabaseModel):

dao_ai/providers/databricks.py

@@ -1,4 +1,5 @@
 import base64
+import uuid
 from importlib.metadata import version
 from pathlib import Path
 from typing import Any, Callable, Final, Sequence
@@ -21,6 +22,7 @@ from databricks.sdk.service.catalog import (
     VolumeInfo,
     VolumeType,
 )
+from databricks.sdk.service.database import DatabaseCredential
 from databricks.sdk.service.iam import User
 from databricks.sdk.service.workspace import GetSecretResponse
 from databricks.vector_search.client import VectorSearchClient
@@ -743,3 +745,281 @@ class DatabricksProvider(ServiceProvider):
                 break
         logger.debug(f"Vector search index found: {found_endpoint_name}")
         return found_endpoint_name
+
+    def create_lakebase(self, database: DatabaseModel) -> None:
+        """
+        Create a Lakebase database instance using the Databricks workspace client.
+
+        This method handles idempotent database creation, gracefully handling cases where:
+        - The database instance already exists
+        - The database is in an intermediate state (STARTING, UPDATING, etc.)
+
+        Args:
+            database: DatabaseModel containing the database configuration
+
+        Returns:
+            None
+
+        Raises:
+            Exception: If an unexpected error occurs during database creation
+        """
+        import time
+        from typing import Any
+
+        workspace_client: WorkspaceClient = database.workspace_client
+
+        try:
+            # First, check if the database instance already exists
+            existing_instance: Any = workspace_client.database.get_database_instance(
+                name=database.instance_name
+            )
+
+            if existing_instance:
+                logger.debug(
+                    f"Database instance {database.instance_name} already exists with state: {existing_instance.state}"
+                )
+
+                # Check if database is in an intermediate state
+                if existing_instance.state in ["STARTING", "UPDATING"]:
+                    logger.info(
+                        f"Database instance {database.instance_name} is in {existing_instance.state} state, waiting for it to become AVAILABLE..."
+                    )
+
+                    # Wait for database to reach a stable state
+                    max_wait_time: int = 600  # 10 minutes
+                    wait_interval: int = 10  # 10 seconds
+                    elapsed: int = 0
+
+                    while elapsed < max_wait_time:
+                        try:
+                            current_instance: Any = (
+                                workspace_client.database.get_database_instance(
+                                    name=database.instance_name
+                                )
+                            )
+                            current_state: str = current_instance.state
+                            logger.debug(f"Database instance state: {current_state}")
+
+                            if current_state == "AVAILABLE":
+                                logger.info(
+                                    f"Database instance {database.instance_name} is now AVAILABLE"
+                                )
+                                break
+                            elif current_state in ["STARTING", "UPDATING"]:
+                                logger.debug(
+                                    f"Database instance still in {current_state} state, waiting {wait_interval} seconds..."
+                                )
+                                time.sleep(wait_interval)
+                                elapsed += wait_interval
+                            elif current_state in ["STOPPED", "DELETING"]:
+                                logger.warning(
+                                    f"Database instance {database.instance_name} is in unexpected state: {current_state}"
+                                )
+                                break
+                            else:
+                                logger.warning(
+                                    f"Unknown database state: {current_state}, proceeding anyway"
+                                )
+                                break
+                        except NotFound:
+                            logger.warning(
+                                f"Database instance {database.instance_name} no longer exists, will attempt to recreate"
+                            )
+                            break
+                        except Exception as state_error:
+                            logger.warning(
+                                f"Could not check database state: {state_error}, proceeding anyway"
+                            )
+                            break
+
+                    if elapsed >= max_wait_time:
+                        logger.warning(
+                            f"Timed out waiting for database instance {database.instance_name} to become AVAILABLE after {max_wait_time} seconds"
+                        )
+
+                elif existing_instance.state == "AVAILABLE":
+                    logger.info(
+                        f"Database instance {database.instance_name} already exists and is AVAILABLE"
+                    )
+                    return
+                elif existing_instance.state in ["STOPPED", "DELETING"]:
+                    logger.warning(
+                        f"Database instance {database.instance_name} is in {existing_instance.state} state"
+                    )
+                    return
+                else:
+                    logger.info(
+                        f"Database instance {database.instance_name} already exists with state: {existing_instance.state}"
+                    )
+                    return
+
+        except NotFound:
+            # Database doesn't exist, proceed with creation
+            logger.debug(
+                f"Database instance {database.instance_name} not found, creating new instance..."
+            )
+
+            try:
+                # Resolve variable values for database parameters
+                from databricks.sdk.service.database import DatabaseInstance
+
+                capacity: str = database.capacity if database.capacity else "CU_2"
+
+                # Create the database instance object
+                database_instance: DatabaseInstance = DatabaseInstance(
+                    name=database.instance_name,
+                    capacity=capacity,
+                    node_count=database.node_count,
+                )
+
+                # Create the database instance via API
+                workspace_client.database.create_database_instance(
+                    database_instance=database_instance
+                )
+                logger.info(
+                    f"Successfully created database instance: {database.instance_name}"
+                )
+
+            except Exception as create_error:
+                error_msg: str = str(create_error)
+
+                # Handle case where database was created by another process concurrently
+                if (
+                    "already exists" in error_msg.lower()
+                    or "RESOURCE_ALREADY_EXISTS" in error_msg
+                ):
+                    logger.info(
+                        f"Database instance {database.instance_name} was created concurrently by another process"
+                    )
+                    return
+                else:
+                    # Re-raise unexpected errors
+                    logger.error(
+                        f"Error creating database instance {database.instance_name}: {create_error}"
+                    )
+                    raise
+
+        except Exception as e:
+            # Handle other unexpected errors
+            error_msg: str = str(e)
+
+            # Check if this is actually a "resource already exists" type error
+            if (
+                "already exists" in error_msg.lower()
+                or "RESOURCE_ALREADY_EXISTS" in error_msg
+            ):
+                logger.info(
+                    f"Database instance {database.instance_name} already exists (detected via exception)"
+                )
+                return
+            else:
+                logger.error(
+                    f"Unexpected error while handling database {database.instance_name}: {e}"
+                )
+                raise
+
+    def lakebase_password_provider(self, instance_name: str) -> str:
+        """
+        Ask Databricks to mint a fresh DB credential for this instance.
+        """
+        logger.debug(f"Generating password for lakebase instance: {instance_name}")
+        w: WorkspaceClient = self.w
+        cred: DatabaseCredential = w.database.generate_database_credential(
+            request_id=str(uuid.uuid4()),
+            instance_names=[instance_name],
+        )
+        return cred.token
+
+    def create_lakebase_instance_role(self, database: DatabaseModel) -> None:
+        """
+        Create a database instance role for a Lakebase instance.
+
+        This method creates a role with DATABRICKS_SUPERUSER membership for the
+        service principal specified in the database configuration.
+
+        Args:
+            database: DatabaseModel containing the database and service principal configuration
+
+        Returns:
+            None
+
+        Raises:
+            ValueError: If client_id is not provided in the database configuration
+            Exception: If an unexpected error occurs during role creation
+        """
+        from databricks.sdk.service.database import (
+            DatabaseInstanceRole,
+            DatabaseInstanceRoleIdentityType,
+            DatabaseInstanceRoleMembershipRole,
+        )
+
+        from dao_ai.config import value_of
+
+        # Validate that client_id is provided
+        if not database.client_id:
+            logger.warning(
+                f"client_id is required to create instance role for database {database.instance_name}"
+            )
+            return
+
+        # Resolve the client_id value
+        client_id: str = value_of(database.client_id)
+        role_name: str = client_id
+        instance_name: str = database.instance_name
+
+        logger.debug(
+            f"Creating instance role '{role_name}' for database {instance_name} with principal {client_id}"
+        )
+
+        try:
+            # Check if role already exists
+            try:
+                _ = self.w.database.get_database_instance_role(
+                    instance_name=instance_name,
+                    name=role_name,
+                )
+                logger.info(
+                    f"Instance role '{role_name}' already exists for database {instance_name}"
+                )
+                return
+            except NotFound:
+                # Role doesn't exist, proceed with creation
+                logger.debug(
+                    f"Instance role '{role_name}' not found, creating new role..."
+                )
+
+            # Create the database instance role
+            role: DatabaseInstanceRole = DatabaseInstanceRole(
+                name=role_name,
+                identity_type=DatabaseInstanceRoleIdentityType.SERVICE_PRINCIPAL,
+                membership_role=DatabaseInstanceRoleMembershipRole.DATABRICKS_SUPERUSER,
+            )
+
+            # Create the role using the API
+            self.w.database.create_database_instance_role(
+                instance_name=instance_name,
+                database_instance_role=role,
+            )
+
+            logger.info(
+                f"Successfully created instance role '{role_name}' for database {instance_name}"
+            )
+
+        except Exception as e:
+            error_msg: str = str(e)
+
+            # Handle case where role was created concurrently
+            if (
+                "already exists" in error_msg.lower()
+                or "RESOURCE_ALREADY_EXISTS" in error_msg
+            ):
+                logger.info(
+                    f"Instance role '{role_name}' was created concurrently for database {instance_name}"
+                )
+                return
+
+            # Re-raise unexpected errors
+            logger.error(
+                f"Error creating instance role '{role_name}' for database {instance_name}: {e}"
+            )
+            raise

dao_ai/tools/genie.py

@@ -276,7 +276,7 @@ def create_genie_tool(
     genie_room: GenieRoomModel | dict[str, Any],
     name: Optional[str] = None,
     description: Optional[str] = None,
-    persist_conversation: bool = True,
+    persist_conversation: bool = False,
     truncate_results: bool = False,
     poll_interval: int = DEFAULT_POLLING_INTERVAL_SECS,
 ) -> Callable[[str], GenieResponse]:

dao_ai/utils.py

@@ -112,3 +112,7 @@ def load_function(function_name: str) -> Callable[..., Any]:
     except (ImportError, AttributeError, TypeError) as e:
         # Provide a detailed error message that includes the original exception
         raise ImportError(f"Failed to import {function_name}: {e}")
+
+
+def is_in_model_serving() -> bool:
+    return os.environ.get("IS_IN_DB_MODEL_SERVING_ENV", "false").lower() == "true"

{dao_ai-0.0.21.dist-info → dao_ai-0.0.22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.21
+Version: 0.0.22
 Summary: DAO AI: A modular, multi-agent orchestration framework for complex AI workflows. Supports agent handoff, tool integration, and dynamic configuration via YAML.
 Project-URL: Homepage, https://github.com/natefleming/dao-ai
 Project-URL: Documentation, https://natefleming.github.io/dao-ai
@@ -24,9 +24,9 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.12
-Requires-Dist: databricks-agents>=1.6.0
+Requires-Dist: databricks-agents>=1.6.1
 Requires-Dist: databricks-langchain>=0.8.0
-Requires-Dist: databricks-sdk[openai]>=0.66.0
+Requires-Dist: databricks-sdk[openai]>=0.67.0
 Requires-Dist: duckduckgo-search>=8.0.2
 Requires-Dist: grandalf>=0.8
 Requires-Dist: langchain-mcp-adapters>=0.1.10

{dao_ai-0.0.21.dist-info → dao_ai-0.0.22.dist-info}/RECORD

@@ -3,8 +3,8 @@ dao_ai/agent_as_code.py,sha256=kPSeDz2-1jRaed1TMs4LA3VECoyqe9_Ed2beRLB9gXQ,472
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/chat_models.py,sha256=uhwwOTeLyHWqoTTgHrs4n5iSyTwe4EQcLKnh3jRxPWI,8626
 dao_ai/cli.py,sha256=Aez2TQW3Q8Ho1IaIkRggt0NevDxAAVPjXkePC5GPJF0,20429
-dao_ai/config.py,sha256=GeaM00wNlYecwe3HhqeG88Hprt0SvGg4HtC7g_m-v98,52386
-dao_ai/graph.py,sha256=gmD9mxODfXuvn9xWeBfewm1FiuVAWMLEdnZz7DNmSH0,7859
+dao_ai/config.py,sha256=Kh0oJwWr2dhqrOriOEgjMs2CGhOdMYh1hTGO7sAPdw8,55268
+dao_ai/graph.py,sha256=APYc2y3cig4P52X4sOHSFSZNK8j5EtEPJLFwWeJ3KQQ,7956
 dao_ai/guardrails.py,sha256=4TKArDONRy8RwHzOT1plZ1rhy3x9GF_aeGpPCRl6wYA,4016
 dao_ai/messages.py,sha256=xl_3-WcFqZKCFCiov8sZOPljTdM3gX3fCHhxq-xFg2U,7005
 dao_ai/models.py,sha256=8r8GIG3EGxtVyWsRNI56lVaBjiNrPkzh4HdwMZRq8iw,31689
@@ -12,29 +12,29 @@ dao_ai/nodes.py,sha256=SSuFNTXOdFaKg_aX-yUkQO7fM9wvNGu14lPXKDapU1U,8461
 dao_ai/prompts.py,sha256=vpmIbWs_szXUgNNDs5Gh2LcxKZti5pHDKSfoClUcgX0,1289
 dao_ai/state.py,sha256=_lF9krAYYjvFDMUwZzVKOn0ZnXKcOrbjWKdre0C5B54,1137
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/utils.py,sha256=dkZTXNN6q0xwkrvSWdNq8937W2xGuLCRWRb6hRQM6kA,4217
+dao_ai/utils.py,sha256=A7BR28Rv7tH9B_lLVKlgBnWtcPeQ-Bafm2f57oTrUlQ,4337
 dao_ai/vector_search.py,sha256=jlaFS_iizJ55wblgzZmswMM3UOL-qOp2BGJc0JqXYSg,2839
 dao_ai/hooks/__init__.py,sha256=LlHGIuiZt6vGW8K5AQo1XJEkBP5vDVtMhq0IdjcLrD4,417
 dao_ai/hooks/core.py,sha256=ZShHctUSoauhBgdf1cecy9-D7J6-sGn-pKjuRMumW5U,6663
 dao_ai/memory/__init__.py,sha256=1kHx_p9abKYFQ6EYD05nuc1GS5HXVEpufmjBGw_7Uho,260
 dao_ai/memory/base.py,sha256=99nfr2UZJ4jmfTL_KrqUlRSCoRxzkZyWyx5WqeUoMdQ,338
-dao_ai/memory/core.py,sha256=g7chjBgVgx3iKjR2hghl0QL1j3802uIM_e7mgszur9M,4151
-dao_ai/memory/postgres.py,sha256=aWHRLhPm-9ywjlQe2B4XSdLbeaiuVV88p4PiQJFNEWo,13924
+dao_ai/memory/core.py,sha256=DnEjQO3S7hXr3CDDd7C2eE7fQUmcCS_8q9BXEgjPH3U,4271
+dao_ai/memory/postgres.py,sha256=vvI3osjx1EoU5GBA6SCUstTBKillcmLl12hVgDMjfJY,15346
 dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/providers/base.py,sha256=-fjKypCOk28h6vioPfMj9YZSw_3Kcbi2nMuAyY7vX9k,1383
-dao_ai/providers/databricks.py,sha256=PX5mBvZaIxSJIAHWVnPXsho1XvxcoR3Qs3I9UavFRsY,28306
+dao_ai/providers/databricks.py,sha256=CFZ2RojcTjiJ1aGwNI3_0qCGf339w2o5h9CRDKNesLs,39825
 dao_ai/tools/__init__.py,sha256=ye6MHaJY7tUnJ8336YJiLxuZr55zDPNdOw6gm7j5jlc,1103
 dao_ai/tools/agent.py,sha256=WbQnyziiT12TLMrA7xK0VuOU029tdmUBXbUl-R1VZ0Q,1886
 dao_ai/tools/core.py,sha256=Kei33S8vrmvPOAyrFNekaWmV2jqZ-IPS1QDSvU7RZF0,1984
-dao_ai/tools/genie.py,sha256=1CbLViNQ3KnmDtHXuwqCPug7rEhCGvuHP1NgsY-AJZ0,15050
+dao_ai/tools/genie.py,sha256=8HSOCzSg6PlBzBYXMmNfUnl-LO03p3Ki3fxLPm_dhPg,15051
 dao_ai/tools/human_in_the_loop.py,sha256=yk35MO9eNETnYFH-sqlgR-G24TrEgXpJlnZUustsLkI,3681
 dao_ai/tools/mcp.py,sha256=auEt_dwv4J26fr5AgLmwmnAsI894-cyuvkvjItzAUxs,4419
 dao_ai/tools/python.py,sha256=XcQiTMshZyLUTVR5peB3vqsoUoAAy8gol9_pcrhddfI,1831
 dao_ai/tools/time.py,sha256=Y-23qdnNHzwjvnfkWvYsE7PoWS1hfeKy44tA7sCnNac,8759
 dao_ai/tools/unity_catalog.py,sha256=uX_h52BuBAr4c9UeqSMI7DNz3BPRLeai5tBVW4sJqRI,13113
 dao_ai/tools/vector_search.py,sha256=EDYQs51zIPaAP0ma1D81wJT77GQ-v-cjb2XrFVWfWdg,2621
-dao_ai-0.0.21.dist-info/METADATA,sha256=PG-eOltuUpaJf4lYEw-DoVy5BFT9LbMCfe8GanIV7zQ,41380
-dao_ai-0.0.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dao_ai-0.0.21.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.0.21.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.0.21.dist-info/RECORD,,
+dao_ai-0.0.22.dist-info/METADATA,sha256=kqyr-YBFC_fs-PHknnvm4Ahhad8Pfac0gTb8vKydHMw,41380
+dao_ai-0.0.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+dao_ai-0.0.22.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.0.22.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.0.22.dist-info/RECORD,,