hindsight-api 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

hindsight_api/pg0.py

@@ -1,373 +1,116 @@
 import asyncio
-import json
 import logging
-import os
-import platform
-import re
-import shutil
-import stat
-import subprocess
-from pathlib import Path
 from typing import Optional
 
-import httpx
+from pg0 import Pg0
 
 logger = logging.getLogger(__name__)
 
-# pg0 configuration
-BINARY_NAME = "pg0"
 DEFAULT_PORT = 5555
 DEFAULT_USERNAME = "hindsight"
 DEFAULT_PASSWORD = "hindsight"
 DEFAULT_DATABASE = "hindsight"
 
 
-def get_platform_binary_name() -> str:
-    """Get the appropriate binary name for the current platform.
-
-    Supported platforms:
-    - macOS ARM64 (darwin-aarch64)
-    - Linux x86_64 (gnu)
-    - Linux ARM64 (gnu)
-    - Windows x86_64
-    """
-    system = platform.system().lower()
-    machine = platform.machine().lower()
-
-    # Normalize architecture names
-    if machine in ("x86_64", "amd64"):
-        arch = "x86_64"
-    elif machine in ("arm64", "aarch64"):
-        arch = "aarch64"
-    else:
-        raise RuntimeError(
-            f"Embedded PostgreSQL is not supported on architecture: {machine}. "
-            f"Supported architectures: x86_64/amd64 (Linux, Windows), aarch64/arm64 (macOS, Linux)"
-        )
-
-    if system == "darwin" and arch == "aarch64":
-        return "pg0-darwin-aarch64"
-    elif system == "linux" and arch == "x86_64":
-        return "pg0-linux-x86_64-gnu"
-    elif system == "linux" and arch == "aarch64":
-        return "pg0-linux-aarch64-gnu"
-    elif system == "windows" and arch == "x86_64":
-        return "pg0-windows-x86_64.exe"
-    else:
-        raise RuntimeError(
-            f"Embedded PostgreSQL is not supported on {system}-{arch}. "
-            f"Supported platforms: darwin-aarch64 (macOS ARM), linux-x86_64-gnu, linux-aarch64-gnu, windows-x86_64"
-        )
-
-
-def get_download_url(
-    version: str = "latest",
-    repo: str = "vectorize-io/pg0",
-) -> str:
-    """Get the download URL for pg0 binary."""
-    binary_name = get_platform_binary_name()
-
-    if version == "latest":
-        return f"https://github.com/{repo}/releases/latest/download/{binary_name}"
-    else:
-        return f"https://github.com/{repo}/releases/download/{version}/{binary_name}"
-
-
-def _find_pg0_binary() -> Optional[Path]:
-    """Find pg0 binary in PATH or default install location."""
-    # First check PATH
-    pg0_in_path = shutil.which("pg0")
-    if pg0_in_path:
-        return Path(pg0_in_path)
-
-    # Fall back to default install location
-    default_path = Path.home() / ".hindsight" / "bin" / "pg0"
-    if default_path.exists() and os.access(default_path, os.X_OK):
-        return default_path
-
-    return None
-
-
 class EmbeddedPostgres:
-    """
-    Manages an embedded PostgreSQL server instance using pg0.
-
-    This class handles:
-    - Finding or downloading the pg0 CLI
-    - Starting/stopping the PostgreSQL server
-    - Getting the connection URI
-
-    Example:
-        pg = EmbeddedPostgres()
-        await pg.ensure_installed()
-        await pg.start()
-        uri = await pg.get_uri()
-        # ... use uri with asyncpg ...
-        await pg.stop()
-    """
+    """Manages an embedded PostgreSQL server instance using pg0-embedded."""
 
     def __init__(
         self,
-        version: str = "latest",
         port: int = DEFAULT_PORT,
         username: str = DEFAULT_USERNAME,
         password: str = DEFAULT_PASSWORD,
         database: str = DEFAULT_DATABASE,
         name: str = "hindsight",
+        **kwargs,
     ):
