dao-ai 0.1.2__py3-none-any.whl → 0.1.5__py3-none-any.whl

dao_ai/middleware/summarization.py

@@ -150,7 +150,7 @@ def create_summarization_middleware(
         chat_history: ChatHistoryModel configuration for summarization
 
     Returns:
-        LoggingSummarizationMiddleware configured with the specified parameters
+        List containing LoggingSummarizationMiddleware configured with the specified parameters
 
     Example:
         from dao_ai.config import ChatHistoryModel, LLMModel

dao_ai/middleware/tool_call_limit.py

@@ -0,0 +1,210 @@
+"""
+Tool call limit middleware for DAO AI agents.
+
+This module provides a factory for creating LangChain's ToolCallLimitMiddleware
+from DAO AI configuration.
+
+Example:
+    from dao_ai.middleware import create_tool_call_limit_middleware
+
+    # Global limit across all tools
+    middleware = create_tool_call_limit_middleware(
+        thread_limit=20,
+        run_limit=10,
+    )
+
+    # Limit specific tool by name
+    search_limiter = create_tool_call_limit_middleware(
+        tool="search_web",
+        run_limit=3,
+        exit_behavior="continue",
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Literal
+
+from langchain.agents.middleware import ToolCallLimitMiddleware
+from langchain_core.tools import BaseTool
+from loguru import logger
+
+from dao_ai.config import BaseFunctionModel, ToolModel
+
+__all__ = [
+    "ToolCallLimitMiddleware",
+    "create_tool_call_limit_middleware",
+]
+
+
+def _resolve_tool(tool: str | ToolModel | dict[str, Any]) -> list[str]:
+    """
+    Resolve tool argument to a list of actual tool names.
+
+    Args:
+        tool: String name, ToolModel, or dict to resolve
+
+    Returns:
+        List of tool name strings
+
+    Raises:
+        ValueError: If dict cannot be converted to ToolModel
+        TypeError: If tool is not a supported type
+    """
+    # String: return as single-item list
+    if isinstance(tool, str):
+        return [tool]
+
+    # Dict: convert to ToolModel first
+    if isinstance(tool, dict):
+        try:
+            tool_model = ToolModel(**tool)
+        except Exception as e:
+            raise ValueError(
+                f"Failed to construct ToolModel from dict: {e}\n"
+                f"Dict must have 'name' and 'function' keys."
+            ) from e
+    elif isinstance(tool, ToolModel):
+        tool_model = tool
+    else:
+        raise TypeError(
+            f"tool must be str, ToolModel, or dict, got {type(tool).__name__}"
+        )
+
+    # Extract tool names from ToolModel
+    return _extract_tool_names(tool_model)
+
+
+def _extract_tool_names(tool_model: ToolModel) -> list[str]:
+    """
+    Extract actual tool names from a ToolModel.
+
+    A single ToolModel can produce multiple tools (e.g., UC functions).
+    Falls back to ToolModel.name if extraction fails.
+    """
+    function = tool_model.function
+
+    # String function references can't be introspected
+    if not isinstance(function, BaseFunctionModel):
+        logger.debug(
+            "Cannot extract names from string function, using ToolModel.name",
+            tool_model_name=tool_model.name,
+        )
+        return [tool_model.name]
+
+    # Try to extract names from created tools
+    try:
+        tool_names = [
+            tool.name
+            for tool in function.as_tools()
+            if isinstance(tool, BaseTool) and tool.name
+        ]
+        if tool_names:
+            logger.trace(
+                "Extracted tool names",
+                tool_model_name=tool_model.name,
+                tool_names=tool_names,
+            )
+            return tool_names
+    except Exception as e:
+        logger.warning(
+            "Error extracting tool names from ToolModel",
+            tool_model_name=tool_model.name,
+            error=str(e),
+        )
+
+    # Fallback to ToolModel.name
+    logger.debug(
+        "Falling back to ToolModel.name",
+        tool_model_name=tool_model.name,
+    )
+    return [tool_model.name]
+
+
+def create_tool_call_limit_middleware(
+    tool: str | ToolModel | dict[str, Any] | None = None,
+    thread_limit: int | None = None,
+    run_limit: int | None = None,
+    exit_behavior: Literal["continue", "error", "end"] = "continue",
+) -> ToolCallLimitMiddleware:
+    """
+    Create a ToolCallLimitMiddleware with graceful termination support.
+
+    Factory for LangChain's ToolCallLimitMiddleware that supports DAO AI
+    configuration types.
+
+    Args:
+        tool: Tool to limit. Can be:
+            - None: Global limit on all tools
+            - str: Limit specific tool by name
+            - ToolModel: Limit tool(s) from DAO AI config
+            - dict: Tool config dict (converted to ToolModel)
+        thread_limit: Max calls per thread (conversation). Requires checkpointer.
+        run_limit: Max calls per run (single invocation).
+        exit_behavior: What to do when limit hit:
+            - "continue": Block tool with error message, let agent continue
+            - "error": Raise ToolCallLimitExceededError immediately
+            - "end": Stop execution gracefully (single-tool only)
+
+    Returns:
+        A ToolCallLimitMiddleware instance. If ToolModel produces multiple tools,
+        only the first tool is used (with a warning logged).
+
+    Raises:
+        ValueError: If no limits specified, or invalid dict
+        TypeError: If tool is unsupported type
+
+    Example:
+        # Global limit
+        limiter = create_tool_call_limit_middleware(run_limit=10)
+
+        # Tool-specific limit
+        limiter = create_tool_call_limit_middleware(
+            tool="search_web",
+            run_limit=3,
+            exit_behavior="continue",
+        )
+    """
+    if thread_limit is None and run_limit is None:
+        raise ValueError("At least one of thread_limit or run_limit must be specified.")
+
+    # Global limit: no tool parameter
+    if tool is None:
+        logger.debug(
+            "Creating global tool call limit",
+            thread_limit=thread_limit,
+            run_limit=run_limit,
+            exit_behavior=exit_behavior,
+        )
+        return ToolCallLimitMiddleware(
+            thread_limit=thread_limit,
+            run_limit=run_limit,
+            exit_behavior=exit_behavior,
+        )
+
+    # Resolve to list of tool names
+    names = _resolve_tool(tool)
+
+    # Use first tool name (warn if multiple)
+    tool_name = names[0]
+    if len(names) > 1:
+        logger.warning(
+            "ToolModel resolved to multiple tool names, using first only",
+            tool_names=names,
+            using=tool_name,
+        )
+
+    logger.debug(
+        "Creating tool call limit middleware",
+        tool_name=tool_name,
+        thread_limit=thread_limit,
+        run_limit=run_limit,
+        exit_behavior=exit_behavior,
+    )
+
+    return ToolCallLimitMiddleware(
+        tool_name=tool_name,
+        thread_limit=thread_limit,
+        run_limit=run_limit,
+        exit_behavior=exit_behavior,
+    )

dao_ai/middleware/tool_retry.py

@@ -0,0 +1,174 @@
+"""
+Tool retry middleware for DAO AI agents.
+
+Automatically retries failed tool calls with configurable exponential backoff.
+
+Example:
+    from dao_ai.middleware import create_tool_retry_middleware
+
+    # Retry failed tool calls with exponential backoff
+    middleware = create_tool_retry_middleware(
+        max_retries=3,
+        backoff_factor=2.0,
+        initial_delay=1.0,
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Literal
+
+from langchain.agents.middleware import ToolRetryMiddleware
+from langchain_core.tools import BaseTool
+from loguru import logger
+
+from dao_ai.config import BaseFunctionModel, ToolModel
+
+__all__ = [
+    "ToolRetryMiddleware",
+    "create_tool_retry_middleware",
+]
+
+
+def _resolve_tools(
+    tools: list[str | ToolModel | dict[str, Any]] | None,
+) -> list[str] | None:
+    """
+    Resolve tool specs to a list of tool name strings.
+
+    Returns None if tools is None (apply to all tools).
+    """
+    if tools is None:
+        return None
+
+    result: list[str] = []
+    for tool in tools:
+        if isinstance(tool, str):
+            result.append(tool)
+        elif isinstance(tool, dict):
+            try:
+                tool_model = ToolModel(**tool)
+                result.extend(_extract_tool_names(tool_model))
+            except Exception as e:
+                raise ValueError(f"Failed to construct ToolModel from dict: {e}") from e
+        elif isinstance(tool, ToolModel):
+            result.extend(_extract_tool_names(tool))
+        else:
+            raise TypeError(
+                f"Tool must be str, ToolModel, or dict, got {type(tool).__name__}"
+            )
+
+    return result if result else None
+
+
+def _extract_tool_names(tool_model: ToolModel) -> list[str]:
+    """Extract tool names from ToolModel, falling back to ToolModel.name."""
+    function = tool_model.function
+
+    if not isinstance(function, BaseFunctionModel):
+        return [tool_model.name]
+
+    try:
+        tool_names = [
+            tool.name
+            for tool in function.as_tools()
+            if isinstance(tool, BaseTool) and tool.name
+        ]
+        return tool_names if tool_names else [tool_model.name]
+    except Exception:
+        return [tool_model.name]
+
+
+def create_tool_retry_middleware(
+    max_retries: int = 3,
+    backoff_factor: float = 2.0,
+    initial_delay: float = 1.0,
+    max_delay: float | None = None,
+    jitter: bool = False,
+    tools: list[str | ToolModel | dict[str, Any]] | None = None,
+    retry_on: tuple[type[Exception], ...] | Callable[[Exception], bool] | None = None,
+    on_failure: Literal["continue", "error"] | Callable[[Exception], str] = "continue",
+) -> ToolRetryMiddleware:
+    """
+    Create a ToolRetryMiddleware for automatic tool call retries.
+
+    Handles transient failures in external API calls with exponential backoff.
+
+    Args:
+        max_retries: Max retry attempts after initial call. Default 3.
+        backoff_factor: Multiplier for exponential backoff. Default 2.0.
+            Delay = initial_delay * (backoff_factor ** retry_number)
+            Set to 0.0 for constant delay.
+        initial_delay: Initial delay in seconds before first retry. Default 1.0.
+        max_delay: Max delay in seconds (caps exponential growth). None = no cap.
+        jitter: Add ±25% random jitter to avoid thundering herd. Default False.
+        tools: List of tools to apply retry to. Can be:
+            - None: Apply to all tools (default)
+            - list of str: Tool names
+            - list of ToolModel: DAO AI tool models
+            - list of dict: Tool config dicts
+        retry_on: When to retry:
+            - None: Retry on all errors (default)
+            - tuple of Exception types: Retry only on these
+            - callable: Function(exception) -> bool
+        on_failure: Behavior when all retries exhausted:
+            - "continue": Return error message, let agent continue (default)
+            - "error": Re-raise exception, stop execution
+            - callable: Function(exception) -> str for custom message
+
+    Returns:
+        List containing ToolRetryMiddleware instance
+
+    Example:
+        # Basic retry with defaults
+        retry = create_tool_retry_middleware()
+
+        # Retry specific tools with custom backoff
+        retry = create_tool_retry_middleware(
+            max_retries=5,
+            backoff_factor=1.5,
+            initial_delay=0.5,
+            tools=["search_web", "query_database"],
+        )
+
+        # Retry only on specific exceptions
+        retry = create_tool_retry_middleware(
+            max_retries=3,
+            retry_on=(TimeoutError, ConnectionError),
+            on_failure="error",
+        )
+    """
+    tool_names = _resolve_tools(tools)
+
+    logger.debug(
+        "Creating tool retry middleware",
+        max_retries=max_retries,
+        backoff_factor=backoff_factor,
+        initial_delay=initial_delay,
+        max_delay=max_delay,
+        jitter=jitter,
+        tools=tool_names or "all",
+        on_failure=on_failure if isinstance(on_failure, str) else "custom",
+    )
+
+    # Build kwargs
+    kwargs: dict[str, Any] = {
+        "max_retries": max_retries,
+        "backoff_factor": backoff_factor,
+        "initial_delay": initial_delay,
+        "on_failure": on_failure,
+    }
+
+    if tool_names is not None:
+        kwargs["tools"] = tool_names
+
+    if max_delay is not None:
+        kwargs["max_delay"] = max_delay
+
+    if jitter:
+        kwargs["jitter"] = jitter
+
+    if retry_on is not None:
+        kwargs["retry_on"] = retry_on
+
+    return ToolRetryMiddleware(**kwargs)

dao_ai/nodes.py

@@ -26,11 +26,9 @@ from dao_ai.config import (
 from dao_ai.middleware.core import create_factory_middleware
 from dao_ai.middleware.guardrails import GuardrailMiddleware
 from dao_ai.middleware.human_in_the_loop import (
-    HumanInTheLoopMiddleware,
     create_hitl_middleware_from_tool_models,
 )
 from dao_ai.middleware.summarization import (
-    LoggingSummarizationMiddleware,
     create_summarization_middleware,
 )
 from dao_ai.prompts import make_prompt
@@ -78,8 +76,7 @@ def _create_middleware_list(
             function_name=middleware_config.name,
             args=middleware_config.args,
         )
-        if middleware is not None:
-            middleware_list.append(middleware)
+        middleware_list.append(middleware)
 
     # Add guardrails as middleware
     if agent.guardrails:
@@ -117,16 +114,12 @@ def _create_middleware_list(
             max_tokens=chat_history.max_tokens,
             summary_model=chat_history.model.name,
         )
-        summarization_middleware: LoggingSummarizationMiddleware = (
-            create_summarization_middleware(chat_history)
-        )
+        summarization_middleware = create_summarization_middleware(chat_history)
         middleware_list.append(summarization_middleware)
 
     # Add human-in-the-loop middleware if any tools require it
-    hitl_middleware: HumanInTheLoopMiddleware | None = (
-        create_hitl_middleware_from_tool_models(tool_models)
-    )
-    if hitl_middleware is not None:
+    hitl_middlewares = create_hitl_middleware_from_tool_models(tool_models)
+    if hitl_middlewares:
         # Log which tools require HITL
         hitl_tool_names: list[str] = [
             tool.name
@@ -139,7 +132,7 @@ def _create_middleware_list(
             agent=agent.name,
             hitl_tools=hitl_tool_names,
         )
-        middleware_list.append(hitl_middleware)
+        middleware_list.append(hitl_middlewares)
 
     logger.info(
         "Middleware summary",

dao_ai/orchestration/supervisor.py

@@ -190,6 +190,7 @@ def create_supervisor_graph(config: AppConfig) -> CompiledStateGraph:
     supervisor_tools: list[BaseTool] = list(create_tools(supervisor_config.tools))
 
     # Create middleware from configuration
+    # All middleware factories return list[AgentMiddleware] for composability
     middlewares: list[AgentMiddleware] = []
 
     for middleware_config in supervisor_config.middleware:
@@ -201,11 +202,11 @@ def create_supervisor_graph(config: AppConfig) -> CompiledStateGraph:
             function_name=middleware_config.name,
             args=middleware_config.args,
         )
-        if middleware is not None:
-            middlewares.append(middleware)
-            logger.debug(
-                "Created supervisor middleware", middleware=middleware_config.name
-            )
+        middlewares.append(middleware)
+        logger.debug(
+            "Created supervisor middleware",
+            middleware=middleware_config.name,
+        )
 
     # Set up memory store and checkpointer
     store: BaseStore | None = create_store(orchestration)

dao_ai/providers/databricks.py

@@ -625,6 +625,17 @@ class DatabricksProvider(ServiceProvider):
                 df.write.mode("overwrite").saveAsTable(table)
 
     def create_vector_store(self, vector_store: VectorStoreModel) -> None:
+        """
+        Create a vector search index from a source table.
+
+        This method expects a VectorStoreModel in provisioning mode with all
+        required fields validated. Use VectorStoreModel.create() which handles
+        mode detection and validation.
+
+        Args:
+            vector_store: VectorStoreModel configured for provisioning
+        """
+        # Ensure endpoint exists
         if not endpoint_exists(self.vsc, vector_store.endpoint.name):
             self.vsc.create_endpoint_and_wait(
                 name=vector_store.endpoint.name,

dao_ai/vector_search.py

@@ -72,3 +72,40 @@ def index_exists(
             raise e
     # If we reach here, the index doesn't exist
     return False
+
+
+def find_index(
+    vsc: VectorSearchClient, index_full_name: str
+) -> tuple[bool, str | None]:
+    """
+    Find a Vector Search index across all endpoints.
+
+    Searches all available endpoints to find where the index is located.
+
+    Args:
+        vsc: Databricks Vector Search client instance
+        index_full_name: Fully qualified name of the index (catalog.schema.index)
+
+    Returns:
+        Tuple of (exists: bool, endpoint_name: str | None)
+        - (True, endpoint_name) if index is found
+        - (False, None) if index is not found on any endpoint
+    """
+    try:
+        endpoints = vsc.list_endpoints().get("endpoints", [])
+    except Exception as e:
+        if "REQUEST_LIMIT_EXCEEDED" in str(e):
+            print("WARN: couldn't list endpoints due to REQUEST_LIMIT_EXCEEDED error.")
+            return (False, None)
+        raise e
+
+    for endpoint in endpoints:
+        endpoint_name: str = endpoint["name"]
+        try:
+            vsc.get_index(endpoint_name, index_full_name).describe()
+            return (True, endpoint_name)
+        except Exception:
+            # Index not on this endpoint, try next
+            continue
+
+    return (False, None)

{dao_ai-0.1.2.dist-info → dao_ai-0.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.2
+Version: 0.1.5
 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
@@ -79,7 +79,7 @@ Description-Content-Type: text/markdown
 
 # DAO: Declarative Agent Orchestration
 
-[![Version](https://img.shields.io/badge/version-0.1.0-blue.svg)](CHANGELOG.md)
+[![Version](https://img.shields.io/badge/version-0.1.2-blue.svg)](CHANGELOG.md)
 [![Python](https://img.shields.io/badge/python-3.11+-green.svg)](https://www.python.org/)
 [![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
 
@@ -293,6 +293,16 @@ This single command:
 3. Deploys it to Databricks
 4. Creates a serving endpoint
 
+**Deploying to a specific workspace:**
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile aws-field-eng
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy --run -c config/my_agent.yaml --profile azure-retail
+```
+
 **Step 5: Interact with your agent**
 
 Once deployed, you can chat with your agent using Python:
@@ -422,10 +432,34 @@ dao-ai graph -c config/my_config.yaml -o workflow.png
 # Deploy with Databricks Asset Bundles
 dao-ai bundle --deploy --run -c config/my_config.yaml
 
+# Deploy to a specific workspace (multi-cloud support)
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-field-eng
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-retail
+
 # Interactive chat with agent
 dao-ai chat -c config/my_config.yaml
 ```
 
+### Multi-Cloud Deployment
+
+DAO AI supports deploying to Azure, AWS, and GCP workspaces with automatic cloud detection:
+
+```bash
+# Deploy to AWS workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile aws-prod
+
+# Deploy to Azure workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile azure-prod
+
+# Deploy to GCP workspace
+dao-ai bundle --deploy -c config/my_config.yaml --profile gcp-prod
+```
+
+The CLI automatically:
+- Detects the cloud provider from your profile's workspace URL
+- Selects appropriate compute node types for each cloud
+- Creates isolated deployment state per profile
+
 👉 **Learn more:** [CLI Reference Documentation](docs/cli-reference.md)
 
 ---

{dao_ai-0.1.2.dist-info → dao_ai-0.1.5.dist-info}/RECORD

@@ -1,19 +1,19 @@
 dao_ai/__init__.py,sha256=18P98ExEgUaJ1Byw440Ct1ty59v6nxyWtc5S6Uq2m9Q,1062
 dao_ai/agent_as_code.py,sha256=xIlLDpPVfmDVzLvbdY_V_CrC4Jvj2ItCWJ-NzdrszTo,538
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
-dao_ai/cli.py,sha256=azkzrG0RCKyb_euXsmiLCMXWtz7n-8KMNG-45pufqUg,32655
-dao_ai/config.py,sha256=o8BYHB-9R3PVWP0rtGAVrge3CHQqqnIZgfUl_awNPTU,117044
+dao_ai/cli.py,sha256=FWzddUceOoER2EIMwBx_mIMhCWFFZHoAL3KHy7f0Euc,35377
+dao_ai/config.py,sha256=GWBmrbiixMG0ZszLk_XTRKRIS0QqOk_TIQhauK--MIY,120863
 dao_ai/graph.py,sha256=1-uQlo7iXZQTT3uU8aYu0N5rnhw5_g_2YLwVsAs6M-U,1119
 dao_ai/logging.py,sha256=lYy4BmucCHvwW7aI3YQkQXKJtMvtTnPDu9Hnd7_O4oc,1556
 dao_ai/messages.py,sha256=4ZBzO4iFdktGSLrmhHzFjzMIt2tpaL-aQLHOQJysGnY,6959
 dao_ai/models.py,sha256=AwzwTRTNZF-UOh59HsuXEgFk_YH6q6M-mERNDe64Z8k,81783
-dao_ai/nodes.py,sha256=uI2L_icOAB1xYWSOx7W5QBbTxnvrt16hpQJKuSRAqos,10996
+dao_ai/nodes.py,sha256=7W6Ek6Uk9-pKa-H06nVCwuDllCrgX02IYy3rHtuL0aM,10777
 dao_ai/optimization.py,sha256=phK6t4wYmWPObCjGUBHdZzsaFXGhQOjhAek2bAEfwXo,22971
 dao_ai/prompts.py,sha256=G0ng5f2PkzfgdKrSl03Rnd6riZn5APedof0GAzsWQI8,4792
 dao_ai/state.py,sha256=0wbbzfQmldkCu26gdTE5j0Rl-_pfilza-YIHPbSWlvI,6394
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dao_ai/utils.py,sha256=_Urd7Nj2VzrgPKf3NS4E6vt0lWRhEUddBqWN9BksqeE,11543
-dao_ai/vector_search.py,sha256=jlaFS_iizJ55wblgzZmswMM3UOL-qOp2BGJc0JqXYSg,2839
+dao_ai/vector_search.py,sha256=8d3xROg9zSIYNXjRRl6rSexsJTlufjRl5Fy1ZA8daKA,4019
 dao_ai/genie/__init__.py,sha256=vdEyGhrt6L8GlK75SyYvTnl8QpHKDCJC5hJKLg4DesQ,1063
 dao_ai/genie/core.py,sha256=HPKbocvhnnw_PkQwfoq5bpgQmL9lZyyS6_goTJL8yiY,1073
 dao_ai/genie/cache/__init__.py,sha256=JfgCJl1NYQ1aZvZ4kly4T6uQK6ZCJ6PX_htuq7nJF50,1203
@@ -28,21 +28,27 @@ dao_ai/memory/base.py,sha256=99nfr2UZJ4jmfTL_KrqUlRSCoRxzkZyWyx5WqeUoMdQ,338
 dao_ai/memory/core.py,sha256=38H-JLIyUrRDIECLvpXK3iJlWG35X97E-DTo_4c3Jzc,6317
 dao_ai/memory/databricks.py,sha256=SM6nwLjhSRJO4hLc3GUuht5YydYtTi3BAOae6jPwTm4,14377
 dao_ai/memory/postgres.py,sha256=q9IIAGs0wuaV-3rUIn4dtzOxbkCCoB-yv1Rtod7ohjI,16467
-dao_ai/middleware/__init__.py,sha256=epSCtCtttIogl21nVK768Ln35L0mOShVczyURtR6Ln8,3609
-dao_ai/middleware/assertions.py,sha256=VmTBhHKulcDwicEP9IB3_HyI4hDhmq3ZP_85InGgvCc,27360
+dao_ai/middleware/__init__.py,sha256=scEk9Mt9POJe-j9e9t5sf3FNMNPBsu15_oxrlV9IkVE,4871
+dao_ai/middleware/assertions.py,sha256=C1K-TnNZfBEwWouioHCt6c48i1ux9QKfQaX6AzghhgE,27408
 dao_ai/middleware/base.py,sha256=uG2tpdnjL5xY5jCKvb_m3UTBtl4ZC6fJQUkDsQvV8S4,1279
-dao_ai/middleware/core.py,sha256=rRPwNCBAj40lbZK08hdzP9utrqaHl3l520jgBOwI_Z4,2124
-dao_ai/middleware/guardrails.py,sha256=qM_V0fb1fa2iuKGy_nmOvVrOP72UiPtKgrfSqxngQUc,13975
-dao_ai/middleware/human_in_the_loop.py,sha256=Ylmiqo17dOKsUDhbD103tnknGcidVX0Joy7WPlodo78,7491
-dao_ai/middleware/message_validation.py,sha256=evdfozSd2rsEARTrKaYAqNWhZCtgrnFAi6YudvT54qQ,19754
-dao_ai/middleware/summarization.py,sha256=moqcR27vEeMc7uN_OJoStOFSEFQu-GqvjH933b3DTPE,7127
+dao_ai/middleware/context_editing.py,sha256=5rNKqH1phFFQTVW-4nzlVH5cbqomD-HFEIy2Z841D4I,7687
+dao_ai/middleware/core.py,sha256=XFzL-A1_jS_pUCw7Q-z1WD0gutmpWZhfCMqHI6ifbhA,2096
+dao_ai/middleware/guardrails.py,sha256=wjH4OwDRagkrKpcGNf7_bf3eJhtMpIWK_RIrrvMeqDs,14023
+dao_ai/middleware/human_in_the_loop.py,sha256=YS11oQcRVzHVuZi309tuXfB4ItGuOz-PRT0fXwupdsY,7537
+dao_ai/middleware/message_validation.py,sha256=SGvXow76BB1eW8zDSSuLJgRkIvLU-WOwA1Cd5_DatmQ,19818
+dao_ai/middleware/model_call_limit.py,sha256=sxv15iNOUMjVLTEXwMBR5zAkxkWbnysbSIsBcuJbNUI,2216
+dao_ai/middleware/model_retry.py,sha256=SlWjAcaEmvj6KBOkjUicChYjhlg7bAJM7-e6KLpHS9Q,3908
+dao_ai/middleware/pii.py,sha256=zetfoz1WlJ-V0vjJp37v8NGimXB27EkZfetUHpGCXno,5137
+dao_ai/middleware/summarization.py,sha256=gp2s9uc4DEJat-mWjWEzMaR-zAAeUOXYvu5EEYtqae4,7143
+dao_ai/middleware/tool_call_limit.py,sha256=WQ3NmA3pLo-pNPBmwM7KwkYpT1segEnWqkhgW1xNkCE,6321
+dao_ai/middleware/tool_retry.py,sha256=QfJ7yTHneME8VtnA88QcmnjXIegSFeJztyngy49wTgM,5568
 dao_ai/orchestration/__init__.py,sha256=i85CLfRR335NcCFhaXABcMkn6WZfXnJ8cHH4YZsZN0s,1622
 dao_ai/orchestration/core.py,sha256=qoU7uMXBJCth-sqfu0jRE1L0GOn5H4LoZdRUY1Ib3DI,9585
-dao_ai/orchestration/supervisor.py,sha256=0aQLL1a3oBjG9LYTuV1y73rB0mqkIkax7MwtZ7xx_pE,9833
+dao_ai/orchestration/supervisor.py,sha256=alKMEEo9G5LhdpMvTVdAMel234cZj5_MguWl4wFB7XQ,9873
 dao_ai/orchestration/swarm.py,sha256=8tp1eGmsQqqWpaDcjPoJckddPWohZdmmN0RGRJ_xzOA,9198
 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=4IBV9_staE6vMci4hUjHWYHc8iS87mM8lT6LX0xh8Mw,61040
+dao_ai/providers/databricks.py,sha256=XxYkyoDYkwGV_Xg1IJBpGOl4d7U5HiFP4RtjjSLgenI,61437
 dao_ai/tools/__init__.py,sha256=SRd7W2DOCXKbWWy8lclRtJiCskz7SDAm94qaFF47urQ,1664
 dao_ai/tools/agent.py,sha256=plIWALywRjaDSnot13nYehBsrHRpBUpsVZakoGeajOE,1858
 dao_ai/tools/core.py,sha256=bRIN3BZhRQX8-Kpu3HPomliodyskCqjxynQmYbk6Vjs,3783
@@ -57,8 +63,8 @@ dao_ai/tools/sql.py,sha256=tKd1gjpLuKdQDyfmyYYtMiNRHDW6MGRbdEVaeqyB8Ok,7632
 dao_ai/tools/time.py,sha256=tufJniwivq29y0LIffbgeBTIDE6VgrLpmVf8Qr90qjw,9224
 dao_ai/tools/unity_catalog.py,sha256=AjQfW7bvV8NurqDLIyntYRv2eJuTwNdbvex1L5CRjOk,15534
 dao_ai/tools/vector_search.py,sha256=oe2uBwl2TfeJIXPpwiS6Rmz7wcHczSxNyqS9P3hE6co,14542
-dao_ai-0.1.2.dist-info/METADATA,sha256=hNysdpnl7dp_T1gC5tJQ4YHwSLoeg2UJY0aHg4-gvYc,15615
-dao_ai-0.1.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dao_ai-0.1.2.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.1.2.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.1.2.dist-info/RECORD,,
+dao_ai-0.1.5.dist-info/METADATA,sha256=Iz_x_25jQut9i8yghsPmQV08iyLBJdrXTAjFmYOjx1Q,16685
+dao_ai-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.1.5.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.1.5.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.1.5.dist-info/RECORD,,