dao-ai 0.0.25__py3-none-any.whl → 0.0.28__py3-none-any.whl

dao_ai/tools/genie.py

@@ -1,6 +1,5 @@
 import bisect
 import json
-import logging
 import os
 import time
 from dataclasses import asdict, dataclass
@@ -184,7 +183,7 @@ class Genie:
                         conversation_id, result, query_str, description
                     )
                 elif state in ["RUNNING", "PENDING"]:
-                    logging.debug("Waiting for query result...")
+                    logger.debug("Waiting for query result...")
                     time.sleep(self.poll_interval)
                 else:
                     return GenieResponse(
@@ -250,7 +249,7 @@ class Genie:
                     )
                 # includes EXECUTING_QUERY, Genie can retry after this status
                 else:
-                    logging.debug(f"Waiting...: {resp['status']}")
+                    logger.debug(f"Waiting...: {resp['status']}")
                     time.sleep(self.poll_interval)
             return GenieResponse(
                 conversation_id,

dao_ai/tools/mcp.py

@@ -5,7 +5,6 @@ from databricks_mcp import DatabricksOAuthClientProvider
 from langchain_core.runnables.base import RunnableLike
 from langchain_core.tools import tool as create_tool
 from langchain_mcp_adapters.client import MultiServerMCPClient
-from langchain_mcp_adapters.tools import load_mcp_tools
 from loguru import logger
 from mcp import ClientSession
 from mcp.client.streamable_http import streamablehttp_client
@@ -31,26 +30,17 @@ def create_mcp_tools(
     """
     logger.debug(f"create_mcp_tools: {function}")
 
+    # Get MCP URL - handles all convenience objects (connection, genie_room, warehouse, etc.)
+    mcp_url = function.mcp_url
+    logger.debug(f"Using MCP URL: {mcp_url}")
+
     # Check if using UC Connection or direct MCP connection
     if function.connection:
         # Use UC Connection approach with DatabricksOAuthClientProvider
         logger.debug(f"Using UC Connection for MCP: {function.connection.name}")
 
-        # Construct URL if not provided
-        if function.url:
-            mcp_url = function.url
-            logger.debug(f"Using provided MCP URL: {mcp_url}")
-        else:
-            # Construct URL from workspace host and connection name
-            # Pattern: https://{workspace_host}/api/2.0/mcp/external/{connection_name}
-            workspace_client = function.connection.workspace_client
-            workspace_host = workspace_client.config.host
-            connection_name = function.connection.name
-            mcp_url = f"{workspace_host}/api/2.0/mcp/external/{connection_name}"
-            logger.debug(f"Constructed MCP URL from connection: {mcp_url}")
-
-        async def _get_tools_with_connection():
-            """Get tools using DatabricksOAuthClientProvider."""
+        async def _list_tools_with_connection():
+            """List available tools using DatabricksOAuthClientProvider."""
             workspace_client = function.connection.workspace_client
 
             async with streamablehttp_client(
@@ -59,20 +49,16 @@ def create_mcp_tools(
                 async with ClientSession(read_stream, write_stream) as session:
                     # Initialize and list tools
                     await session.initialize()
-                    tools = await load_mcp_tools(session)
-                    return tools
+                    return await session.list_tools()
 
         try:
-            langchain_tools = asyncio.run(_get_tools_with_connection())
-            logger.debug(
-                f"Retrieved {len(langchain_tools)} MCP tools via UC Connection"
+            mcp_tools: list[Tool] | ListToolsResult = asyncio.run(
+                _list_tools_with_connection()
             )
+            if isinstance(mcp_tools, ListToolsResult):
+                mcp_tools = mcp_tools.tools
 
-            # Wrap tools with human-in-the-loop if needed
-            wrapped_tools = [
-                as_human_in_the_loop(tool, function) for tool in langchain_tools
-            ]
-            return wrapped_tools
+            logger.debug(f"Retrieved {len(mcp_tools)} MCP tools via UC Connection")
 
         except Exception as e:
             logger.error(f"Failed to get tools from MCP server via UC Connection: {e}")
@@ -80,6 +66,39 @@ def create_mcp_tools(
                 f"Failed to list MCP tools for function '{function.name}' via UC Connection '{function.connection.name}': {e}"
             )
 
+        # Create wrapper tools with fresh session per invocation
+        def _create_tool_wrapper_with_connection(mcp_tool: Tool) -> RunnableLike:
+            @create_tool(
+                mcp_tool.name,
+                description=mcp_tool.description or f"MCP tool: {mcp_tool.name}",
+                args_schema=mcp_tool.inputSchema,
+            )
+            async def tool_wrapper(**kwargs):
+                """Execute MCP tool with fresh UC Connection session."""
+                logger.debug(
+                    f"Invoking MCP tool {mcp_tool.name} with fresh UC Connection session"
+                )
+                workspace_client = function.connection.workspace_client
+
+                try:
+                    async with streamablehttp_client(
+                        mcp_url, auth=DatabricksOAuthClientProvider(workspace_client)
+                    ) as (read_stream, write_stream, _):
+                        async with ClientSession(read_stream, write_stream) as session:
+                            await session.initialize()
+                            result = await session.call_tool(mcp_tool.name, kwargs)
+                            logger.debug(
+                                f"MCP tool {mcp_tool.name} completed successfully"
+                            )
+                            return result
+                except Exception as e:
+                    logger.error(f"MCP tool {mcp_tool.name} failed: {e}")
+                    raise
+
+            return as_human_in_the_loop(tool_wrapper, function)
+
+        return [_create_tool_wrapper_with_connection(tool) for tool in mcp_tools]
+
     else:
         # Use direct MCP connection with MultiServerMCPClient
         logger.debug("Using direct MCP connection with MultiServerMCPClient")
@@ -119,7 +138,7 @@ def create_mcp_tools(
                 logger.debug("Using existing authentication token")
 
             return {
-                "url": function.url,
+                "url": mcp_url,  # Use the resolved MCP URL
                 "transport": function.transport,
                 "headers": headers,
             }

dao_ai/tools/vector_search.py

@@ -1,10 +1,21 @@
-from typing import Any, Optional, Sequence
+from typing import Annotated, Any, Callable, List, Optional, Sequence
 
 import mlflow
-from databricks_langchain.vector_search_retriever_tool import VectorSearchRetrieverTool
-from langchain_core.tools import BaseTool
+from databricks.vector_search.reranker import DatabricksReranker
+from databricks_ai_bridge.vector_search_retriever_tool import (
+    FilterItem,
+    VectorSearchRetrieverToolInput,
+)
+from databricks_langchain.vectorstores import DatabricksVectorSearch
+from flashrank import Ranker, RerankRequest
+from langchain_core.documents import Document
+from langchain_core.tools import InjectedToolCallId, tool
+from langgraph.prebuilt import InjectedState
+from loguru import logger
+from mlflow.entities import SpanType
 
 from dao_ai.config import (
+    RerankParametersModel,
     RetrieverModel,
     VectorStoreModel,
 )
@@ -14,13 +25,13 @@ def create_vector_search_tool(
     retriever: RetrieverModel | dict[str, Any],
     name: Optional[str] = None,
     description: Optional[str] = None,
-) -> BaseTool:
+) -> Callable:
     """
     Create a Vector Search tool for retrieving documents from a Databricks Vector Search index.
 
     This function creates a tool that enables semantic search over product information,
-    documentation, or other content. It also registers the retriever schema with MLflow
-    for proper integration with the model serving infrastructure.
+    documentation, or other content using the @tool decorator pattern. It supports optional
+    reranking of results using FlashRank for improved relevance.
 
     Args:
         retriever: Configuration details for the vector search retriever, including:
@@ -32,32 +43,69 @@ def create_vector_search_tool(
             - vector_store: Dictionary with 'endpoint_name' and 'index' for vector search
             - columns: List of columns to retrieve from the vector store
             - search_parameters: Additional parameters for customizing the search behavior
+            - rerank: Optional rerank configuration for result reranking
+        name: Optional custom name for the tool
+        description: Optional custom description for the tool
 
     Returns:
-        A BaseTool instance that can perform vector search operations
+        A LangChain tool that performs vector search with optional reranking
     """
 
     if isinstance(retriever, dict):
         retriever = RetrieverModel(**retriever)
 
-    vector_store: VectorStoreModel = retriever.vector_store
+    vector_store_config: VectorStoreModel = retriever.vector_store
+
+    # Index is required for vector search
+    if vector_store_config.index is None:
+        raise ValueError("vector_store.index is required for vector search")
 
-    index_name: str = vector_store.index.full_name
-    columns: Sequence[str] = retriever.columns
+    index_name: str = vector_store_config.index.full_name
+    columns: Sequence[str] = retriever.columns or []
     search_parameters: dict[str, Any] = retriever.search_parameters.model_dump()
-    primary_key: str = vector_store.primary_key
-    doc_uri: str = vector_store.doc_uri
-    text_column: str = vector_store.embedding_source_column
-
-    vector_search_tool: BaseTool = VectorSearchRetrieverTool(
-        name=name,
-        tool_name=name,
-        description=description,
-        tool_description=description,
+    primary_key: str = vector_store_config.primary_key or ""
+    doc_uri: str = vector_store_config.doc_uri or ""
+    text_column: str = vector_store_config.embedding_source_column
+
+    # Extract reranker configuration
+    reranker_config: Optional[RerankParametersModel] = retriever.rerank
+
+    # Initialize FlashRank ranker once if reranking is enabled
+    # This is expensive (loads model weights), so we do it once and reuse across invocations
+    ranker: Optional[Ranker] = None
+    if reranker_config:
+        logger.debug(
+            f"Creating vector search tool with reranking: '{name}' "
+            f"(model: {reranker_config.model}, top_n: {reranker_config.top_n or 'auto'})"
+        )
+        try:
+            ranker = Ranker(
+                model_name=reranker_config.model, cache_dir=reranker_config.cache_dir
+            )
+            logger.info(
+                f"FlashRank ranker initialized successfully (model: {reranker_config.model})"
+            )
+        except Exception as e:
+            logger.warning(
+                f"Failed to initialize FlashRank ranker during tool creation: {e}. "
+                "Reranking will be disabled for this tool."
+            )
+            # Set reranker_config to None so we don't attempt reranking
+            reranker_config = None
+    else:
+        logger.debug(
+            f"Creating vector search tool without reranking: '{name}' (standard similarity search only)"
+        )
+
+    # Initialize the vector store
+    # Note: text_column is only required for self-managed embeddings
+    # For Databricks-managed embeddings, it's automatically determined from the index
+    vector_store: DatabricksVectorSearch = DatabricksVectorSearch(
         index_name=index_name,
+        text_column=None,  # Let DatabricksVectorSearch determine this from the index
         columns=columns,
-        **search_parameters,
-        workspace_client=vector_store.workspace_client,
+        include_score=True,
+        workspace_client=vector_store_config.workspace_client,
     )
 
     # Register the retriever schema with MLflow for model serving integration
@@ -66,7 +114,169 @@ def create_vector_search_tool(
         primary_key=primary_key,
         text_column=text_column,
         doc_uri=doc_uri,
-        other_columns=columns,
+        other_columns=list(columns),
+    )
+
+    # Helper function to perform vector similarity search
+    @mlflow.trace(name="find_documents", span_type=SpanType.RETRIEVER)
+    def _find_documents(
+        query: str, filters: Optional[List[FilterItem]] = None
+    ) -> List[Document]:
+        """Perform vector similarity search."""
+        # Convert filters to dict format
+        filters_dict: dict[str, Any] = {}
+        if filters:
+            for item in filters:
+                item_dict = dict(item)
+                filters_dict[item_dict["key"]] = item_dict["value"]
+
+        # Merge with any configured filters
+        combined_filters: dict[str, Any] = {
+            **filters_dict,
+            **search_parameters.get("filters", {}),
+        }
+
+        # Perform similarity search
+        num_results: int = search_parameters.get("num_results", 10)
+        query_type: str = search_parameters.get("query_type", "ANN")
+
+        logger.debug(
+            f"Performing vector search: query='{query[:50]}...', k={num_results}, filters={combined_filters}"
+        )
+
+        # Build similarity search kwargs
+        search_kwargs = {
+            "query": query,
+            "k": num_results,
+            "filter": combined_filters if combined_filters else None,
+            "query_type": query_type,
+        }
+
+        # Add DatabricksReranker if configured with columns
+        if reranker_config and reranker_config.columns:
+            search_kwargs["reranker"] = DatabricksReranker(
+                columns_to_rerank=reranker_config.columns
+            )
+
+        documents: List[Document] = vector_store.similarity_search(**search_kwargs)
+
+        logger.debug(f"Retrieved {len(documents)} documents from vector search")
+        return documents
+
+    # Helper function to rerank documents
+    @mlflow.trace(name="rerank_documents", span_type=SpanType.RETRIEVER)
+    def _rerank_documents(query: str, documents: List[Document]) -> List[Document]:
+        """Rerank documents using FlashRank.
+
+        Uses the ranker instance initialized at tool creation time (captured in closure).
+        This avoids expensive model loading on every invocation.
+        """
+        if not reranker_config or ranker is None:
+            return documents
+
+        logger.debug(
+            f"Starting reranking for {len(documents)} documents using model '{reranker_config.model}'"
+        )
+
+        # Prepare passages for reranking
+        passages: List[dict[str, Any]] = [
+            {"text": doc.page_content, "meta": doc.metadata} for doc in documents
+        ]
+
+        # Create reranking request
+        rerank_request: RerankRequest = RerankRequest(query=query, passages=passages)
+
+        # Perform reranking
+        logger.debug(f"Reranking {len(passages)} passages for query: '{query[:50]}...'")
+        results: List[dict[str, Any]] = ranker.rerank(rerank_request)
+
+        # Apply top_n filtering
+        top_n: int = reranker_config.top_n or len(documents)
+        results = results[:top_n]
+        logger.debug(
+            f"Reranking complete. Filtered to top {top_n} results from {len(documents)} candidates"
+        )
+
+        # Convert back to Document objects with reranking scores
+        reranked_docs: List[Document] = []
+        for result in results:
+            # Find original document by matching text
+            orig_doc: Optional[Document] = next(
+                (doc for doc in documents if doc.page_content == result["text"]), None
+            )
+            if orig_doc:
+                # Add reranking score to metadata
+                reranked_doc: Document = Document(
+                    page_content=orig_doc.page_content,
+                    metadata={
+                        **orig_doc.metadata,
+                        "reranker_score": result["score"],
+                    },
+                )
+                reranked_docs.append(reranked_doc)
+
+        logger.debug(
+            f"Reranked {len(documents)} documents → {len(reranked_docs)} results "
+            f"(model: {reranker_config.model}, top score: {reranked_docs[0].metadata.get('reranker_score', 0):.4f})"
+            if reranked_docs
+            else f"Reranking completed with {len(reranked_docs)} results"
+        )
+
+        return reranked_docs
+
+    # Create the main vector search tool using @tool decorator
+    # Note: args_schema provides descriptions for query and filters,
+    # so Annotated is only needed for injected LangGraph parameters
+    @tool(
+        name_or_callable=name or index_name,
+        description=description or "Search for documents using vector similarity",
+        args_schema=VectorSearchRetrieverToolInput,
     )
+    def vector_search_tool(
+        query: str,
+        filters: Optional[List[FilterItem]] = None,
+        state: Annotated[dict, InjectedState] = None,
+        tool_call_id: Annotated[str, InjectedToolCallId] = None,
+    ) -> list[dict[str, Any]]:
+        """
+        Search for documents using vector similarity with optional reranking.
+
+        This tool performs a two-stage retrieval process:
+        1. Vector similarity search to find candidate documents
+        2. Optional reranking using cross-encoder model for improved relevance
+
+        Both stages are traced in MLflow for observability.
+
+        Returns:
+            Command with ToolMessage containing the retrieved documents
+        """
+        logger.debug(
+            f"Vector search tool called: query='{query[:50]}...', reranking={reranker_config is not None}"
+        )
+
+        # Step 1: Perform vector similarity search
+        documents: List[Document] = _find_documents(query, filters)
+
+        # Step 2: If reranking is enabled, rerank the documents
+        if reranker_config:
+            logger.debug(
+                f"Reranking enabled (model: '{reranker_config.model}', top_n: {reranker_config.top_n or 'all'})"
+            )
+            documents = _rerank_documents(query, documents)
+            logger.debug(f"Returning {len(documents)} reranked documents")
+        else:
+            logger.debug("Reranking disabled, returning original vector search results")
+
+        # Return Command with ToolMessage containing the documents
+        # Serialize documents to dicts for proper ToolMessage handling
+        serialized_docs: list[dict[str, Any]] = [
+            {
+                "page_content": doc.page_content,
+                "metadata": doc.metadata,
+            }
+            for doc in documents
+        ]
+
+        return serialized_docs
 
     return vector_search_tool

dao_ai/utils.py

@@ -3,7 +3,8 @@ import importlib.metadata
 import os
 import re
 import site
-from importlib.metadata import version
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
 from typing import Any, Callable, Sequence
 
 from loguru import logger
@@ -37,6 +38,59 @@ def normalize_name(name: str) -> str:
     return normalized.strip("_")
 
 
+def dao_ai_version() -> str:
+    """
+    Get the dao-ai package version, with fallback for source installations.
+
+    Tries to get the version from installed package metadata first. If the package
+    is not installed (e.g., running from source), falls back to reading from
+    pyproject.toml. Returns "dev" if neither method works.
+
+    Returns:
+        str: The version string, or "dev" if version cannot be determined
+    """
+    try:
+        # Try to get version from installed package metadata
+        return version("dao-ai")
+    except PackageNotFoundError:
+        # Package not installed, try reading from pyproject.toml
+        logger.debug(
+            "dao-ai package not installed, attempting to read version from pyproject.toml"
+        )
+        try:
+            import tomllib  # Python 3.11+
+        except ImportError:
+            try:
+                import tomli as tomllib  # Fallback for Python < 3.11
+            except ImportError:
+                logger.warning(
+                    "Cannot determine dao-ai version: package not installed and tomllib/tomli not available"
+                )
+                return "dev"
+
+        try:
+            # Find pyproject.toml relative to this file
+            project_root = Path(__file__).parents[2]
+            pyproject_path = project_root / "pyproject.toml"
+
+            if not pyproject_path.exists():
+                logger.warning(
+                    f"Cannot determine dao-ai version: pyproject.toml not found at {pyproject_path}"
+                )
+                return "dev"
+
+            with open(pyproject_path, "rb") as f:
+                pyproject_data = tomllib.load(f)
+                pkg_version = pyproject_data.get("project", {}).get("version", "dev")
+                logger.debug(
+                    f"Read version {pkg_version} from pyproject.toml at {pyproject_path}"
+                )
+                return pkg_version
+        except Exception as e:
+            logger.warning(f"Cannot determine dao-ai version from pyproject.toml: {e}")
+            return "dev"
+
+
 def get_installed_packages() -> dict[str, str]:
     """Get all installed packages with versions"""
 
@@ -46,6 +100,7 @@ def get_installed_packages() -> dict[str, str]:
         f"databricks-mcp=={version('databricks-mcp')}",
         f"databricks-sdk[openai]=={version('databricks-sdk')}",
         f"duckduckgo-search=={version('duckduckgo-search')}",
+        f"flashrank=={version('flashrank')}",
         f"langchain=={version('langchain')}",
         f"langchain-mcp-adapters=={version('langchain-mcp-adapters')}",
         f"langchain-openai=={version('langchain-openai')}",
@@ -65,6 +120,7 @@ def get_installed_packages() -> dict[str, str]:
         f"psycopg[binary,pool]=={version('psycopg')}",
         f"pydantic=={version('pydantic')}",
         f"pyyaml=={version('pyyaml')}",
+        f"tomli=={version('tomli')}",
         f"unitycatalog-ai[databricks]=={version('unitycatalog-ai')}",
         f"unitycatalog-langchain[databricks]=={version('unitycatalog-langchain')}",
     ]

{dao_ai-0.0.25.dist-info → dao_ai-0.0.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.0.25
+Version: 0.0.28
 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
@@ -29,6 +29,8 @@ Requires-Dist: databricks-langchain>=0.8.1
 Requires-Dist: databricks-mcp>=0.3.0
 Requires-Dist: databricks-sdk[openai]>=0.67.0
 Requires-Dist: duckduckgo-search>=8.0.2
+Requires-Dist: flashrank>=0.2.8
+Requires-Dist: gepa>=0.0.17
 Requires-Dist: grandalf>=0.8
 Requires-Dist: langchain-mcp-adapters>=0.1.10
 Requires-Dist: langchain-tavily>=0.2.11
@@ -40,7 +42,7 @@ Requires-Dist: langgraph>=0.6.10
 Requires-Dist: langmem>=0.0.29
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp>=1.17.0
-Requires-Dist: mlflow>=3.4.0
+Requires-Dist: mlflow>=3.5.1
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: openevals>=0.0.19
 Requires-Dist: openpyxl>=3.1.5
@@ -51,10 +53,11 @@ Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.0.0
 Requires-Dist: scipy<=1.15
 Requires-Dist: sqlparse>=0.5.3
+Requires-Dist: tomli>=2.3.0
 Requires-Dist: unitycatalog-ai[databricks]>=0.3.0
 Provides-Extra: databricks
 Requires-Dist: databricks-connect>=15.0.0; extra == 'databricks'
-Requires-Dist: databricks-vectorsearch>=0.56; extra == 'databricks'
+Requires-Dist: databricks-vectorsearch>=0.63; extra == 'databricks'
 Requires-Dist: pyspark>=3.5.0; extra == 'databricks'
 Provides-Extra: dev
 Requires-Dist: mypy>=1.0.0; extra == 'dev'

{dao_ai-0.0.25.dist-info → dao_ai-0.0.28.dist-info}/RECORD

@@ -1,18 +1,18 @@
 dao_ai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/agent_as_code.py,sha256=kPSeDz2-1jRaed1TMs4LA3VECoyqe9_Ed2beRLB9gXQ,472
+dao_ai/agent_as_code.py,sha256=sviZQV7ZPxE5zkZ9jAbfegI681nra5i8yYxw05e3X7U,552
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
 dao_ai/chat_models.py,sha256=uhwwOTeLyHWqoTTgHrs4n5iSyTwe4EQcLKnh3jRxPWI,8626
 dao_ai/cli.py,sha256=gq-nsapWxDA1M6Jua3vajBvIwf0Oa6YLcB58lEtMKUo,22503
-dao_ai/config.py,sha256=_4OyJ1x7DH1S-5-FTJp7geeOf2H096PQHVFUBtALKsU,56795
-dao_ai/graph.py,sha256=APYc2y3cig4P52X4sOHSFSZNK8j5EtEPJLFwWeJ3KQQ,7956
+dao_ai/config.py,sha256=qqBdYV-ElIMYDKzY4lBejyJ6ysmwnBkqyGMWRBwWGVo,72507
+dao_ai/graph.py,sha256=9kjJx0oFZKq5J9-Kpri4-0VCJILHYdYyhqQnj0_noxQ,8913
 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
-dao_ai/nodes.py,sha256=SSuFNTXOdFaKg_aX-yUkQO7fM9wvNGu14lPXKDapU1U,8461
+dao_ai/nodes.py,sha256=iQ_5vL6mt1UcRnhwgz-l1D8Ww4CMQrSMVnP_Lu7fFjU,8781
 dao_ai/prompts.py,sha256=7Hcstmv514P0s9s-TVoIlbkDV2XXOphGCW6gcPeyUYE,1628
 dao_ai/state.py,sha256=_lF9krAYYjvFDMUwZzVKOn0ZnXKcOrbjWKdre0C5B54,1137
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/utils.py,sha256=yXgqHrYdO5qDxgxUs2G5XJeLFgwg8D0BIJvbFkqSbhs,4519
+dao_ai/utils.py,sha256=4FV9y0EVn0tmxfkn4EdUAkOewoAF_T0pHDAHe6hJx-M,6708
 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
@@ -22,20 +22,20 @@ 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=1BPYQxi4-Z4I1ygZYlKV8ycdxZTtWNXplySToayHCEI,43096
+dao_ai/providers/databricks.py,sha256=W_lXSMbPTULMAx-KW7zBJfP7LtkcPGRnEfGcSYuu708,65824
 dao_ai/tools/__init__.py,sha256=G5-5Yi6zpQOH53b5IzLdtsC6g0Ep6leI5GxgxOmgw7Q,1203
 dao_ai/tools/agent.py,sha256=WbQnyziiT12TLMrA7xK0VuOU029tdmUBXbUl-R1VZ0Q,1886
 dao_ai/tools/core.py,sha256=Kei33S8vrmvPOAyrFNekaWmV2jqZ-IPS1QDSvU7RZF0,1984
-dao_ai/tools/genie.py,sha256=8HSOCzSg6PlBzBYXMmNfUnl-LO03p3Ki3fxLPm_dhPg,15051
+dao_ai/tools/genie.py,sha256=R9Vl72s6NUtfTrQcdfhNtJFOw-BrKs_5JGt-3dAQGjA,15034
 dao_ai/tools/human_in_the_loop.py,sha256=yk35MO9eNETnYFH-sqlgR-G24TrEgXpJlnZUustsLkI,3681
-dao_ai/tools/mcp.py,sha256=CYv59yn-LIY11atUgNtN2W6vR7C6Qyo7-rvPcVJnXVk,7461
+dao_ai/tools/mcp.py,sha256=5aQoRtx2z4xm6zgRslc78rSfEQe-mfhqov2NsiybYfc,8416
 dao_ai/tools/python.py,sha256=XcQiTMshZyLUTVR5peB3vqsoUoAAy8gol9_pcrhddfI,1831
 dao_ai/tools/slack.py,sha256=SCvyVcD9Pv_XXPXePE_fSU1Pd8VLTEkKDLvoGTZWy2Y,4775
 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.25.dist-info/METADATA,sha256=ahAblBSty81iw_mlf9blqOF4-AKN5Asak9SWH0H4FIs,42639
-dao_ai-0.0.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-dao_ai-0.0.25.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.0.25.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.0.25.dist-info/RECORD,,
+dao_ai/tools/vector_search.py,sha256=h6yCgEtOA3h-anJG0hGB3VvcmC3Os7_qnhz8xxRjv1E,11346
+dao_ai-0.0.28.dist-info/METADATA,sha256=xVgC8iAxjfXmuRz_FzITQTXgZgbTcmEBAiY-DYvGWSk,42727
+dao_ai-0.0.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.0.28.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.0.28.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.0.28.dist-info/RECORD,,

{dao_ai-0.0.25.dist-info → dao_ai-0.0.28.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any