-        """
-        Initialize the embedded PostgreSQL manager.
-
-        Args:
-            version: Version of pg0 to download if not found. Defaults to "latest"
-            port: Port to listen on. Defaults to 5555
-            username: Username for the database. Defaults to "hindsight"
-            password: Password for the database. Defaults to "hindsight"
-            database: Database name to create. Defaults to "hindsight"
-            name: Instance name for pg0. Defaults to "hindsight"
-        """
-        self.version = version
         self.port = port
         self.username = username
         self.password = password
         self.database = database
         self.name = name
-
-        # Will be set when binary is found/installed
-        self._binary_path: Optional[Path] = _find_pg0_binary()
-
-    @property
-    def binary_path(self) -> Path:
-        """Get the path to the pg0 binary."""
-        if self._binary_path is None:
-            # Default install location
-            return Path.home() / ".hindsight" / "bin" / "pg0"
-        return self._binary_path
-
-    def is_installed(self) -> bool:
-        """Check if pg0 is available (in PATH or installed)."""
-        self._binary_path = _find_pg0_binary()
-        return self._binary_path is not None
-
-    async def ensure_installed(self) -> None:
-        """
-        Ensure pg0 is available.
-
-        Checks PATH and default location. If not found, raises an error
-        instructing the user to install pg0 manually.
-        """
-        if self.is_installed():
-            logger.debug(f"pg0 found at {self._binary_path}")
-            return
-
-        raise RuntimeError(
-            "pg0 is not installed. Please install it manually:\n"
-            "  curl -fsSL https://github.com/vectorize-io/pg0/releases/latest/download/pg0-linux-amd64 -o ~/.local/bin/pg0 && chmod +x ~/.local/bin/pg0\n"
-            "Or visit: https://github.com/vectorize-io/pg0/releases"
-        )
-
-    def _run_command(self, *args: str, capture_output: bool = True) -> subprocess.CompletedProcess:
-        """Run a pg0 command synchronously."""
-        cmd = [str(self.binary_path), *args]
-        return subprocess.run(cmd, capture_output=capture_output, text=True)
-
-    async def _run_command_async(self, *args: str, timeout: int = 120) -> tuple[int, str, str]:
-        """Run a pg0 command asynchronously."""
-        cmd = [str(self.binary_path), *args]
-
-        def run_sync():
-            try:
-                result = subprocess.run(
-                    cmd,
-                    stdin=subprocess.DEVNULL,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    text=True,
-                    timeout=timeout,
-                )
-                return result.returncode, result.stdout, result.stderr
-            except subprocess.TimeoutExpired:
-                return 1, "", "Command timed out"
-
-        loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, run_sync)
-
-    def _extract_uri_from_output(self, output: str) -> Optional[str]:
-        """Extract the PostgreSQL URI from pg0 start output."""
-        match = re.search(r"Connection URI:\s*(postgresql://[^\s]+)", output)
-        if match:
-            return match.group(1)
-        return None
-
-    async def _get_version(self) -> str:
-        """Get the pg0 version."""
-        returncode, stdout, stderr = await self._run_command_async("--version", timeout=10)
-        if returncode == 0 and stdout:
-            return stdout.strip()
-        return "unknown"
+        self._pg0: Optional[Pg0] = None
+
+    def _get_pg0(self) -> Pg0:
+        if self._pg0 is None:
+            self._pg0 = Pg0(
+                name=self.name,
+                port=self.port,
+                username=self.username,
+                password=self.password,
+                database=self.database,
+            )
+        return self._pg0
 
     async def start(self, max_retries: int = 3, retry_delay: float = 2.0) -> str:
