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

dao_ai/tools/verifier.py

@@ -0,0 +1,159 @@
+"""
+Result verifier for validating search results against user constraints.
+
+Provides structured feedback for intelligent retry when results don't match intent.
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+import mlflow
+import yaml
+from langchain_core.documents import Document
+from langchain_core.language_models import BaseChatModel
+from langchain_core.runnables import Runnable
+from loguru import logger
+from mlflow.entities import SpanType
+
+from dao_ai.config import VerificationResult
+
+# Load prompt template
+_PROMPT_PATH = Path(__file__).parent.parent / "prompts" / "verifier.yaml"
+
+
+def _load_prompt_template() -> dict[str, Any]:
+    """Load the verifier prompt template from YAML."""
+    with open(_PROMPT_PATH) as f:
+        return yaml.safe_load(f)
+
+
+def _format_results_summary(documents: list[Document], max_docs: int = 5) -> str:
+    """Format top documents for verification prompt."""
+    if not documents:
+        return "No results retrieved."
+
+    summaries = []
+    for i, doc in enumerate(documents[:max_docs]):
+        metadata_str = ", ".join(
+            f"{k}: {v}"
+            for k, v in doc.metadata.items()
+            if not k.startswith("_") and k not in ("rrf_score", "reranker_score")
+        )
+        content_preview = (
+            doc.page_content[:200] + "..."
+            if len(doc.page_content) > 200
+            else doc.page_content
+        )
+        summaries.append(f"{i + 1}. {content_preview}\n   Metadata: {metadata_str}")
+
+    return "\n\n".join(summaries)
+
+
+def _format_constraints(constraints: list[str] | None) -> str:
+    """Format constraints list for prompt."""
+    if not constraints:
+        return "No explicit constraints specified."
+    return "\n".join(f"- {c}" for c in constraints)
+
+
+@mlflow.trace(name="verify_results", span_type=SpanType.LLM)
+def verify_results(
+    llm: BaseChatModel,
+    query: str,
+    documents: list[Document],
+    schema_description: str,
+    constraints: list[str] | None = None,
+    previous_feedback: str | None = None,
+) -> VerificationResult:
+    """
+    Verify that search results satisfy user constraints.
+
+    Args:
+        llm: Language model for verification
+        query: User's original search query
+        documents: Retrieved documents to verify
+        schema_description: Column names, types, and filter syntax
+        constraints: Explicit constraints to verify
+        previous_feedback: Feedback from previous failed attempt (for retry)
+
+    Returns:
+        VerificationResult with pass/fail status and structured feedback
+    """
+    prompt_config = _load_prompt_template()
+    prompt_template = prompt_config["template"]
+
+    prompt = prompt_template.format(
+        query=query,
+        schema_description=schema_description,
+        constraints=_format_constraints(constraints),
+        num_results=len(documents),
+        results_summary=_format_results_summary(documents),
+        previous_feedback=previous_feedback or "N/A (first attempt)",
+    )
+
+    logger.trace("Verifying results", query=query[:100], num_docs=len(documents))
+
+    # Use LangChain's with_structured_output for automatic strategy selection
+    # (JSON schema vs tool calling based on model capabilities)
+    try:
+        structured_llm: Runnable[str, VerificationResult] = llm.with_structured_output(
+            VerificationResult
+        )
+        result: VerificationResult = structured_llm.invoke(prompt)
+    except Exception as e:
+        logger.warning(
+            "Verifier failed, treating as passed with low confidence", error=str(e)
+        )
+        return VerificationResult(
+            passed=True,
+            confidence=0.0,
+            feedback="Verification failed to produce a valid result",
+        )
+
+    # Log for observability
+    mlflow.log_text(
+        json.dumps(result.model_dump(), indent=2),
+        "verification_result.json",
+    )
+
+    logger.debug(
+        "Verification complete",
+        passed=result.passed,
+        confidence=result.confidence,
+        unmet_constraints=result.unmet_constraints,
+    )
+
+    return result
+
+
+def add_verification_metadata(
+    documents: list[Document],
+    result: VerificationResult,
+    exhausted: bool = False,
+) -> list[Document]:
+    """
+    Add verification metadata to documents.
+
+    Args:
+        documents: Documents to annotate
+        result: Verification result
+        exhausted: Whether max retries were exhausted
+
+    Returns:
+        Documents with verification metadata added
+    """
+    status = "exhausted" if exhausted else ("passed" if result.passed else "failed")
+
+    annotated = []
+    for doc in documents:
+        metadata = {
+            **doc.metadata,
+            "_verification_status": status,
+            "_verification_confidence": result.confidence,
+        }
+        if result.feedback:
+            metadata["_verification_feedback"] = result.feedback
+        annotated.append(Document(page_content=doc.page_content, metadata=metadata))
+
+    return annotated

dao_ai/utils.py

@@ -1,17 +1,22 @@
 import importlib
 import importlib.metadata
+import json
 import os
 import re
 import site
 from importlib.metadata import PackageNotFoundError, version
 from pathlib import Path
-from typing import Any, Callable, Sequence
+from typing import Any, Callable, Sequence, TypeVar
 
+from langchain_core.language_models import BaseChatModel
 from langchain_core.tools import BaseTool
 from loguru import logger
+from pydantic import BaseModel
 
 import dao_ai
 
+T = TypeVar("T", bound=BaseModel)
+
 
 def is_lib_provided(lib_name: str, pip_requirements: Sequence[str]) -> bool:
     return any(
@@ -152,7 +157,7 @@ def get_installed_packages() -> dict[str, str]:
 
     packages: Sequence[str] = [
         f"databricks-agents=={version('databricks-agents')}",
-        f"databricks-langchain=={version('databricks-langchain')}",
+        f"databricks-langchain[memory]=={version('databricks-langchain')}",
         f"databricks-mcp=={version('databricks-mcp')}",
         f"databricks-sdk[openai]=={version('databricks-sdk')}",
         f"ddgs=={version('ddgs')}",
@@ -322,3 +327,178 @@ def is_in_model_serving() -> bool:
         return True
 
     return False
+
+
+def get_databricks_response_format(model_class: type[BaseModel]) -> dict[str, Any]:
+    """Create a Databricks-compatible response_format for structured output.
+
+    Databricks requires the json_schema response format to have a 'name' field.
+    This function creates the properly formatted response_format dictionary
+    from a Pydantic model.
+
+    Args:
+        model_class: A Pydantic model class to use as the output schema
+
+    Returns:
+        A dictionary suitable for use with llm.bind(response_format=...)
+
+    Example:
+        >>> response_format = get_databricks_response_format(MyModel)
+        >>> bound_llm = llm.bind(response_format=response_format)
+        >>> result = bound_llm.invoke(prompt)
+    """
+    schema = model_class.model_json_schema()
+
+    # Remove $defs from the schema - Databricks doesn't support complex refs
+    # We need to inline any referenced definitions
+    if "$defs" in schema:
+        schema = _inline_schema_defs(schema)
+
+    return {
+        "type": "json_schema",
+        "json_schema": {
+            "name": model_class.__name__,
+            "schema": schema,
+            "strict": True,
+        },
+    }
+
+
+def _inline_schema_defs(schema: dict[str, Any]) -> dict[str, Any]:
+    """Inline $defs references in a JSON schema.
+
+    Databricks doesn't support $ref and complex nested definitions,
+    so we need to inline them.
+
+    Args:
+        schema: The original JSON schema with $defs
+
+    Returns:
+        A schema with all references inlined
+    """
+    defs = schema.pop("$defs", {})
+    if not defs:
+        return schema
+
+    def resolve_refs(obj: Any) -> Any:
+        if isinstance(obj, dict):
+            if "$ref" in obj:
+                # Extract the definition name from #/$defs/DefinitionName
+                ref_path = obj["$ref"]
+                if ref_path.startswith("#/$defs/"):
+                    def_name = ref_path[len("#/$defs/") :]
+                    if def_name in defs:
+                        # Return a copy of the definition with refs resolved
+                        return resolve_refs(defs[def_name].copy())
+                return obj
+            return {k: resolve_refs(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [resolve_refs(item) for item in obj]
+        return obj
+
+    return resolve_refs(schema)
+
+
+def _repair_json(content: str) -> str | None:
+    """Attempt to repair malformed JSON from LLM output.
+
+    Handles common issues:
+    - Extra text before/after JSON object
+    - Truncated JSON (unclosed brackets/braces)
+    - Trailing commas
+
+    Args:
+        content: The potentially malformed JSON string
+
+    Returns:
+        Repaired JSON string if successful, None otherwise
+    """
+    # 1. Extract JSON object if wrapped in extra text
+    start = content.find("{")
+    end = content.rfind("}")
+    if start == -1 or end == -1 or start >= end:
+        return None
+    content = content[start : end + 1]
+
+    # 2. Try parsing as-is first
+    try:
+        json.loads(content)
+        return content
+    except json.JSONDecodeError:
+        pass
+
+    # 3. Fix trailing commas before closing brackets
+    content = re.sub(r",\s*}", "}", content)
+    content = re.sub(r",\s*]", "]", content)
+
+    # 4. Try to close unclosed brackets/braces
+    open_braces = content.count("{") - content.count("}")
+    open_brackets = content.count("[") - content.count("]")
+
+    if open_braces > 0 or open_brackets > 0:
+        # Remove trailing comma if present
+        content = content.rstrip().rstrip(",")
+        content += "]" * open_brackets + "}" * open_braces
+
+    # 5. Final validation
+    try:
+        json.loads(content)
+        return content
+    except json.JSONDecodeError:
+        return None
+
+
+def invoke_with_structured_output(
+    llm: BaseChatModel,
+    prompt: str,
+    model_class: type[T],
+) -> T | None:
+    """Invoke an LLM with Databricks-compatible structured output.
+
+    Uses response_format with json_schema type and proper 'name' field
+    as required by Databricks Foundation Model APIs.
+
+    Args:
+        llm: The language model to invoke
+        prompt: The prompt to send to the model
+        model_class: The Pydantic model class for the expected output
+
+    Returns:
+        An instance of model_class, or None if parsing fails
+    """
+    response_format = get_databricks_response_format(model_class)
+    bound_llm = llm.bind(response_format=response_format)
+
+    response = bound_llm.invoke(prompt)
+
+    content = response.content
+    if not isinstance(content, str):
+        return None
+
+    try:
+        # Try parsing the JSON directly
+        result_dict = json.loads(content)
+        return model_class.model_validate(result_dict)
+    except json.JSONDecodeError as e:
+        # Attempt JSON repair
+        repaired = _repair_json(content)
+        if repaired:
+            try:
+                result_dict = json.loads(repaired)
+                logger.debug("JSON repair successful", model_class=model_class.__name__)
+                return model_class.model_validate(result_dict)
+            except (json.JSONDecodeError, Exception):
+                pass
+        logger.warning(
+            "Failed to parse structured output",
+            error=str(e),
+            model_class=model_class.__name__,
+        )
+        return None
+    except Exception as e:
+        logger.warning(
+            "Failed to parse structured output",
+            error=str(e),
+            model_class=model_class.__name__,
+        )
+        return None

dao_ai/vector_search.py

@@ -64,7 +64,12 @@ def index_exists(
         return True
     except Exception as e:
         # Check if this is a "not exists" error or something else
-        if "RESOURCE_DOES_NOT_EXIST" not in str(e):
+        # Handle both "RESOURCE_DOES_NOT_EXIST" and "does not exist" error patterns
+        error_str = str(e).lower()
+        if (
+            "does not exist" not in error_str
+            and "resource_does_not_exist" not in error_str
+        ):
             # For unexpected errors, provide a more helpful message
             print(
                 "Unexpected error describing the index. This could be a permission issue."
@@ -72,3 +77,43 @@ 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
+            # Catches both "does not exist" and "RESOURCE_DOES_NOT_EXIST" errors,
+            # as well as other errors (permission issues, etc.) - we continue
+            # searching other endpoints regardless of error type
+            continue
+
+    return (False, None)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.2
+Version: 0.1.20
 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
@@ -26,9 +26,9 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Distributed Computing
 Requires-Python: >=3.11
 Requires-Dist: databricks-agents>=1.9.0
-Requires-Dist: databricks-langchain[memory]>=0.12.1
+Requires-Dist: databricks-langchain[memory]>=0.13.0
 Requires-Dist: databricks-mcp>=0.5.0
-Requires-Dist: databricks-sdk[openai]>=0.76.0
+Requires-Dist: databricks-sdk[openai]>=0.77.0
 Requires-Dist: ddgs>=9.10.0
 Requires-Dist: dspy>=2.6.27
 Requires-Dist: flashrank>=0.2.10
@@ -43,7 +43,7 @@ Requires-Dist: langgraph>=1.0.5
 Requires-Dist: langmem>=0.0.30
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: mcp>=1.24.0
-Requires-Dist: mlflow>=3.8.1
+Requires-Dist: mlflow[databricks]>=3.8.1
 Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: openevals>=0.1.3
 Requires-Dist: openpyxl>=3.1.5
@@ -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)
 
@@ -125,7 +125,7 @@ DAO AI Builder generates valid YAML configurations that work seamlessly with thi
 - **[Architecture](docs/architecture.md)** - Understand how DAO works under the hood
 
 ### Core Concepts
-- **[Key Capabilities](docs/key-capabilities.md)** - Explore 14 powerful features for production agents
+- **[Key Capabilities](docs/key-capabilities.md)** - Explore 15 powerful features for production agents
 - **[Configuration Reference](docs/configuration-reference.md)** - Complete YAML configuration guide
 - **[Examples](docs/examples.md)** - Ready-to-use example configurations
 
@@ -148,7 +148,7 @@ Before you begin, you'll need:
 - **Python 3.11 or newer** installed on your computer ([download here](https://www.python.org/downloads/))
 - **A Databricks workspace** (ask your IT team or see [Databricks docs](https://docs.databricks.com/))
   - Access to **Unity Catalog** (your organization's data catalog)
-  - **Model Serving** enabled (for deploying AI agents)
+  - **Model Serving** or **Databricks Apps** enabled (for deploying AI agents)
   - *Optional*: Vector Search, Genie (for advanced features)
 
 **Not sure if you have access?** Your Databricks administrator can grant you permissions.
@@ -235,7 +235,7 @@ app:
     - *assistant
   orchestration:
     swarm:
-      model: *default_llm
+      default_agent: *assistant
 ```
 
 **💡 What's happening here?**
@@ -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:
@@ -335,6 +345,7 @@ DAO provides powerful capabilities for building production-ready AI agents:
 
 | Feature | Description |
 |---------|-------------|
+| **Dual Deployment Targets** | Deploy to Databricks Model Serving or Databricks Apps with a single config |
 | **Multi-Tool Support** | Python functions, Unity Catalog, MCP, Agent Endpoints |
 | **On-Behalf-Of User** | Per-user permissions and governance |
 | **Advanced Caching** | Two-tier (LRU + Semantic) caching for cost optimization |
@@ -398,7 +409,8 @@ The `config/examples/` directory contains ready-to-use configurations organized
 
 - `01_getting_started/minimal.yaml` - Simplest possible agent
 - `02_tools/vector_search_with_reranking.yaml` - RAG with improved accuracy
-- `04_genie/genie_semantic_cache.yaml` - NL-to-SQL with two-tier caching
+- `04_genie/genie_semantic_cache.yaml` - NL-to-SQL with PostgreSQL semantic caching
+- `04_genie/genie_in_memory_semantic_cache.yaml` - NL-to-SQL with in-memory semantic caching (no database)
 - `05_memory/conversation_summarization.yaml` - Long conversation handling
 - `06_on_behalf_of_user/obo_basic.yaml` - User-level access control
 - `07_human_in_the_loop/human_in_the_loop.yaml` - Approval workflows
@@ -422,10 +434,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.20.dist-info/RECORD

@@ -0,0 +1,89 @@
+dao_ai/__init__.py,sha256=18P98ExEgUaJ1Byw440Ct1ty59v6nxyWtc5S6Uq2m9Q,1062
+dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
+dao_ai/cli.py,sha256=7hVCC8mn9S3c4wW-eRt-WoFKzV1wPdJVAeNhkyhfUGc,53251
+dao_ai/config.py,sha256=08eHf7HzXNEsFY1_-lCESCtC-RhEZy9nikTiWPmc25A,156770
+dao_ai/evaluation.py,sha256=4dveWDwFnUxaybswr0gag3ydZ5RGVCTRaiE3eKLClD4,18161
+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=NaHj91Gra4M8thlKX1DSufLqtJfZSZ55lm1H1dJL_O8,77320
+dao_ai/nodes.py,sha256=H7_C0ev0TpS5KWkGZD6eE4Wn6ouBwnN5HgYUyBeKe0A,10881
+dao_ai/optimization.py,sha256=phK6t4wYmWPObCjGUBHdZzsaFXGhQOjhAek2bAEfwXo,22971
+dao_ai/state.py,sha256=ifDTAC7epdowk3Z1CP3Xqw4uH2dIxQEVF3C747dA8yI,6436
+dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dao_ai/utils.py,sha256=ImgH0jnHPCK2AR7KcueG_Zb7kltcBzTw78ujDUpARIE,17184
+dao_ai/vector_search.py,sha256=PfmT2PDMymk-3dTm2uszlOZNyHyiDge--imxKpKJRsY,4440
+dao_ai/apps/__init__.py,sha256=RLuhZf4gQ4pemwKDz1183aXib8UfaRhwfKvRx68GRlM,661
+dao_ai/apps/handlers.py,sha256=6-IhhklHSPnS8aqKp155wPaSnYWTU1BSOPwbdWYBkFU,3594
+dao_ai/apps/model_serving.py,sha256=XLt3_0pGSRceMK6YtOrND9Jnh7mKLPCtwjVDLIaptQU,847
+dao_ai/apps/resources.py,sha256=5l6UxfMq6uspOql-HNDyUikfqRAa9eH_TiJHrGgMb6s,40029
+dao_ai/apps/server.py,sha256=neWbVnC2z9f-tJZBnho70FytNDEVOdOM1YngoGc5KHI,1264
+dao_ai/genie/__init__.py,sha256=UpSvP6gZO8H-eAPokYpkshvFxYD4ETYZHz-pRPoK2sI,2786
+dao_ai/genie/core.py,sha256=eKZo4pRagwI6QglAXqHYjUaC3AicmGMiy_9WIuZ-tzw,9119
+dao_ai/genie/cache/__init__.py,sha256=hMD2q7VRX8fQmkd4rXhxGJdRIVbDqLh2DyjBu0CdM_k,2129
+dao_ai/genie/cache/base.py,sha256=nbWl-KTstUPGagdUtO8xtVUSosuqkaNc_hx-PgT1ROo,7155
+dao_ai/genie/cache/core.py,sha256=48sDY7dbrsmflb96OFEE8DYarNB6zyiFxZQG-qfhXD4,2537
+dao_ai/genie/cache/lru.py,sha256=dWoNottME8y6y_OKnQZ1xH4NmQxk2PdXvUgKcdzjlxI,19935
+dao_ai/genie/cache/optimization.py,sha256=8tyMrthHCxdOdvqDwGnGAvRNCWk9e0nIb3dJkE05t-4,30167
+dao_ai/genie/cache/context_aware/__init__.py,sha256=EaW2CmWxb0CDNcm3pKL6Vyaw2KuwanKV1LiFVlT2M-s,1197
+dao_ai/genie/cache/context_aware/base.py,sha256=o3S3f0B0jCB7vjb2XKWm5hFcO6v-jNYc6ZELyBkeBrg,40452
+dao_ai/genie/cache/context_aware/in_memory.py,sha256=Z-ZrMTVD1pjC55irhodBWsrs6D2h3Sv-Iifk0Cr1mRo,22316
+dao_ai/genie/cache/context_aware/persistent.py,sha256=cpn25Go6ZyN65lY_vh5cWcuqr__nNH7RPWJA_LP7wcE,28154
+dao_ai/genie/cache/context_aware/postgres.py,sha256=cakJuba3dFjKoEHlpBYgmr3pEuM88dM8ambgL6Vq_54,46403
+dao_ai/hooks/__init__.py,sha256=uA4DQdP9gDf4SyNjNx9mWPoI8UZOcTyFsCXV0NraFvQ,463
+dao_ai/hooks/core.py,sha256=yZAfRfB0MyMo--uwGr4STtVxxen5s4ZUrNTnR3a3qkA,1721
+dao_ai/memory/__init__.py,sha256=Us3wFehvug_h83m-UJ7OXdq2qZ0e9nHBQE7m5RwoAd8,559
+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=bSjtvEht0h6jy2ADN2vqISVQDxm_DeM586VDdGaShJQ,23168
+dao_ai/middleware/__init__.py,sha256=Qy8wbvjXF7TrUzi3tWziOwxqsrUcT1rzE3UWd3x5CrU,5108
+dao_ai/middleware/assertions.py,sha256=C1K-TnNZfBEwWouioHCt6c48i1ux9QKfQaX6AzghhgE,27408
+dao_ai/middleware/base.py,sha256=uG2tpdnjL5xY5jCKvb_m3UTBtl4ZC6fJQUkDsQvV8S4,1279
+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/middleware/tool_selector.py,sha256=POj72YdzZEiNGfW4AQXPBeVVS1RUBsiG7PBuSENEhe0,4516
+dao_ai/orchestration/__init__.py,sha256=i85CLfRR335NcCFhaXABcMkn6WZfXnJ8cHH4YZsZN0s,1622
+dao_ai/orchestration/core.py,sha256=8bPigzWtHUZ0Gw4Q_91uvcREucVQstxlelC06W_qmn0,10683
+dao_ai/orchestration/supervisor.py,sha256=FoQ1fYP_e0taKC4ByITqJLOYvwJd1zecYYLs4RcY1lk,10605
+dao_ai/orchestration/swarm.py,sha256=BloDI0TWhGisv9r3-zTgJWZQy9l3hbQ5tXYggovr5i8,9467
+dao_ai/prompts/__init__.py,sha256=r91BY_yq28iUL0Pz5NbMo1VEDQh-aE44GqN0tBrIKfc,3011
+dao_ai/prompts/instructed_retriever_decomposition.yaml,sha256=OkBLLlgU8MXtvGPlhESXgFfwYCUGRDcyD8O1iWOsmbk,2107
+dao_ai/prompts/instruction_reranker.yaml,sha256=4OGZLNbdcWk6slBY5vnt_C-nGLPZM6e21smTNyaRPmE,406
+dao_ai/prompts/router.yaml,sha256=79C_O98cpNndeMO0Vdn91CC7vxZx0hZ1rl1BAgnGjYc,1319
+dao_ai/prompts/verifier.yaml,sha256=9snFQuxfYuEr46F4gv13VqL9q2PJCtWlbBhN3_IO2zI,1455
+dao_ai/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dao_ai/providers/base.py,sha256=cJGo3UjUTPgS91dv38ePOHwQQtYhIa84ebb167CBXjk,2111
+dao_ai/providers/databricks.py,sha256=cg-TY9IS3-OqIo1gkLe1YwOR1H-s8YTBGrqDrkOWR6c,73569
+dao_ai/tools/__init__.py,sha256=4dX_N6G_WrkV2BhS7hN8tR9zrMNlorLTKQYM388KTR4,1758
+dao_ai/tools/agent.py,sha256=plIWALywRjaDSnot13nYehBsrHRpBUpsVZakoGeajOE,1858
+dao_ai/tools/core.py,sha256=bRIN3BZhRQX8-Kpu3HPomliodyskCqjxynQmYbk6Vjs,3783
+dao_ai/tools/email.py,sha256=A3TsCoQgJR7UUWR0g45OPRGDpVoYwctFs1MOZMTt_d4,7389
+dao_ai/tools/genie.py,sha256=MWW2nCutl5-Wxwt4m7AxrS0ufqZimTKXa-lbojhwRYQ,12219
+dao_ai/tools/instructed_retriever.py,sha256=iEu7oH1Z9_-Id0SMaq-dAgCNigeRrJDDTSZTcOJLl6k,12990
+dao_ai/tools/instruction_reranker.py,sha256=_1kGwrXkJk4QR2p8n3lAaYkUVoidxCxV9wNCtoS0qco,6730
+dao_ai/tools/mcp.py,sha256=4uvag52OJPInUEnxFLwpE0JRugTrgHeWbkP5lzIx4lg,22620
+dao_ai/tools/memory.py,sha256=lwObKimAand22Nq3Y63tsv-AXQ5SXUigN9PqRjoWKes,1836
+dao_ai/tools/python.py,sha256=jWFnZPni2sCdtd8D1CqXnZIPHnWkdK27bCJnBXpzhvo,1879
+dao_ai/tools/router.py,sha256=YIVzSk4-ZFQHgvkhyrPHGLbDyzE9koa5QmbcTT-npnI,2872
+dao_ai/tools/search.py,sha256=cJ3D9FKr1GAR6xz55dLtRkjtQsI0WRueGt9TPDFpOxc,433
+dao_ai/tools/slack.py,sha256=QnMsA7cYD1MnEcqGqqSr6bKIhV0RgDpkyaiPmDqnAts,5433
+dao_ai/tools/sql.py,sha256=FG-Aa0FAUAnhCuZvao1J-y-cMM6bU5eCujNbsYn0xDw,7864
+dao_ai/tools/time.py,sha256=tufJniwivq29y0LIffbgeBTIDE6VgrLpmVf8Qr90qjw,9224
+dao_ai/tools/unity_catalog.py,sha256=oBlW6pH-Ne08g60QW9wVi_tyeVYDiecuNoxQbIIFmN8,16515
+dao_ai/tools/vector_search.py,sha256=34uhd58FKHzvcdgHHoACRdZAUJWTaUuPYiwIqBwvGqk,29061
+dao_ai/tools/verifier.py,sha256=ociBVsGkQNyhWS6F6G8x17V7zAQfSuTe4Xcd6Y-7lPE,4975
+dao_ai-0.1.20.dist-info/METADATA,sha256=v-u8GWz1AnJXLm1LfSMrD-cHZYT-nbyU57VNOxG9KWY,16954
+dao_ai-0.1.20.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.1.20.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.1.20.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.1.20.dist-info/RECORD,,

dao_ai/agent_as_code.py

@@ -1,22 +0,0 @@
-import mlflow
-from mlflow.models import ModelConfig
-from mlflow.pyfunc import ResponsesAgent
-
-from dao_ai.config import AppConfig
-from dao_ai.logging import configure_logging
-
-mlflow.set_registry_uri("databricks-uc")
-mlflow.set_tracking_uri("databricks")
-
-mlflow.langchain.autolog()
-
-model_config: ModelConfig = ModelConfig()
-config: AppConfig = AppConfig(**model_config.to_dict())
-
-log_level: str = config.app.log_level
-
-configure_logging(level=log_level)
-
-app: ResponsesAgent = config.as_responses_agent()
-
-mlflow.models.set_model(app)