dao-ai 0.1.16__py3-none-any.whl → 0.1.18__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."
@@ -106,6 +111,9 @@ def find_index(
             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.16.dist-info → dao_ai-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dao-ai
-Version: 0.1.16
+Version: 0.1.18
 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,7 +26,7 @@ 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.77.0
 Requires-Dist: ddgs>=9.10.0
@@ -235,7 +235,7 @@ app:
     - *assistant
   orchestration:
     swarm:
-      model: *default_llm
+      default_agent: *assistant
 ```
 
 **💡 What's happening here?**

{dao_ai-0.1.16.dist-info → dao_ai-0.1.18.dist-info}/RECORD

@@ -1,18 +1,18 @@
 dao_ai/__init__.py,sha256=18P98ExEgUaJ1Byw440Ct1ty59v6nxyWtc5S6Uq2m9Q,1062
 dao_ai/catalog.py,sha256=sPZpHTD3lPx4EZUtIWeQV7VQM89WJ6YH__wluk1v2lE,4947
-dao_ai/cli.py,sha256=6qwlS07_Tei6iEPXIJ-19cQVnLXd7vJDpuY4Qu0k96E,51634
-dao_ai/config.py,sha256=9RcyCNiLg0YlARZd-ZJ9M4oirNX5emxaIS23VHca_Z4,130328
+dao_ai/cli.py,sha256=Mcw03hemsT4O63lAH6mqTaPZjx0Q01YTgj5CN0thODI,52121
+dao_ai/config.py,sha256=lPWOCTL8NxoARkI8MRZlDJ2HiCAXgBB-SAyqCQQUVC8,145474
+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=7W6Ek6Uk9-pKa-H06nVCwuDllCrgX02IYy3rHtuL0aM,10777
 dao_ai/optimization.py,sha256=phK6t4wYmWPObCjGUBHdZzsaFXGhQOjhAek2bAEfwXo,22971
-dao_ai/prompts.py,sha256=4cz5bZ7cOzrjyQ8hMp-K4evK6cVYrkGrAGdUl8-KDEM,2784
 dao_ai/state.py,sha256=ifDTAC7epdowk3Z1CP3Xqw4uH2dIxQEVF3C747dA8yI,6436
 dao_ai/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dao_ai/utils.py,sha256=_Urd7Nj2VzrgPKf3NS4E6vt0lWRhEUddBqWN9BksqeE,11543
-dao_ai/vector_search.py,sha256=8d3xROg9zSIYNXjRRl6rSexsJTlufjRl5Fy1ZA8daKA,4019
+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
@@ -31,7 +31,7 @@ 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=DeLmexSzz91eXEJN5zW4YJigLCby8j9qNAZleumaVHU,17481
+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
@@ -48,28 +48,37 @@ dao_ai/middleware/tool_call_limit.py,sha256=WQ3NmA3pLo-pNPBmwM7KwkYpT1segEnWqkhg
 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=qoU7uMXBJCth-sqfu0jRE1L0GOn5H4LoZdRUY1Ib3DI,9585
-dao_ai/orchestration/supervisor.py,sha256=alKMEEo9G5LhdpMvTVdAMel234cZj5_MguWl4wFB7XQ,9873
-dao_ai/orchestration/swarm.py,sha256=8tp1eGmsQqqWpaDcjPoJckddPWohZdmmN0RGRJ_xzOA,9198
+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=bI8lWZ2DkNac9aJWCIJzTG3lCE8MJ8n2BPurEHM1SeE,72791
+dao_ai/providers/databricks.py,sha256=cg-TY9IS3-OqIo1gkLe1YwOR1H-s8YTBGrqDrkOWR6c,73569
 dao_ai/tools/__init__.py,sha256=NfRpAKds_taHbx6gzLPWgtPXve-YpwzkoOAUflwxceM,1734
 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=b0R51N5D58H1vpOCUCA88ALjLs58KSMn6nl80ap8_c0,11009
-dao_ai/tools/mcp.py,sha256=K1yMQ39UgJ0Q4xhMpNWV3AVNx929w9vxZlLoCq_jrws,22016
+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=LF_72vlEF6TwUjKVv6nkUetLK766l9Kl6DQQTc9ebJI,15888
-dao_ai-0.1.16.dist-info/METADATA,sha256=hKYbqBIQ8eNjVtpkhysLAJNS1ISg9Tuy1ek9SggxSC4,16830
-dao_ai-0.1.16.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dao_ai-0.1.16.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
-dao_ai-0.1.16.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
-dao_ai-0.1.16.dist-info/RECORD,,
+dao_ai/tools/vector_search.py,sha256=34uhd58FKHzvcdgHHoACRdZAUJWTaUuPYiwIqBwvGqk,29061
+dao_ai/tools/verifier.py,sha256=ociBVsGkQNyhWS6F6G8x17V7zAQfSuTe4Xcd6Y-7lPE,4975
+dao_ai-0.1.18.dist-info/METADATA,sha256=_458v0KntzrWOU-pc8hs0YsRjfW0Oacgf91gqNloT5w,16836
+dao_ai-0.1.18.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dao_ai-0.1.18.dist-info/entry_points.txt,sha256=Xa-UFyc6gWGwMqMJOt06ZOog2vAfygV_DSwg1AiP46g,43
+dao_ai-0.1.18.dist-info/licenses/LICENSE,sha256=YZt3W32LtPYruuvHE9lGk2bw6ZPMMJD8yLrjgHybyz4,1069
+dao_ai-0.1.18.dist-info/RECORD,,