-        """
-        Start the PostgreSQL server with retry logic.
-
-        Args:
-            max_retries: Maximum number of start attempts (default: 3)
-            retry_delay: Initial delay between retries in seconds (default: 2.0)
-
-        Returns:
-            The connection URI for the started server.
-
-        Raises:
-            RuntimeError: If the server fails to start after all retries.
-        """
-        if not self.is_installed():
-            raise RuntimeError("pg0 is not installed. Call ensure_installed() first.")
-
-        # Log pg0 version
-        version = await self._get_version()
-        logger.info(f"Starting embedded PostgreSQL with pg0 {version} (name: {self.name}, port: {self.port})...")
+        """Start the PostgreSQL server with retry logic."""
+        logger.info(f"Starting embedded PostgreSQL (name: {self.name}, port: {self.port})...")
 
+        pg0 = self._get_pg0()
         last_error = None
-        for attempt in range(1, max_retries + 1):
-            returncode, stdout, stderr = await self._run_command_async(
-                "start",
-                "--name", self.name,
-                "--port", str(self.port),
-                "--username", self.username,
-                "--password", self.password,
-                "--database", self.database,
-                timeout=300,
-            )
-
-            # Try to extract URI from output
-            uri = self._extract_uri_from_output(stdout)
-            if uri:
-                logger.info(f"PostgreSQL started on port {self.port}")
-                return uri
 
-            # Check if pg0 info can find the running instance
+        for attempt in range(1, max_retries + 1):
             try:
-                uri = await self.get_uri()
+                loop = asyncio.get_event_loop()
+                info = await loop.run_in_executor(None, pg0.start)
                 logger.info(f"PostgreSQL started on port {self.port}")
+                # Construct URI manually since pg0-embedded may return None
+                uri = info.uri if info and info.uri else f"postgresql://{self.username}:{self.password}@localhost:{self.port}/{self.database}"
                 return uri
-            except RuntimeError:
-                pass
+            except Exception as e:
+                last_error = str(e)
+                if attempt < max_retries:
+                    delay = retry_delay * (2 ** (attempt - 1))
+                    logger.debug(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error}")
+                    logger.debug(f"Retrying in {delay:.1f}s...")
+                    await asyncio.sleep(delay)
+                else:
+                    logger.debug(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error}")
 
-            # Start failed, log and retry
-            last_error = stderr or f"pg0 start returned exit code {returncode}"
-            if attempt < max_retries:
-                delay = retry_delay * (2 ** (attempt - 1))
-                logger.debug(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error.strip()}")
-                logger.debug(f"Retrying in {delay:.1f}s...")
-                await asyncio.sleep(delay)
-            else:
-                logger.debug(f"pg0 start attempt {attempt}/{max_retries} failed: {last_error.strip()}")
-
-        # All retries exhausted - fail
         raise RuntimeError(
             f"Failed to start embedded PostgreSQL after {max_retries} attempts. "
-            f"Last error: {last_error.strip() if last_error else 'unknown'}"
+            f"Last error: {last_error}"
         )
 
     async def stop(self) -> None:
         """Stop the PostgreSQL server."""
-        if not self.is_installed():
-            return
-
+        pg0 = self._get_pg0()
         logger.info(f"Stopping embedded PostgreSQL (name: {self.name})...")
 
-        returncode, stdout, stderr = await self._run_command_async("stop", "--name", self.name)
-
-        if returncode != 0:
-            if "not running" in stderr.lower():
-                return
-            raise RuntimeError(f"Failed to stop PostgreSQL: {stderr}")
-
-        logger.info("Embedded PostgreSQL stopped")
-
-    async def _get_info(self) -> dict:
-        """Get info from pg0 using the `info -o json` command."""
-        if not self.is_installed():
-            raise RuntimeError("pg0 is not installed.")
-
-        returncode, stdout, stderr = await self._run_command_async(
-            "info", "--name", self.name, "-o", "json"
-        )
-
-        if returncode != 0:
-            raise RuntimeError(f"Failed to get PostgreSQL info: {stderr}")
-
         try:
