haiku.rag 0.13.2__tar.gz → 0.13.3__tar.gz

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: haiku.rag
-Version: 0.13.2
+Version: 0.13.3
 Summary: Agentic Retrieval Augmented Generation (RAG) with LanceDB
 Author-email: Yiorgis Gozadinos <ggozadinos@gmail.com>
 License: MIT
@@ -33,10 +33,14 @@ Requires-Dist: typer<0.20.0,>=0.19.2
 Requires-Dist: watchfiles>=1.1.1
 Provides-Extra: a2a
 Requires-Dist: fasta2a>=0.1.0; extra == 'a2a'
+Provides-Extra: cohere
+Requires-Dist: cohere>=5.0.0; extra == 'cohere'
 Provides-Extra: mxbai
 Requires-Dist: mxbai-rerank>=0.1.6; extra == 'mxbai'
 Provides-Extra: voyageai
 Requires-Dist: voyageai>=0.3.5; extra == 'voyageai'
+Provides-Extra: zeroentropy
+Requires-Dist: zeroentropy>=0.1.0a6; extra == 'zeroentropy'
 Description-Content-Type: text/markdown
 
 # Haiku RAG
@@ -56,7 +60,7 @@ Retrieval-Augmented Generation (RAG) library built on LanceDB.
 - **Multiple QA providers**: Any provider/model supported by Pydantic AI
 - **Research graph (multi‑agent)**: Plan → Search → Evaluate → Synthesize with agentic AI
 - **Native hybrid search**: Vector + full-text search with native LanceDB RRF reranking
-- **Reranking**: Default search result reranking with MixedBread AI, Cohere, or vLLM
+- **Reranking**: Default search result reranking with MixedBread AI, Cohere, Zero Entropy, or vLLM
 - **Question answering**: Built-in QA agents on your documents
 - **File monitoring**: Auto-index files when run as server
 - **40+ file formats**: PDF, DOCX, HTML, Markdown, code files, URLs
@@ -79,6 +83,9 @@ haiku-rag add-src document.pdf --meta source=manual
 # Search
 haiku-rag search "query"
 
+# Search with filters
+haiku-rag search "query" --filter "uri LIKE '%.pdf' AND title LIKE '%paper%'"
+
 # Ask questions
 haiku-rag ask "Who is the author of haiku.rag?"
 

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/README.md

@@ -15,7 +15,7 @@ Retrieval-Augmented Generation (RAG) library built on LanceDB.
 - **Multiple QA providers**: Any provider/model supported by Pydantic AI
 - **Research graph (multi‑agent)**: Plan → Search → Evaluate → Synthesize with agentic AI
 - **Native hybrid search**: Vector + full-text search with native LanceDB RRF reranking
-- **Reranking**: Default search result reranking with MixedBread AI, Cohere, or vLLM
+- **Reranking**: Default search result reranking with MixedBread AI, Cohere, Zero Entropy, or vLLM
 - **Question answering**: Built-in QA agents on your documents
 - **File monitoring**: Auto-index files when run as server
 - **40+ file formats**: PDF, DOCX, HTML, Markdown, code files, URLs
@@ -38,6 +38,9 @@ haiku-rag add-src document.pdf --meta source=manual
 # Search
 haiku-rag search "query"
 
+# Search with filters
+haiku-rag search "query" --filter "uri LIKE '%.pdf' AND title LIKE '%paper%'"
+
 # Ask questions
 haiku-rag ask "Who is the author of haiku.rag?"
 

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/pyproject.toml

@@ -2,7 +2,7 @@
 
 name = "haiku.rag"
 description = "Agentic Retrieval Augmented Generation (RAG) with LanceDB"
-version = "0.13.2"
+version = "0.13.3"
 authors = [{ name = "Yiorgis Gozadinos", email = "ggozadinos@gmail.com" }]
 license = { text = "MIT" }
 readme = { file = "README.md", content-type = "text/markdown" }
@@ -42,6 +42,8 @@ dependencies = [
 voyageai = ["voyageai>=0.3.5"]
 mxbai = ["mxbai-rerank>=0.1.6"]
 a2a = ["fasta2a>=0.1.0"]
+cohere = ["cohere>=5.0.0"]
+zeroentropy = ["zeroentropy>=0.1.0a6"]
 
 [project.scripts]
 haiku-rag = "haiku.rag.cli:cli"

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/evaluations/benchmark.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections.abc import Mapping
+from pathlib import Path
 from typing import Any, cast
 
 import logfire
@@ -12,13 +13,12 @@ from pydantic_evals.reporting import ReportCaseFailure
 from rich.console import Console
 from rich.progress import Progress
 
-from evaluations.config import DatasetSpec, RetrievalSample
+from evaluations.config import DatasetSpec
 from evaluations.datasets import DATASETS
 from evaluations.llm_judge import ANSWER_EQUIVALENCE_RUBRIC
 from evaluations.prompts import WIX_SUPPORT_PROMPT
-from haiku.rag import logging  # noqa: F401
 from haiku.rag.client import HaikuRAG
-from haiku.rag.config import Config
+from haiku.rag.config import AppConfig, find_config_file, load_yaml_config
 from haiku.rag.logging import configure_cli_logging
 from haiku.rag.qa import get_qa_agent
 
@@ -30,7 +30,7 @@ configure_cli_logging()
 console = Console()
 
 
-async def populate_db(spec: DatasetSpec) -> None:
+async def populate_db(spec: DatasetSpec, config: AppConfig) -> None:
     spec.db_path.parent.mkdir(parents=True, exist_ok=True)
     corpus = spec.document_loader()
     if spec.document_limit is not None:
@@ -38,7 +38,7 @@ async def populate_db(spec: DatasetSpec) -> None:
 
     with Progress() as progress:
         task = progress.add_task("[green]Populating database...", total=len(corpus))
-        async with HaikuRAG(spec.db_path) as rag:
+        async with HaikuRAG(spec.db_path, config=config) as rag:
             for doc in corpus:
                 doc_mapping = cast(Mapping[str, Any], doc)
                 payload = spec.document_mapper(doc_mapping)
@@ -64,11 +64,9 @@ async def populate_db(spec: DatasetSpec) -> None:
                 progress.advance(task)
 
 
-def _is_relevant_match(retrieved_uri: str | None, sample: RetrievalSample) -> bool:
-    return retrieved_uri is not None and retrieved_uri in sample.expected_uris
-
-
-async def run_retrieval_benchmark(spec: DatasetSpec) -> dict[str, float] | None:
+async def run_retrieval_benchmark(
+    spec: DatasetSpec, config: AppConfig
+) -> dict[str, float] | None:
     if spec.retrieval_loader is None or spec.retrieval_mapper is None:
         console.print("Skipping retrieval benchmark; no retrieval config.")
         return None
@@ -91,7 +89,7 @@ async def run_retrieval_benchmark(spec: DatasetSpec) -> dict[str, float] | None:
         task = progress.add_task(
             "[blue]Running retrieval benchmark...", total=len(corpus)
         )
-        async with HaikuRAG(spec.db_path) as rag:
+        async with HaikuRAG(spec.db_path, config=config) as rag:
             for doc in corpus:
                 doc_mapping = cast(Mapping[str, Any], doc)
                 sample = spec.retrieval_mapper(doc_mapping)
@@ -161,7 +159,7 @@ async def run_retrieval_benchmark(spec: DatasetSpec) -> dict[str, float] | None:
 
 
 async def run_qa_benchmark(
-    spec: DatasetSpec, qa_limit: int | None = None
+    spec: DatasetSpec, config: AppConfig, qa_limit: int | None = None
 ) -> ReportCaseFailure[str, str, dict[str, str]] | None:
     corpus = spec.qa_loader()
     if qa_limit is not None:
@@ -174,7 +172,7 @@ async def run_qa_benchmark(
 
     judge_model = OpenAIChatModel(
         model_name=QA_JUDGE_MODEL,
-        provider=OllamaProvider(base_url=f"{Config.providers.ollama.base_url}/v1"),
+        provider=OllamaProvider(base_url=f"{config.providers.ollama.base_url}/v1"),
     )
 
     evaluation_dataset = EvalDataset[str, str, dict[str, str]](
@@ -204,7 +202,7 @@ async def run_qa_benchmark(
             total=len(evaluation_dataset.cases),
         )
 
-        async with HaikuRAG(spec.db_path) as rag:
+        async with HaikuRAG(spec.db_path, config=config) as rag:
             system_prompt = WIX_SUPPORT_PROMPT if spec.key == "wix" else None
             qa = get_qa_agent(rag, system_prompt=system_prompt)
 
@@ -272,6 +270,7 @@ async def run_qa_benchmark(
 
 async def evaluate_dataset(
     spec: DatasetSpec,
+    config: AppConfig,
     skip_db: bool,
     skip_retrieval: bool,
     skip_qa: bool,
@@ -279,15 +278,15 @@ async def evaluate_dataset(
 ) -> None:
     if not skip_db:
         console.print(f"Using dataset: {spec.key}", style="bold magenta")
-        await populate_db(spec)
+        await populate_db(spec, config)
 
     if not skip_retrieval:
         console.print("Running retrieval benchmarks...", style="bold blue")
-        await run_retrieval_benchmark(spec)
+        await run_retrieval_benchmark(spec, config)
 
     if not skip_qa:
         console.print("\nRunning QA benchmarks...", style="bold yellow")
-        await run_qa_benchmark(spec, qa_limit=qa_limit)
+        await run_qa_benchmark(spec, config, qa_limit=qa_limit)
 
 
 app = typer.Typer(help="Run retrieval and QA benchmarks for configured datasets.")
@@ -296,6 +295,9 @@ app = typer.Typer(help="Run retrieval and QA benchmarks for configured datasets.
 @app.command()
 def run(
     dataset: str = typer.Argument(..., help="Dataset key to evaluate."),
+    config: Path | None = typer.Option(
+        None, "--config", help="Path to haiku.rag YAML config file."
+    ),
     skip_db: bool = typer.Option(
         False, "--skip-db", help="Skip updateing the evaluation db."
     ),
@@ -314,9 +316,28 @@ def run(
             f"Unknown dataset '{dataset}'. Choose from: {valid_datasets}"
         )
 
+    # Load config from file or use defaults
+    if config:
+        if not config.exists():
+            raise typer.BadParameter(f"Config file not found: {config}")
+        console.print(f"Loading config from: {config}", style="dim")
+        yaml_data = load_yaml_config(config)
+        app_config = AppConfig.model_validate(yaml_data)
+    else:
+        # Try to find config file using standard search path
+        config_path = find_config_file(None)
+        if config_path:
+            console.print(f"Loading config from: {config_path}", style="dim")
+            yaml_data = load_yaml_config(config_path)
+            app_config = AppConfig.model_validate(yaml_data)
+        else:
+            console.print("No config file found, using defaults", style="dim")
+            app_config = AppConfig()
+
     asyncio.run(
         evaluate_dataset(
             spec=spec,
+            config=app_config,
             skip_db=skip_db,
             skip_retrieval=skip_retrieval,
             skip_qa=skip_qa,

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/app.py

@@ -81,13 +81,10 @@ class HaikuRAGApp:
                 raw = rows[0].get("settings") or "{}"
                 data = json.loads(raw) if isinstance(raw, str) else (raw or {})
                 stored_version = str(data.get("version", stored_version))
-                embed_provider = data.get("EMBEDDINGS_PROVIDER")
-                embed_model = data.get("EMBEDDINGS_MODEL")
-                vector_dim = (
-                    int(data.get("EMBEDDINGS_VECTOR_DIM"))  # pyright: ignore[reportArgumentType]
-                    if data.get("EMBEDDINGS_VECTOR_DIM") is not None
-                    else None
-                )
+                embeddings = data.get("embeddings", {})
+                embed_provider = embeddings.get("provider")
+                embed_model = embeddings.get("model")
+                vector_dim = embeddings.get("vector_dim")
 
         num_docs = 0
         if "documents" in table_names:
@@ -195,9 +192,9 @@ class HaikuRAGApp:
                     f"[yellow]Document with id {doc_id} not found.[/yellow]"
                 )
 
-    async def search(self, query: str, limit: int = 5):
+    async def search(self, query: str, limit: int = 5, filter: str | None = None):
         async with HaikuRAG(db_path=self.db_path) as self.client:
-            results = await self.client.search(query, limit=limit)
+            results = await self.client.search(query, limit=limit, filter=filter)
             if not results:
                 self.console.print("[yellow]No results found.[/yellow]")
                 return

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/cli.py

@@ -221,6 +221,12 @@ def search(
         "-l",
         help="Maximum number of results to return",
     ),
+    filter: str | None = typer.Option(
+        None,
+        "--filter",
+        "-f",
+        help="SQL WHERE clause to filter documents (e.g., \"uri LIKE '%arxiv%'\")",
+    ),
     db: Path = typer.Option(
         Config.storage.data_dir / "haiku.rag.lancedb",
         "--db",
@@ -230,7 +236,7 @@ def search(
     from haiku.rag.app import HaikuRAGApp
 
     app = HaikuRAGApp(db_path=db)
-    asyncio.run(app.search(query=query, limit=limit))
+    asyncio.run(app.search(query=query, limit=limit, filter=filter))
 
 
 @cli.command("ask", help="Ask a question using the QA agent")

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/client.py

@@ -135,9 +135,6 @@ class HaikuRAG:
             ValueError: If the file/URL cannot be parsed or doesn't exist
             httpx.RequestError: If URL request fails
         """
-        # Lazy import to avoid loading docling
-        from haiku.rag.reader import FileReader
-
         # Normalize metadata
         metadata = metadata or {}
 
@@ -157,15 +154,17 @@ class HaikuRAG:
 
         # Handle directories
         if source_path.is_dir():
+            from haiku.rag.monitor import FileFilter
+
             documents = []
-            supported_extensions = set(FileReader.extensions)
-            for file_path in source_path.rglob("*"):
-                if (
-                    file_path.is_file()
-                    and file_path.suffix.lower() in supported_extensions
-                ):
+            filter = FileFilter(
+                ignore_patterns=self._config.monitor.ignore_patterns or None,
+                include_patterns=self._config.monitor.include_patterns or None,
+            )
+            for path in source_path.rglob("*"):
+                if path.is_file() and filter.include_file(str(path)):
                     doc = await self._create_document_from_file(
-                        file_path, title=None, metadata=metadata
+                        path, title=None, metadata=metadata
                     )
                     documents.append(doc)
             return documents
@@ -424,7 +423,11 @@ class HaikuRAG:
         return await self.document_repository.list_all(limit=limit, offset=offset)
 
     async def search(
-        self, query: str, limit: int = 5, search_type: str = "hybrid"
+        self,
+        query: str,
+        limit: int = 5,
+        search_type: str = "hybrid",
+        filter: str | None = None,
     ) -> list[tuple[Chunk, float]]:
         """Search for relevant chunks using the specified search method with optional reranking.
 
@@ -432,6 +435,7 @@ class HaikuRAG:
             query: The search query string.
             limit: Maximum number of results to return.
             search_type: Type of search - "vector", "fts", or "hybrid" (default).
+            filter: Optional SQL WHERE clause to filter documents before searching chunks.
 
         Returns:
             List of (chunk, score) tuples ordered by relevance.
@@ -441,12 +445,12 @@ class HaikuRAG:
 
         if reranker is None:
             # No reranking - return direct search results
-            return await self.chunk_repository.search(query, limit, search_type)
+            return await self.chunk_repository.search(query, limit, search_type, filter)
 
         # Get more initial results (3X) for reranking
         search_limit = limit * 3
         search_results = await self.chunk_repository.search(
-            query, search_limit, search_type
+            query, search_limit, search_type, filter
         )
 
         # Apply reranking

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/monitor.py

@@ -40,6 +40,14 @@ class FileFilter(DefaultFilter):
         super().__init__()
 
     def __call__(self, change: Change, path: str) -> bool:
+        if not self.include_file(path):
+            return False
+
+        # Apply default watchfiles filter
+        return super().__call__(change, path)
+
+    def include_file(self, path: str) -> bool:
+        """Check if a file should be included based on filters."""
         # Check extension filter
         if not path.endswith(self.extensions):
             return False
@@ -54,8 +62,7 @@ class FileFilter(DefaultFilter):
             if self.ignore_spec.match_file(path):
                 return False
 
-        # Apply default watchfiles filter
-        return super().__call__(change, path)
+        return True
 
 
 class FileWatcher:

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/reranking/__init__.py

@@ -41,5 +41,23 @@ def get_reranker(config: AppConfig = Config) -> RerankerBase | None:
         except ImportError:
             reranker = None
 
+    elif config.reranking.provider == "vllm":
+        try:
+            from haiku.rag.reranking.vllm import VLLMReranker
+
+            reranker = VLLMReranker(config.reranking.model)
+        except ImportError:
+            reranker = None
+
+    elif config.reranking.provider == "zeroentropy":
+        try:
+            from haiku.rag.reranking.zeroentropy import ZeroEntropyReranker
+
+            # Use configured model or default to zerank-1
+            model = config.reranking.model or "zerank-1"
+            reranker = ZeroEntropyReranker(model)
+        except ImportError:
+            reranker = None
+
     _reranker_cache[config_id] = reranker
     return reranker

haiku_rag-0.13.3/src/haiku/rag/reranking/zeroentropy.py

@@ -0,0 +1,59 @@
+from zeroentropy import ZeroEntropy
+
+from haiku.rag.reranking.base import RerankerBase
+from haiku.rag.store.models.chunk import Chunk
+
+
+class ZeroEntropyReranker(RerankerBase):
+    """Zero Entropy reranker implementation using the zerank-1 model."""
+
+    def __init__(self, model: str = "zerank-1"):
+        """Initialize the Zero Entropy reranker.
+
+        Args:
+            model: The Zero Entropy model to use (default: "zerank-1")
+        """
+        self._model = model
+        # Zero Entropy SDK reads ZEROENTROPY_API_KEY from environment by default
+        self._client = ZeroEntropy()
+
+    async def rerank(
+        self, query: str, chunks: list[Chunk], top_n: int = 10
+    ) -> list[tuple[Chunk, float]]:
+        """Rerank the given chunks based on relevance to the query.
+
+        Args:
+            query: The query to rank against
+            chunks: The chunks to rerank
+            top_n: The number of top results to return
+
+        Returns:
+            A list of (chunk, score) tuples, sorted by relevance
+        """
+        if not chunks:
+            return []
+
+        # Prepare documents for Zero Entropy API
+        documents = [chunk.content for chunk in chunks]
+
+        # Call Zero Entropy reranking API
+        response = self._client.models.rerank(
+            model=self._model,
+            query=query,
+            documents=documents,
+        )
+
+        # Extract results and map back to chunks
+        # Zero Entropy returns results sorted by relevance with scores
+        reranked_results = []
+
+        # Get top_n results
+        for i, result in enumerate(response.results[:top_n]):
+            # Zero Entropy returns index and score for each document
+            chunk_index = result.index
+            score = result.relevance_score
+
+            if chunk_index < len(chunks):
+                reranked_results.append((chunks[chunk_index], score))
+
+        return reranked_results

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/src/haiku/rag/store/repositories/chunk.py

@@ -230,7 +230,11 @@ class ChunkRepository:
         return True
 
     async def search(
-        self, query: str, limit: int = 5, search_type: str = "hybrid"
+        self,
+        query: str,
+        limit: int = 5,
+        search_type: str = "hybrid",
+        filter: str | None = None,
     ) -> list[tuple[Chunk, float]]:
         """Search for relevant chunks using the specified search method.
 
@@ -238,6 +242,7 @@ class ChunkRepository:
             query: The search query string.
             limit: Maximum number of results to return.
             search_type: Type of search - "vector", "fts", or "hybrid" (default).
+            filter: Optional SQL WHERE clause to filter documents before searching chunks.
 
         Returns:
             List of (chunk, score) tuples ordered by relevance.
@@ -245,19 +250,42 @@ class ChunkRepository:
         if not query.strip():
             return []
 
+        chunk_where_clause = None
+        if filter:
+            # We perform filtering as a two-step process, first filtering documents, then
+            # filtering chunks based on those document IDs.
+            # This is because LanceDB does not support joins directly in search queries.
+            matching_doc_ids = self._get_filtered_document_ids(filter)
+
+            if not matching_doc_ids:
+                return []
+
+            # Build WHERE clause for chunks table
+            # Use IN clause with document IDs
+            id_list = "', '".join(matching_doc_ids)
+            chunk_where_clause = f"document_id IN ('{id_list}')"
+
         if search_type == "vector":
             query_embedding = await self.embedder.embed(query)
 
             results = self.store.chunks_table.search(
                 query_embedding, query_type="vector", vector_column_name="vector"
-            ).limit(limit)
+            )
+
+            if chunk_where_clause:
+                results = results.where(chunk_where_clause)
+
+            results = results.limit(limit)
 
             return await self._process_search_results(results)
 
         elif search_type == "fts":
-            results = self.store.chunks_table.search(query, query_type="fts").limit(
-                limit
-            )
+            results = self.store.chunks_table.search(query, query_type="fts")
+
+            if chunk_where_clause:
+                results = results.where(chunk_where_clause)
+
+            results = results.limit(limit)
             return await self._process_search_results(results)
 
         else:  # hybrid (default)
@@ -267,9 +295,13 @@ class ChunkRepository:
             reranker = RRFReranker()
 
             # Perform native hybrid search with RRF reranking
+            results = self.store.chunks_table.search(query_type="hybrid")
+
+            if chunk_where_clause:
+                results = results.where(chunk_where_clause)
+
             results = (
-                self.store.chunks_table.search(query_type="hybrid")
-                .vector(query_embedding)
+                results.vector(query_embedding)
                 .text(query)
                 .rerank(reranker)
                 .limit(limit)
@@ -332,6 +364,15 @@ class ChunkRepository:
 
         return adjacent_chunks
 
+    def _get_filtered_document_ids(self, filter: str) -> list[str]:
+        """Query documents table with filter and return matching document IDs."""
+        filtered_docs = (
+            self.store.documents_table.search()
+            .where(filter)
+            .to_pydantic(DocumentRecord)
+        )
+        return [doc.id for doc in filtered_docs]
+
     async def _process_search_results(self, query_result) -> list[tuple[Chunk, float]]:
         """Process search results into chunks with document info and scores."""
         chunks_with_scores = []

{haiku_rag-0.13.2 → haiku_rag-0.13.3}/uv.lock

@@ -1150,7 +1150,7 @@ wheels = [
 
 [[package]]
 name = "haiku-rag"
-version = "0.13.2"
+version = "0.13.3"
 source = { editable = "." }
 dependencies = [
     { name = "docling" },
@@ -1173,12 +1173,18 @@ dependencies = [
 a2a = [
     { name = "fasta2a" },
 ]
+cohere = [
+    { name = "cohere" },
+]
 mxbai = [
     { name = "mxbai-rerank" },
 ]
 voyageai = [
     { name = "voyageai" },
 ]
+zeroentropy = [
+    { name = "zeroentropy" },
+]
 
 [package.dev-dependencies]
 dev = [
@@ -1197,6 +1203,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "cohere", marker = "extra == 'cohere'", specifier = ">=5.0.0" },
     { name = "docling", specifier = ">=2.58.0" },
     { name = "fasta2a", marker = "extra == 'a2a'", specifier = ">=0.1.0" },
     { name = "fastmcp", specifier = ">=2.13.0.2" },
@@ -1214,8 +1221,9 @@ requires-dist = [
     { name = "typer", specifier = ">=0.19.2,<0.20.0" },
     { name = "voyageai", marker = "extra == 'voyageai'", specifier = ">=0.3.5" },
     { name = "watchfiles", specifier = ">=1.1.1" },
+    { name = "zeroentropy", marker = "extra == 'zeroentropy'", specifier = ">=0.1.0a6" },
 ]
-provides-extras = ["voyageai", "mxbai", "a2a"]
+provides-extras = ["voyageai", "mxbai", "a2a", "cohere", "zeroentropy"]
 
 [package.metadata.requires-dev]
 dev = [
@@ -4718,6 +4726,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b4/2d/2345fce04cfd4bee161bf1e7d9cdc702e3e16109021035dbb24db654a622/yarl-1.20.1-py3-none-any.whl", hash = "sha256:83b8eb083fe4683c6115795d9fc1cfaf2cbbefb19b3a1cb68f6527460f483a77", size = 46542, upload-time = "2025-06-10T00:46:07.521Z" },
 ]
 
+[[package]]
+name = "zeroentropy"
+version = "0.1.0a6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "distro" },
+    { name = "httpx" },
+    { name = "pydantic" },
+    { name = "sniffio" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/08/14/05c8caaa25ae64008c2f5b021cefd30276f00845d99bab4763be300da93a/zeroentropy-0.1.0a6.tar.gz", hash = "sha256:04f38e7b40f39cfdd4bb16df0ab0b18d8f33d516c1e9a39e0494a5fb7fba358d", size = 112726, upload-time = "2025-07-08T01:51:42.796Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/7e/594e9ec5cda6d8f4dc249c5ca0c6b31b19886eafedcea6c41a2400a2a7b9/zeroentropy-0.1.0a6-py3-none-any.whl", hash = "sha256:0caa6c4a450af80892d42848036eea0b766e3fe0bf6a097a613ab9403fdf5ad6", size = 101501, upload-time = "2025-07-08T01:51:41.527Z" },
+]
+
 [[package]]
 name = "zipp"
 version = "3.23.0"