-            return json.loads(stdout.strip())
-        except json.JSONDecodeError as e:
-            raise RuntimeError(f"Failed to parse pg0 info output: {e}")
+            loop = asyncio.get_event_loop()
+            await loop.run_in_executor(None, pg0.stop)
+            logger.info("Embedded PostgreSQL stopped")
+        except Exception as e:
+            if "not running" in str(e).lower():
+                return
+            raise RuntimeError(f"Failed to stop PostgreSQL: {e}")
 
     async def get_uri(self) -> str:
         """Get the connection URI for the PostgreSQL server."""
-        info = await self._get_info()
-        uri = info.get("uri")
-        if not uri:
-            raise RuntimeError("PostgreSQL server is not running or URI not available")
+        pg0 = self._get_pg0()
+        loop = asyncio.get_event_loop()
+        info = await loop.run_in_executor(None, pg0.info)
+        # Construct URI manually since pg0-embedded may return None
+        uri = info.uri if info and info.uri else f"postgresql://{self.username}:{self.password}@localhost:{self.port}/{self.database}"
         return uri
 
-    async def status(self) -> dict:
-        """Get the status of the PostgreSQL server."""
-        if not self.is_installed():
-            return {"installed": False, "running": False}
-
-        try:
-            info = await self._get_info()
-            return {
-                "installed": True,
-                "running": info.get("running", False),
-                "uri": info.get("uri"),
-            }
-        except RuntimeError:
-            return {"installed": True, "running": False}
-
     async def is_running(self) -> bool:
         """Check if the PostgreSQL server is currently running."""
-        if not self.is_installed():
-            return False
         try:
-            info = await self._get_info()
-            return info.get("running", False)
-        except RuntimeError:
+            pg0 = self._get_pg0()
+            loop = asyncio.get_event_loop()
+            info = await loop.run_in_executor(None, pg0.info)
+            return info is not None and info.running
+        except Exception:
             return False
 
     async def ensure_running(self) -> str:
-        """
-        Ensure the PostgreSQL server is running.
-
-        Installs if needed, starts if not running.
-
-        Returns:
-            The connection URI.
-        """
-        await self.ensure_installed()
-
+        """Ensure the PostgreSQL server is running, starting it if needed."""
         if await self.is_running():
             return await self.get_uri()
-
         return await self.start()
 
-    def uninstall(self) -> None:
-        """Remove the pg0 binary (only if we installed it)."""
-        default_path = Path.home() / ".hindsight" / "bin" / "pg0"
-        if default_path.exists():
-            default_path.unlink()
-            logger.info(f"Removed {default_path}")
-
-    def clear_data(self) -> None:
-        """Remove all PostgreSQL data (destructive!)."""
-        result = self._run_command("drop", "--name", self.name, "--force")
-        if result.returncode == 0:
-            logger.info(f"Dropped pg0 instance {self.name}")
-        else:
-            logger.warning(f"Failed to drop pg0 instance {self.name}: {result.stderr}")
-
-
-# Convenience functions
 
 _default_instance: Optional[EmbeddedPostgres] = None
 
@@ -375,33 +118,18 @@ _default_instance: Optional[EmbeddedPostgres] = None
 def get_embedded_postgres() -> EmbeddedPostgres:
     """Get or create the default EmbeddedPostgres instance."""
     global _default_instance
-
     if _default_instance is None:
         _default_instance = EmbeddedPostgres()
-
     return _default_instance
 
 
 async def start_embedded_postgres() -> str:
-    """
-    Quick start function for embedded PostgreSQL.
-
-    Downloads, installs, and starts PostgreSQL in one call.
-
-    Returns:
-        Connection URI string
-
-    Example:
-        db_url = await start_embedded_postgres()
-        conn = await asyncpg.connect(db_url)
-    """
-    pg = get_embedded_postgres()
-    return await pg.ensure_running()
+    """Quick start function for embedded PostgreSQL."""
+    return await get_embedded_postgres().ensure_running()
 
 
 async def stop_embedded_postgres() -> None:
     """Stop the default embedded PostgreSQL instance."""
     global _default_instance
-
     if _default_instance:
         await _default_instance.stop()

{hindsight_api-0.1.4.dist-info → hindsight_api-0.1.5.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: hindsight-api
-Version: 0.1.4
+Version: 0.1.5
 Summary: Temporal + Semantic + Entity Memory System for AI agents using PostgreSQL
 Requires-Python: >=3.11
 Requires-Dist: alembic>=1.17.1
 Requires-Dist: asyncpg>=0.29.0
 Requires-Dist: dateparser>=1.2.2
 Requires-Dist: fastapi[standard]>=0.120.3
-Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: fastmcp>=2.3.0
 Requires-Dist: google-genai>=1.0.0
 Requires-Dist: greenlet>=3.2.4
 Requires-Dist: httpx>=0.27.0
@@ -17,17 +17,18 @@ Requires-Dist: opentelemetry-api>=1.20.0
 Requires-Dist: opentelemetry-exporter-prometheus>=0.41b0
 Requires-Dist: opentelemetry-instrumentation-fastapi>=0.41b0
 Requires-Dist: opentelemetry-sdk>=1.20.0
+Requires-Dist: pg0-embedded>=0.1.0
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: psycopg2-binary>=2.9.11
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dateutil>=2.8.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
-Requires-Dist: sentence-transformers>=3.0.0
+Requires-Dist: sentence-transformers<3.3.0,>=3.0.0
 Requires-Dist: sqlalchemy>=2.0.44
 Requires-Dist: tiktoken>=0.12.0
-Requires-Dist: torch>=2.0.0
-Requires-Dist: transformers>=4.30.0
+Requires-Dist: torch<2.6.0,>=2.0.0
+Requires-Dist: transformers<4.46.0,>=4.30.0
 Requires-Dist: uvicorn>=0.38.0
 Requires-Dist: wsproto>=1.0.0
 Provides-Extra: test

{hindsight_api-0.1.4.dist-info → hindsight_api-0.1.5.dist-info}/RECORD

@@ -1,11 +1,11 @@
 hindsight_api/__init__.py,sha256=gPkRHnMATZqBgc7b-Mcro4f_gY9W0BlnGBE0zg1t_IY,1139
 hindsight_api/banner.py,sha256=0dsNMXZSuOlj5lkzFykYB19BBOaePgzDTPydPEFel9M,4604
-hindsight_api/config.py,sha256=k2WoA2VAaeAiB0M1JHckl_lO8idC6D1ouxVlIS6w9-g,5180
+hindsight_api/config.py,sha256=rZveBJXViU2q7TrcY5KQnVCN3WpqXAtbp8kLMgjgy-U,5502
 hindsight_api/main.py,sha256=aPftkauWHDaC7We0OF08EsDYuwjBHMZTPznoan-nxnc,6131
 hindsight_api/metrics.py,sha256=j4-eeqVjjcGQxAxS_GgEaBNm10KdUxrGS_I2d1IM1hY,7255
 hindsight_api/migrations.py,sha256=nSbU37ZszVZifYJTU_vEXfusTxWaUea9dRi7-Ao3-SQ,7349
 hindsight_api/models.py,sha256=ncIi8agl3PVk7ffyXlJosFym1jJZZhVmXTguZ3EnAEc,12515
-hindsight_api/pg0.py,sha256=MwZ0KW9_Vm2YTIO27j_YoK8zQQPc06YXD7Z7xJgZ59U,13503
+hindsight_api/pg0.py,sha256=cGAnMif5mFeBV2XCmOPKsDajU6o0L-qud7VOKt0gchk,4786
 hindsight_api/server.py,sha256=C_w3_xzKRVkSsFkujhMz9S4nDlAc0eOFClGIefTCZIk,1263
 hindsight_api/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
 hindsight_api/alembic/env.py,sha256=i0gc3GN2rWidtqRp-vdvnJTIR0zl1X4Uokqp_WnTsAo,4837
@@ -18,14 +18,14 @@ hindsight_api/alembic/versions/e0a1b2c3d4e5_disposition_to_3_traits.py,sha256=fy
 hindsight_api/alembic/versions/rename_personality_to_disposition.py,sha256=xlp-Is96e3TvCwSqhPctQRqLBHcl3dvDmlzbCMZGw1A,2196
 hindsight_api/api/__init__.py,sha256=dIJqoygqYaEgm-Bd7qwZ4UTnb9UPyXtlDxZnQpvVC0o,2946
 hindsight_api/api/http.py,sha256=G23QBZw097boDBNYeox_MdfLWdmDUZczrakTvGTzb3Q,71195
-hindsight_api/api/mcp.py,sha256=DldtC8LQUguAbJSSHnEBS65wC-AQBjcF8rl51xUR1gQ,7808
+hindsight_api/api/mcp.py,sha256=Ugkb4LtGAvi0IvO2wLvJzK62KUGTOmNpYEt1f3R-674,7584
 hindsight_api/engine/__init__.py,sha256=W_y6iAHgu-HUpvdXlI6JJ0KO42wVkrWvcUSJZqTCj_M,1406
-hindsight_api/engine/cross_encoder.py,sha256=D6iTTXv23R1n8O_IoAsBCsCbevZTNhnJSt4AirADksg,10789
+hindsight_api/engine/cross_encoder.py,sha256=0LfuhhvL2wmafAxH0VytcmVAV0X5RzrfZKskOEVj8jI,10489
 hindsight_api/engine/db_utils.py,sha256=p1Ne70wPP327xdPI_XjMfnagilY8sknbkhEIZuED6DU,2724
 hindsight_api/engine/embeddings.py,sha256=RdK9A3lUjp1FZFArllhTgKo70Pot4ZUEJ1Pw70BpNmk,10218
 hindsight_api/engine/entity_resolver.py,sha256=w5DPCuYNsK4GF8Qe3oY7jCKcOT1WYx2h0YD1nX0QRtA,23184
-hindsight_api/engine/llm_wrapper.py,sha256=d1v6DdmoYfmfb6MgJbviekH2Hlo3L1bamKKE_TVNw7k,21112
-hindsight_api/engine/memory_engine.py,sha256=QDCZ4scEjkyTLtEV6XSjnRiWhew5huoEds0CHw12bvA,134924
+hindsight_api/engine/llm_wrapper.py,sha256=SEzgGJRMVCOwt67J5Ggjyayk-7fWiD7OLbwYLDjsdOw,21401
+hindsight_api/engine/memory_engine.py,sha256=saE8flEFNIP9I0XQ7HiNBwo2-hK63e5MVGGEVQxV7oU,135905
 hindsight_api/engine/query_analyzer.py,sha256=K0QCg7tsbqtwC7TR5wt3FPoP8QDuZsX9r0Zljc8nnYo,19733
 hindsight_api/engine/response_models.py,sha256=e-_vE1zAVFLpkl6SeHIYvHcQ4Z-AaOdq0jjjhh8yHk4,8683
 hindsight_api/engine/task_backend.py,sha256=ojxMC9PeHdnkWVs2ozeqycjI_1mmpkDa0_Qfej9AHrg,7287
@@ -44,18 +44,20 @@ hindsight_api/engine/retain/link_utils.py,sha256=kTMxO9fOXHQvRJZ-gsTrdrKmfw16trW
 hindsight_api/engine/retain/observation_regeneration.py,sha256=ykEMZihF1Vt8Z7427k1OJKyEjYp0qIs9P1IqP6eyI58,8069
 hindsight_api/engine/retain/orchestrator.py,sha256=z71wMuJsdjLFlhhwnLHuJ3Y3QQk-9w_faKn1zZUYCXw,17156
 hindsight_api/engine/retain/types.py,sha256=JJ4t8Qtp64kTPB9CKOFDXqdos2i8GZXmJZNzBDaNwHY,6514
-hindsight_api/engine/search/__init__.py,sha256=7X6U10bVw0JRWxQdE5RCfVpawDlSUldi1mPoCzY0V0A,363
+hindsight_api/engine/search/__init__.py,sha256=Ug0TLmgHRR1Dv2gkxXsYwAe4TxuYnjYjXPufuijcMsI,802
 hindsight_api/engine/search/fusion.py,sha256=so6LU7kWRR-VJd1Pxlu8idRJ7P2WLCoDwXUnb8jQifo,4309
+hindsight_api/engine/search/graph_retrieval.py,sha256=hHscHqTIrX4eCUuZXX3R7hqH0cUHgKXMVexYljvD3B0,8592
+hindsight_api/engine/search/mpfp_retrieval.py,sha256=L-Aorab-kNocYjymGLwBaAEQusGYCJMwXIEJQIplrBk,14154
 hindsight_api/engine/search/observation_utils.py,sha256=SPrDx6M0daJ_zLLkk78GlQIG3EL7DqMKSu_etKerUfU,4331
 hindsight_api/engine/search/reranking.py,sha256=znjN78VfuT4PqprhGRPd2B9WtVMhAU5A662s0xCvU7g,3329
-hindsight_api/engine/search/retrieval.py,sha256=i6pffxsfYkTjQYS8iNMC60owMr__a8i7khkHb4LUWuI,19661
+hindsight_api/engine/search/retrieval.py,sha256=ekugBzcANz5q6SyIIX00HQza0phVUNU0xL4xqbXwvwk,24998
 hindsight_api/engine/search/scoring.py,sha256=feFPalpbIMndp8j2Ab0zvu7fRq3c43Wmzrjw3piQ0eM,5167
 hindsight_api/engine/search/temporal_extraction.py,sha256=5klrZdza3mkgk5A15_m_j4IIfOHMc6fUR9UJuzLa790,1812
 hindsight_api/engine/search/think_utils.py,sha256=VJJXFmBg03yO4Mg--UBMlTQW9IZOj2eyTZztjzhT8F8,11315
-hindsight_api/engine/search/trace.py,sha256=Hx-siW9yAfqZoK9LG6esbed0vQuHMNsGxSvCg4FK6-4,11042
-hindsight_api/engine/search/tracer.py,sha256=LQ78knpMxyZmPUvm3PJNN2opCyA-LpB47JZ84n0g2pw,15074
-hindsight_api/engine/search/types.py,sha256=qIeHW_gT7f291vteTZXygAM8oAaPp2dq6uEdvOyOwzs,5488
-hindsight_api-0.1.4.dist-info/METADATA,sha256=voQtL9sUm15LNX0M9tiyybr-nl9SwuSZMYU2pk9kRL4,1466
-hindsight_api-0.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-hindsight_api-0.1.4.dist-info/entry_points.txt,sha256=ZDj1gJCi6Ga6VLdPgRSrRizQ4dUTreefjeG_tO1CuHk,58
-hindsight_api-0.1.4.dist-info/RECORD,,
+hindsight_api/engine/search/trace.py,sha256=YYaOQ_OPgxzDdrGlNwxd4Pp6BcDyuCM4wegAp4esZ6U,11170
+hindsight_api/engine/search/tracer.py,sha256=qsMGZ63412dghSbvO8gKYyAT3MzXU_wTY9cJorgIa7E,15399
+hindsight_api/engine/search/types.py,sha256=fAG2BocKLGBQ6dEbT3UzZA1JZaiJlco_BJ5Dz45MKQA,5652
+hindsight_api-0.1.5.dist-info/METADATA,sha256=dhaSenCcXJEspSk8-wVOhpnln6XtJ9aoqv0B_Um818o,1523
+hindsight_api-0.1.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_api-0.1.5.dist-info/entry_points.txt,sha256=ZDj1gJCi6Ga6VLdPgRSrRizQ4dUTreefjeG_tO1CuHk,58
+hindsight_api-0.1.5.dist-info/RECORD,,