hindsight-api 0.3.0__py3-none-any.whl → 0.4.1__py3-none-any.whl

hindsight_api/worker/poller.py

@@ -0,0 +1,486 @@
+"""
+Worker poller for distributed task execution.
+
+Polls PostgreSQL for pending tasks and executes them using
+FOR UPDATE SKIP LOCKED for safe concurrent claiming.
+"""
+
+import asyncio
+import json
+import logging
+import time
+import traceback
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import asyncpg
+
+    from hindsight_api.extensions.tenant import TenantExtension
+
+logger = logging.getLogger(__name__)
+
+# Progress logging interval in seconds
+PROGRESS_LOG_INTERVAL = 30
+
+
+def fq_table(table: str, schema: str | None = None) -> str:
+    """Get fully-qualified table name with optional schema prefix."""
+    if schema:
+        return f'"{schema}".{table}'
+    return table
+
+
+@dataclass
+class ClaimedTask:
+    """A task claimed from the database with its schema context."""
+
+    operation_id: str
+    task_dict: dict[str, Any]
+    schema: str | None
+
+
+class WorkerPoller:
+    """
+    Polls PostgreSQL for pending tasks and executes them.
+
+    Uses FOR UPDATE SKIP LOCKED for safe distributed claiming,
+    allowing multiple workers to process tasks without conflicts.
+
+    Supports dynamic multi-tenant discovery via tenant_extension.
+    """
+
+    def __init__(
+        self,
+        pool: "asyncpg.Pool",
+        worker_id: str,
+        executor: Callable[[dict[str, Any]], Awaitable[None]],
+        poll_interval_ms: int = 500,
+        batch_size: int = 10,
+        max_retries: int = 3,
+        schema: str | None = None,
+        tenant_extension: "TenantExtension | None" = None,
+    ):
+        """
+        Initialize the worker poller.
+
+        Args:
+            pool: asyncpg connection pool
+            worker_id: Unique identifier for this worker
+            executor: Async function to execute tasks (typically MemoryEngine.execute_task)
+            poll_interval_ms: Interval between polls when no tasks found (milliseconds)
+            batch_size: Maximum number of tasks to claim per poll cycle
+            max_retries: Maximum retry attempts before marking task as failed
+            schema: Database schema for single-tenant support (ignored if tenant_extension is set)
+            tenant_extension: Extension for dynamic multi-tenant discovery. If set, list_tenants()
+                            is called on each poll cycle to discover schemas dynamically.
+        """
+        self._pool = pool
+        self._worker_id = worker_id
+        self._executor = executor
+        self._poll_interval_ms = poll_interval_ms
+        self._batch_size = batch_size
+        self._max_retries = max_retries
+        self._schema = schema
+        self._tenant_extension = tenant_extension
+        self._shutdown = asyncio.Event()
+        self._current_tasks: set[asyncio.Task] = set()
+        self._in_flight_count = 0
+        self._in_flight_lock = asyncio.Lock()
+        self._last_progress_log = 0.0
+        self._tasks_completed_since_log = 0
+        # Track active tasks locally: operation_id -> (op_type, bank_id, schema)
+        self._active_tasks: dict[str, tuple[str, str, str | None]] = {}
+
+    async def _get_schemas(self) -> list[str | None]:
+        """Get list of schemas to poll. Returns [None] for public schema."""
+        if self._tenant_extension is not None:
+            tenants = await self._tenant_extension.list_tenants()
+            # Convert "public" to None for SQL compatibility, keep others as-is
+            return [t.schema if t.schema != "public" else None for t in tenants]
+        # Single schema mode
+        return [self._schema]
+
+    async def claim_batch(self) -> list[ClaimedTask]:
+        """
+        Claim up to batch_size pending tasks atomically across all tenant schemas.
+
+        Uses FOR UPDATE SKIP LOCKED to ensure no conflicts with other workers.
+
+        For consolidation tasks specifically, skips pending tasks if there's already
+        a processing consolidation for the same bank (to avoid duplicate work).
+
+        If tenant_extension is configured, dynamically discovers schemas on each call.
+
+        Returns:
+            List of ClaimedTask objects containing operation_id, task_dict, and schema
+        """
+        schemas = await self._get_schemas()
+        all_tasks: list[ClaimedTask] = []
+        remaining_batch = self._batch_size
+
+        for schema in schemas:
+            if remaining_batch <= 0:
+                break
+
+            tasks = await self._claim_batch_for_schema(schema, remaining_batch)
+            all_tasks.extend(tasks)
+            remaining_batch -= len(tasks)
+
+        return all_tasks
+
+    async def _claim_batch_for_schema(self, schema: str | None, limit: int) -> list[ClaimedTask]:
+        """Claim tasks from a specific schema."""
+        table = fq_table("async_operations", schema)
+
+        async with self._pool.acquire() as conn:
+            async with conn.transaction():
+                # Select and lock pending tasks
+                # For consolidation: skip if same bank already has one processing
+                rows = await conn.fetch(
+                    f"""
+                    SELECT operation_id, task_payload
+                    FROM {table} AS pending
+                    WHERE status = 'pending' AND task_payload IS NOT NULL
+                    AND (
+                        -- Non-consolidation tasks: always claimable
+                        operation_type != 'consolidation'
+                        OR
+                        -- Consolidation: only if no other consolidation processing for same bank
+                        NOT EXISTS (
+                            SELECT 1 FROM {table} AS processing
+                            WHERE processing.bank_id = pending.bank_id
+                            AND processing.operation_type = 'consolidation'
+                            AND processing.status = 'processing'
+                        )
+                    )
+                    ORDER BY created_at
+                    LIMIT $1
+                    FOR UPDATE SKIP LOCKED
+                    """,
+                    limit,
+                )
+
+                if not rows:
+                    return []
+
+                # Claim the tasks by updating status and worker_id
+                operation_ids = [row["operation_id"] for row in rows]
+                await conn.execute(
+                    f"""
+                    UPDATE {table}
+                    SET status = 'processing', worker_id = $1, claimed_at = now(), updated_at = now()
+                    WHERE operation_id = ANY($2)
+                    """,
+                    self._worker_id,
+                    operation_ids,
+                )
+
+                # Parse and return task payloads with schema context
+                return [
+                    ClaimedTask(
+                        operation_id=str(row["operation_id"]),
+                        task_dict=json.loads(row["task_payload"]),
+                        schema=schema,
+                    )
+                    for row in rows
+                ]
+
+    async def _mark_completed(self, operation_id: str, schema: str | None):
+        """Mark a task as completed."""
+        table = fq_table("async_operations", schema)
+        await self._pool.execute(
+            f"""
+            UPDATE {table}
+            SET status = 'completed', completed_at = now(), updated_at = now()
+            WHERE operation_id = $1
+            """,
+            operation_id,
+        )
+
+    async def _mark_failed(self, operation_id: str, error_message: str, schema: str | None):
+        """Mark a task as failed with error message."""
+        table = fq_table("async_operations", schema)
+        # Truncate error message if too long (max 5000 chars in schema)
+        error_message = error_message[:5000] if len(error_message) > 5000 else error_message
+        await self._pool.execute(
+            f"""
+            UPDATE {table}
+            SET status = 'failed', error_message = $2, completed_at = now(), updated_at = now()
+            WHERE operation_id = $1
+            """,
+            operation_id,
+            error_message,
+        )
+
+    async def _retry_or_fail(self, operation_id: str, error_message: str, schema: str | None):
+        """Increment retry count or mark as failed if max retries exceeded."""
+        table = fq_table("async_operations", schema)
+
+        # Get current retry count
+        row = await self._pool.fetchrow(
+            f"SELECT retry_count FROM {table} WHERE operation_id = $1",
+            operation_id,
+        )
+
+        if row is None:
+            logger.warning(f"Operation {operation_id} not found, cannot retry")
+            return
+
+        retry_count = row["retry_count"]
+
+        if retry_count >= self._max_retries:
+            # Max retries exceeded, mark as failed
+            await self._mark_failed(
+                operation_id, f"Max retries ({self._max_retries}) exceeded. Last error: {error_message}", schema
+            )
+            logger.error(f"Task {operation_id} failed after {retry_count} retries")
+        else:
+            # Increment retry and reset to pending
+            await self._pool.execute(
+                f"""
+                UPDATE {table}
+                SET status = 'pending', worker_id = NULL, claimed_at = NULL,
+                    retry_count = retry_count + 1, updated_at = now()
+                WHERE operation_id = $1
+                """,
+                operation_id,
+            )
+            logger.warning(f"Task {operation_id} failed, will retry (attempt {retry_count + 1}/{self._max_retries})")
+
+    async def execute_task(self, task: ClaimedTask):
+        """Execute a single task and update its status."""
+        task_type = task.task_dict.get("type", "unknown")
+        bank_id = task.task_dict.get("bank_id", "unknown")
+
+        # Track this task as active
+        async with self._in_flight_lock:
+            self._active_tasks[task.operation_id] = (task_type, bank_id, task.schema)
+
+        try:
+            schema_info = f", schema={task.schema}" if task.schema else ""
+            logger.debug(f"Executing task {task.operation_id} (type={task_type}, bank={bank_id}{schema_info})")
+            # Pass schema to executor so it can set the correct context
+            if task.schema:
+                task.task_dict["_schema"] = task.schema
+            await self._executor(task.task_dict)
+            await self._mark_completed(task.operation_id, task.schema)
+            logger.debug(f"Task {task.operation_id} completed successfully")
+        except Exception as e:
+            error_msg = f"{type(e).__name__}: {e}\n{traceback.format_exc()}"
+            logger.error(f"Task {task.operation_id} failed: {e}")
+            await self._retry_or_fail(task.operation_id, error_msg, task.schema)
+        finally:
+            # Remove from active tasks
+            async with self._in_flight_lock:
+                self._active_tasks.pop(task.operation_id, None)
+
+    async def recover_own_tasks(self) -> int:
+        """
+        Recover tasks that were assigned to this worker but not completed.
+
+        This handles the case where a worker crashes while processing tasks.
+        On startup, we reset any tasks stuck in 'processing' for this worker_id
+        back to 'pending' so they can be picked up again.
+
+        If tenant_extension is configured, recovers across all tenant schemas.
+
+        Returns:
+            Number of tasks recovered
+        """
+        schemas = await self._get_schemas()
+        total_count = 0
+
+        for schema in schemas:
+            table = fq_table("async_operations", schema)
+
+            result = await self._pool.execute(
+                f"""
+                UPDATE {table}
+                SET status = 'pending', worker_id = NULL, claimed_at = NULL, updated_at = now()
+                WHERE status = 'processing' AND worker_id = $1
+                """,
+                self._worker_id,
+            )
+
+            # Parse "UPDATE N" to get count
+            count = int(result.split()[-1]) if result else 0
+            total_count += count
+
+        if total_count > 0:
+            logger.info(f"Worker {self._worker_id} recovered {total_count} stale tasks from previous run")
+        return total_count
+
+    async def run(self):
+        """
+        Main polling loop.
+
+        Continuously polls for pending tasks, claims them, and executes them
+        until shutdown is signaled.
+
+        If tenant_extension is configured, dynamically discovers schemas on each poll.
+        """
+        # Recover any tasks from a previous crash before starting
+        await self.recover_own_tasks()
+
+        logger.info(f"Worker {self._worker_id} starting polling loop")
+
+        while not self._shutdown.is_set():
+            try:
+                # Claim a batch of tasks (across all tenant schemas if configured)
+                tasks = await self.claim_batch()
+
+                if tasks:
+                    # Log batch info
+                    task_types: dict[str, int] = {}
+                    schemas_seen: set[str | None] = set()
+                    for task in tasks:
+                        t = task.task_dict.get("type", "unknown")
+                        task_types[t] = task_types.get(t, 0) + 1
+                        schemas_seen.add(task.schema)
+                    types_str = ", ".join(f"{k}:{v}" for k, v in task_types.items())
+                    schemas_str = ", ".join(s or "public" for s in schemas_seen)
+                    logger.info(
+                        f"Worker {self._worker_id} claimed {len(tasks)} tasks: {types_str} (schemas: {schemas_str})"
+                    )
+
+                    # Track in-flight tasks
+                    async with self._in_flight_lock:
+                        self._in_flight_count += len(tasks)
+
+                    # Execute tasks concurrently
+                    try:
+                        await asyncio.gather(
+                            *[self.execute_task(task) for task in tasks],
+                            return_exceptions=True,
+                        )
+                    finally:
+                        async with self._in_flight_lock:
+                            self._in_flight_count -= len(tasks)
+                else:
+                    # No tasks found, wait before polling again
+                    try:
+                        await asyncio.wait_for(
+                            self._shutdown.wait(),
+                            timeout=self._poll_interval_ms / 1000,
+                        )
+                    except asyncio.TimeoutError:
+                        pass  # Normal timeout, continue polling
+
+                # Log progress stats periodically
+                await self._log_progress_if_due()
+
+            except asyncio.CancelledError:
+                logger.info(f"Worker {self._worker_id} polling loop cancelled")
+                break
+            except Exception as e:
+                logger.error(f"Worker {self._worker_id} error in polling loop: {e}")
+                traceback.print_exc()
+                # Backoff on error
+                await asyncio.sleep(1)
+
+        logger.info(f"Worker {self._worker_id} polling loop stopped")
+
+    async def shutdown_graceful(self, timeout: float = 30.0):
+        """
+        Signal shutdown and wait for current tasks to complete.
+
+        Args:
+            timeout: Maximum time to wait for in-flight tasks (seconds)
+        """
+        logger.info(f"Worker {self._worker_id} initiating graceful shutdown")
+        self._shutdown.set()
+
+        # Wait for in-flight tasks to complete
+        start_time = asyncio.get_event_loop().time()
+        while asyncio.get_event_loop().time() - start_time < timeout:
+            async with self._in_flight_lock:
+                in_flight = self._in_flight_count
+
+            if in_flight == 0:
+                logger.info(f"Worker {self._worker_id} graceful shutdown complete")
+                return
+
+            logger.info(f"Worker {self._worker_id} waiting for {in_flight} in-flight tasks")
+            await asyncio.sleep(0.5)
+
+        logger.warning(f"Worker {self._worker_id} shutdown timeout after {timeout}s")
+
+    async def _log_progress_if_due(self):
+        """Log progress stats every PROGRESS_LOG_INTERVAL seconds."""
+        now = time.time()
+        if now - self._last_progress_log < PROGRESS_LOG_INTERVAL:
+            return
+
+        self._last_progress_log = now
+
+        try:
+            # Get local active tasks (this worker only)
+            async with self._in_flight_lock:
+                in_flight = self._in_flight_count
+                active_tasks = dict(self._active_tasks)  # Copy to avoid holding lock
+
+            # Build local processing breakdown grouped by (op_type, bank_id)
+            task_groups: dict[tuple[str, str], int] = {}
+            for op_type, bank_id, _ in active_tasks.values():
+                key = (op_type, bank_id)
+                task_groups[key] = task_groups.get(key, 0) + 1
+
+            processing_info = [f"{op}:{bank}({cnt})" for (op, bank), cnt in task_groups.items()]
+            processing_str = ", ".join(processing_info[:10]) if processing_info else "none"
+            if len(processing_info) > 10:
+                processing_str += f" +{len(processing_info) - 10} more"
+
+            # Get global stats from DB across all schemas
+            schemas = await self._get_schemas()
+            global_pending = 0
+            all_worker_counts: dict[str, int] = {}
+
+            async with self._pool.acquire() as conn:
+                for schema in schemas:
+                    table = fq_table("async_operations", schema)
+
+                    row = await conn.fetchrow(f"SELECT COUNT(*) as count FROM {table} WHERE status = 'pending'")
+                    global_pending += row["count"] if row else 0
+
+                    # Get processing breakdown by worker
+                    worker_rows = await conn.fetch(
+                        f"""
+                        SELECT worker_id, COUNT(*) as count
+                        FROM {table}
+                        WHERE status = 'processing'
+                        GROUP BY worker_id
+                        """
+                    )
+                    for wr in worker_rows:
+                        wid = wr["worker_id"] or "unknown"
+                        all_worker_counts[wid] = all_worker_counts.get(wid, 0) + wr["count"]
+
+            # Format other workers' processing counts
+            other_workers = []
+            for wid, cnt in all_worker_counts.items():
+                if wid != self._worker_id:
+                    other_workers.append(f"{wid}:{cnt}")
+            others_str = ", ".join(other_workers) if other_workers else "none"
+
+            schemas_str = ", ".join(s or "public" for s in schemas)
+            logger.info(
+                f"[WORKER_STATS] worker={self._worker_id} in_flight={in_flight} | "
+                f"global: pending={global_pending} (schemas: {schemas_str}) | "
+                f"others: {others_str} | "
+                f"my_active: {processing_str}"
+            )
+
+        except Exception as e:
+            logger.debug(f"Failed to log progress stats: {e}")
+
+    @property
+    def worker_id(self) -> str:
+        """Get the worker ID."""
+        return self._worker_id
+
+    @property
+    def is_shutdown(self) -> bool:
+        """Check if shutdown has been signaled."""
+        return self._shutdown.is_set()

{hindsight_api-0.3.0.dist-info → hindsight_api-0.4.1.dist-info}/METADATA

@@ -1,19 +1,23 @@
 Metadata-Version: 2.4
 Name: hindsight-api
-Version: 0.3.0
+Version: 0.4.1
 Summary: Hindsight: Agent Memory That Works Like Human Memory
 Requires-Python: >=3.11
+Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: alembic>=1.17.1
 Requires-Dist: anthropic>=0.40.0
 Requires-Dist: asyncpg>=0.29.0
+Requires-Dist: authlib>=1.6.6
 Requires-Dist: cohere>=5.0.0
 Requires-Dist: dateparser>=1.2.2
 Requires-Dist: fastapi[standard]>=0.120.3
-Requires-Dist: fastmcp>=2.3.0
+Requires-Dist: fastmcp>=2.14.0
+Requires-Dist: filelock>=3.20.1
 Requires-Dist: flashrank>=0.2.0
 Requires-Dist: google-genai>=1.0.0
 Requires-Dist: greenlet>=3.2.4
 Requires-Dist: httpx>=0.27.0
+Requires-Dist: langchain-core>=1.2.5
 Requires-Dist: langchain-text-splitters>=0.3.0
 Requires-Dist: openai>=1.0.0
 Requires-Dist: opentelemetry-api>=1.20.0
@@ -23,21 +27,23 @@ Requires-Dist: opentelemetry-sdk>=1.20.0
 Requires-Dist: pg0-embedded>=0.11.0
 Requires-Dist: pgvector>=0.4.1
 Requires-Dist: psycopg2-binary>=2.9.11
+Requires-Dist: pyasn1>=0.6.2
 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.3.0,>=3.0.0
+Requires-Dist: sentence-transformers>=3.3.0
 Requires-Dist: sqlalchemy>=2.0.44
 Requires-Dist: tiktoken>=0.12.0
-Requires-Dist: torch>=2.0.0
-Requires-Dist: transformers<4.46.0,>=4.30.0
+Requires-Dist: torch>=2.6.0
+Requires-Dist: transformers>=4.53.0
 Requires-Dist: typer>=0.9.0
+Requires-Dist: urllib3>=2.6.3
 Requires-Dist: uvicorn>=0.38.0
 Requires-Dist: uvloop>=0.22.1
 Requires-Dist: wsproto>=1.0.0
 Provides-Extra: test
-Requires-Dist: filelock>=3.0.0; extra == 'test'
+Requires-Dist: filelock>=3.20.1; extra == 'test'
 Requires-Dist: pytest-asyncio>=0.21.0; extra == 'test'
 Requires-Dist: pytest-timeout>=2.4.0; extra == 'test'
 Requires-Dist: pytest-xdist>=3.0.0; extra == 'test'

hindsight_api-0.4.1.dist-info/RECORD

@@ -0,0 +1,112 @@
+hindsight_api/__init__.py,sha256=y8um49GprBg-BgGNjmSIRwE5PFOQWNmyio0m4xAiSHo,1197
+hindsight_api/banner.py,sha256=BXn-jhkXe4xi-YV4JeuaVvjYhTMs96O43XoOMv4Cd28,4591
+hindsight_api/config.py,sha256=PTnOLxdq7S4xBBuUA1ADLMKXylhphUQf7-DjSwZg7l0,26497
+hindsight_api/daemon.py,sha256=3CKcO_ENQ57dIWrTsmYUj-V4zvoAB1toNtVh3EVkg-c,5982
+hindsight_api/main.py,sha256=7poaTkS1U4E0SEKMqJ1m-L_IQKIikb-bIcay-btqXU8,14178
+hindsight_api/mcp_local.py,sha256=fJnCxMBc79GlBZrma94Ux6g-GVuh-W66194cqQdkKJQ,5613
+hindsight_api/mcp_tools.py,sha256=KGzgDeRoChwgt3HB-OoUHcWgHz6ELequLIkw6u7kkyo,19669
+hindsight_api/metrics.py,sha256=go3X7wyFAPkc55HFvu7esiaJXDrUsrSrC8Pq5NjcqU0,20692
+hindsight_api/migrations.py,sha256=V4QL_N1cMe6kNF1ejJ3lPIPFXKU2Pzbaiviws7AyMIY,14624
+hindsight_api/models.py,sha256=SzJ8uM2nGr3D6X-UEfE8VIT-PbS9J4DmRT_4lv5n9T8,12831
+hindsight_api/pg0.py,sha256=XORoiemECidQgBP53EBSCF3i0PJegLRRWKl2hU5UPhE,6390
+hindsight_api/server.py,sha256=MU2ZvKe3KWfxKYZq8EEJPgKMmq5diPkRqfQBaz-yOQI,2483
+hindsight_api/admin/__init__.py,sha256=RvaczuwTxg6ajc_Jlk0EhVz5JqlNB3T8su060gRQwfs,26
+hindsight_api/admin/cli.py,sha256=A1qkZ_9GWjz1qOIQYnmj-qUN005cIIlpFsvYH7tZdyc,11607
+hindsight_api/alembic/README,sha256=MVlc9TYmr57RbhXET6QxgyCcwWP7w-vLkEsirENqiIQ,38
+hindsight_api/alembic/env.py,sha256=I4sGdtUo8xcXe95MyD36JQeMod_Bvp9JUkW64Ve4XSM,5808
+hindsight_api/alembic/script.py.mako,sha256=04kgeBtNMa4cCnG8CfQcKt6P6rnloIfj8wy0u_DBydM,704
+hindsight_api/alembic/versions/5a366d414dce_initial_schema.py,sha256=g3G7fV70Z10PZxwTrTmR34OAlEZjQTLJKr-Ol54JqrQ,17665
+hindsight_api/alembic/versions/b7c4d8e9f1a2_add_chunks_table.py,sha256=MaHFU4JczUIFLeUMBTKIV3ocuclil55N9fPPim-HRfk,2599
+hindsight_api/alembic/versions/c8e5f2a3b4d1_add_retain_params_to_documents.py,sha256=ChqkHANauZb4-nBt2uepoZN3q0vRzN6aRsWTGueULiA,1146
+hindsight_api/alembic/versions/d9f6a3b4c5e2_rename_bank_to_interactions.py,sha256=s5_B2D0JdaxO7WM-vWC5Yt6hAtTsAUzJhFGLFSkfuQU,1808
+hindsight_api/alembic/versions/e0a1b2c3d4e5_disposition_to_3_traits.py,sha256=IdDP6fgsYj5fCXAF0QT-3t_wcKJsnf7B0mh7qS-cf_w,3806
+hindsight_api/alembic/versions/f1a2b3c4d5e6_add_memory_links_composite_index.py,sha256=tqkOLVD_p1NXVsIRxAc1mBiNpEosU9WkwrNUEGbc9DY,1598
+hindsight_api/alembic/versions/g2a3b4c5d6e7_add_tags_column.py,sha256=4P7OGJf2t9IWxI0wi8ibC3mrQzjWJaTZ5z5QPr67gig,1772
+hindsight_api/alembic/versions/h3c4d5e6f7g8_mental_models_v4.py,sha256=Pus5r0o_cVlbMOJg8kf6ZxV0Z1n1CvjmmIrq_cqgKrs,4687
+hindsight_api/alembic/versions/i4d5e6f7g8h9_delete_opinions.py,sha256=UAqopJkEkggNJO3aklK5pNr2WdFvqpvnRRAPTn0_6kE,1281
+hindsight_api/alembic/versions/j5e6f7g8h9i0_mental_model_versions.py,sha256=k2JVQtgZnxYr7tbLDrtxgTvATsshA_dnC67A23zgxoA,3536
+hindsight_api/alembic/versions/k6f7g8h9i0j1_add_directive_subtype.py,sha256=PophnJ_irT0TznA0f0acrm_OMPaukxJelWRjeRD5cvU,1990
+hindsight_api/alembic/versions/l7g8h9i0j1k2_add_worker_columns.py,sha256=BjwvxbiwCSAc9OpPc8iZFvK-812xBhcZcjtdluH4dpg,3590
+hindsight_api/alembic/versions/m8h9i0j1k2l3_mental_model_id_to_text.py,sha256=wBP2eQQLkq-EvRp3godGOgj3rWc1wc67v8GSnxHxTGU,1319
+hindsight_api/alembic/versions/n9i0j1k2l3m4_learnings_and_pinned_reflections.py,sha256=Gv8QeFiUhhoeTW33606_Y38BsyJinQPBSgP_cRUPqwY,5008
+hindsight_api/alembic/versions/o0j1k2l3m4n5_migrate_mental_models_data.py,sha256=iB2nKkzYoHFhH2m8VPlx3yGGFK0uypXXNIPxLZA-Sgo,4165
+hindsight_api/alembic/versions/p1k2l3m4n5o6_new_knowledge_architecture.py,sha256=XnlmL-kAixgNfFPcGV7In9GfjrsstivSA9ukrY7a99I,7978
+hindsight_api/alembic/versions/q2l3m4n5o6p7_fix_mental_model_fact_type.py,sha256=ve1pEaSiKnorifBeLFvh7rI33fUPV9CZCZV52eTcUzg,1740
+hindsight_api/alembic/versions/r3m4n5o6p7q8_add_reflect_response_to_reflections.py,sha256=TPht7sDAQGxxJ6_Y62NrMygpWe_5MK3fvoJLVJUctdo,1385
+hindsight_api/alembic/versions/rename_personality_to_disposition.py,sha256=A29-nDJ2Re4u9jdp2sUw29It808j4h6BpcA4wDHJMJ8,2765
+hindsight_api/alembic/versions/s4n5o6p7q8r9_add_consolidated_at_to_memory_units.py,sha256=UYnaPSsagPWKSTISBErVPbGQXm7Cqf_yZjXnzfcen7k,1643
+hindsight_api/alembic/versions/t5o6p7q8r9s0_rename_mental_models_to_observations.py,sha256=vUaQ2l3FUx4MJb_9m3H752FhTjrbsd82mBxe3Ti2nug,5448
+hindsight_api/alembic/versions/u6p7q8r9s0t1_mental_models_text_id.py,sha256=uvil81f-4ag2dIxBXUGKZ5vxkqdNQRpxCWj_iVih09w,1355
+hindsight_api/alembic/versions/v7q8r9s0t1u2_add_max_tokens_to_mental_models.py,sha256=Mw68uW8PK-SaHcYcqb41vWI0R22t70SSasNS2Myeoec,1656
+hindsight_api/api/__init__.py,sha256=npF0AAy8WJhHF5a9ehkNn9_iYLk7RQOk2gdkdFb49Hk,3840
+hindsight_api/api/http.py,sha256=5YFLGWDILApMf4lLxpc72S9EtnOIOvuu8c3K124THPc,133363
+hindsight_api/api/mcp.py,sha256=zV0TmkxKEqwhLIfNAdezYgsZ1PF9Lo8j5_lD73ULpKU,6707
+hindsight_api/engine/__init__.py,sha256=-BwaSwG9fTT_BBO0c_2MBkxG6-tGdclSzIqsgHw4cnw,1633
+hindsight_api/engine/cross_encoder.py,sha256=rA-iFXO-hXOx6BPCUi_Q6p-wm93eE8Bd6cuivFkeKBY,36029
+hindsight_api/engine/db_budget.py,sha256=1OmZiuszpuEaYz355QlOqwaupXPd9FrnbyENsFboBkg,8642
+hindsight_api/engine/db_utils.py,sha256=Fq1pXETt8ZPhkWYjrcGbgL6glrwmCGWh3_lYJgHqQPo,3067
+hindsight_api/engine/embeddings.py,sha256=FAFf7mb7Woz0BoJmBF_m1y3FZt8Ty0yw3ZYaYSHrtMg,30736
+hindsight_api/engine/entity_resolver.py,sha256=qVvWJHnbGEfh0iUFtc1dbM3IUNwPMsQsmg2rMgiX2DY,23794
+hindsight_api/engine/interface.py,sha256=rldxkBmp_bqEeTBD713uZeXvrqJB9Ix1L62gazlNEi0,16899
+hindsight_api/engine/llm_wrapper.py,sha256=Mh38zSlNGhsbN0f2VA1JGZ52HRab_ndcKqvEhyajgK0,68084
+hindsight_api/engine/memory_engine.py,sha256=lYWrQYzHib0UPiGNFxe_5QXxkJv14DjiG93SZ1sHo7c,231906
+hindsight_api/engine/query_analyzer.py,sha256=7APe0MjBcUxjivcMlM03PmMk_w5FjWvlEe20yAJlHlc,19741
+hindsight_api/engine/response_models.py,sha256=1fNAFPztlmYfOaoRfwYyrhzdPBO9UL8QHFNXW6Lmjgg,16322
+hindsight_api/engine/task_backend.py,sha256=zDH24tTwIH_59eFpQzepv0KkZXOIVMpmDkrg1Y5khDA,8172
+hindsight_api/engine/utils.py,sha256=OtEFDViKcCpFmKN3Qir8YV4zp0kv7iaREcgDXCkwShw,2089
+hindsight_api/engine/consolidation/__init__.py,sha256=qEUPy0R7akNoAooQL1TAt2rVasjvnXTcNzh2zpN0flc,160
+hindsight_api/engine/consolidation/consolidator.py,sha256=E2wEsSnHVFEFEahq51QCkp4zGZW-LZxMUxgZh49cEt8,33037
+hindsight_api/engine/consolidation/prompts.py,sha256=UgJJvXeG7bH0h-N0AWlUsmWoYxfJY2gIP_3f9xjCvSc,3422
+hindsight_api/engine/directives/__init__.py,sha256=5ZxaRqZVyJckbGElaI2DMRMBtnj-qYkxRKdnOHBwovA,118
+hindsight_api/engine/directives/models.py,sha256=PKxvmhW1-fjBITAOBu7RKX5Lj61c2jdsTaX8ADelKag,1523
+hindsight_api/engine/mental_models/__init__.py,sha256=TU6dSPyIsevFDgY6PLYctDsk5K4SA4pFSQnmQvbdRlA,488
+hindsight_api/engine/mental_models/models.py,sha256=DjgumJE7LvbMVpv90aMkGhIWOZ3ZrXM2DFAqHuGerAs,2102
+hindsight_api/engine/reflect/__init__.py,sha256=r70r-Y9LElHIL3EsvImO1KIL1sT_ubr1lC0IH5kH6O0,484
+hindsight_api/engine/reflect/agent.py,sha256=mr0rUrwdnDISt9iyuspI_ZhL4qfyLTWAzJO9EAIEctM,37610
+hindsight_api/engine/reflect/models.py,sha256=ZnMCi4sta5bSVGRRNatTA2jNSun59mWEVVq6Dkmjq1Q,5185
+hindsight_api/engine/reflect/observations.py,sha256=TMivY5ujrJAOhG3OFFTGEuwbW27AOjyD5l0JlDfbyJM,6777
+hindsight_api/engine/reflect/prompts.py,sha256=AewEMBJ_fk0pAVtWQagPMY_0lR9mHNJQ7kF4I5ruWmg,18442
+hindsight_api/engine/reflect/tools.py,sha256=tD5l3ODhtQ3bcD5dvbsRipWz902H7tz4M_TDEZhpazU,14550
+hindsight_api/engine/reflect/tools_schema.py,sha256=cdRmRwge5aHlVY19Y0Tlp5zEcFCnvxUc2GAXmwaNcMU,9944
+hindsight_api/engine/retain/__init__.py,sha256=t6q3-_kf4iYTl9j2PVB6laqMSs6UuPeXBSYMW6HT1sA,1152
+hindsight_api/engine/retain/bank_utils.py,sha256=LsFiB5rqyI1deL4rePAmPdmxMBb4paDA8UqMvY2Y40g,7696
+hindsight_api/engine/retain/chunk_storage.py,sha256=zXAqbcFeYpjyWlOoi8zeK5G91zHpF75CUVF-6wsEJpU,2064
+hindsight_api/engine/retain/deduplication.py,sha256=kqs7I7eIc_ppvgAF9GlzL6fSGuEEzrgw17-7NdyUDis,3099
+hindsight_api/engine/retain/embedding_processing.py,sha256=R35oyKYIKjuqC-yZl5Ru56F8xRe0N6KW_9p5PZ9CBi0,1649
+hindsight_api/engine/retain/embedding_utils.py,sha256=uulXIBiA7XNsj16K1VGawR3s5jV-hsAmvmoCi-IodpU,1565
+hindsight_api/engine/retain/entity_processing.py,sha256=0x5b48Im7pWjeqg3xTMIRVhrzd4otc4rSkFBjxgOL9Y,3632
+hindsight_api/engine/retain/fact_extraction.py,sha256=LdrXyoDERRWJhofHHCVlLrTi880RRIIeAk1AgZiDBAw,63187
+hindsight_api/engine/retain/fact_storage.py,sha256=PUdMfNWaGuDA-DodeT3hs8ft81ldzXZedCMXys-sFf4,6690
+hindsight_api/engine/retain/link_creation.py,sha256=KP2kGU2VCymJptgw0hjaSdsjvncBgNp3P_A4OB_qx-w,3082
+hindsight_api/engine/retain/link_utils.py,sha256=eKa9Ecf7Mpqjl4laAEtRilQgu4fbsGWAjg98kdMDsDc,33078
+hindsight_api/engine/retain/orchestrator.py,sha256=URQm9oXFWhLTmQjHlolnyWjcFDusEitn5UVbIvVdcXQ,20480
+hindsight_api/engine/retain/types.py,sha256=zNkjqUA6oUAFe9a5SEbZfQC5PSmpYqTyBfgdmyqPpnw,7722
+hindsight_api/engine/search/__init__.py,sha256=YPz_4g7IOabx078Xwg3RBfbOpJ649NRwNfe0gTI9P1U,802
+hindsight_api/engine/search/fusion.py,sha256=cY81BH9U5RyWrPXbQnrDBghtelDMckZWCke9aqMyNnQ,4220
+hindsight_api/engine/search/graph_retrieval.py,sha256=FCxyxXHv1FU6JlwEACcP3gL4F9u7RN3JDR7c3IzA0Sc,10161
+hindsight_api/engine/search/link_expansion_retrieval.py,sha256=SkBU2bLqh699TwZoWhnmi6HI5blzfF5DAdYUTkAVj-8,16497
+hindsight_api/engine/search/mpfp_retrieval.py,sha256=YJvQBPpBITVq3TcO9S8AFe9i6W4P2AtsZxEplRNtWxg,24461
+hindsight_api/engine/search/reranking.py,sha256=hNwte352lTB8A7wlez8-05cdL2_Ghy2kbTs93sGyug4,3929
+hindsight_api/engine/search/retrieval.py,sha256=kXUnVLZLisRYBrJc1rmD2UjtvPfZsh7i5hDAgvhHnD0,51572
+hindsight_api/engine/search/tags.py,sha256=3oxpm3VonwvowyOXn1FPVby50PakVfxvTT1FuEI_iDo,5843
+hindsight_api/engine/search/temporal_extraction.py,sha256=j7hPqpx2jMdR2BqgFrL-rrV2Hzq8HV24MtjYLJqVl2U,1732
+hindsight_api/engine/search/think_utils.py,sha256=k2NBmb1eczTiDHuQZ7-VW4lsvlGt20VXz-pYLJzvN6k,9642
+hindsight_api/engine/search/trace.py,sha256=RjvbkKBK-_MZBcVhVlaDTLD0yg6krngMNyC0_zLK05Y,11748
+hindsight_api/engine/search/tracer.py,sha256=B75CZQjdoheN2UpNgqKbJkdXlDVKJjzVTdUhvBUFaLY,16212
+hindsight_api/engine/search/types.py,sha256=meIoT8Q1coal1TmV_UiCqo9emjQI6af27EXPWVZL4h4,6418
+hindsight_api/extensions/__init__.py,sha256=F8q_tH-2Hl8-4F8wzIieA4Cya2dMEE9gwPtz7Z56BYc,2151
+hindsight_api/extensions/base.py,sha256=M7zXuM-tbqDnUwXX1mxAxiFs1eXOzNqIJutKLiUE4mU,2357
+hindsight_api/extensions/context.py,sha256=Qq-uy3hhxO6ioDmf6dPXdnIjs_pdm7lTspDiEhJJmPU,4469
+hindsight_api/extensions/http.py,sha256=c-a1g6R6rzibyReyR-WHz8DjRRGr4rVSyV9KB4UxVVU,2907
+hindsight_api/extensions/loader.py,sha256=UwGM0XH7zHGng_xfHUY0VbOQemj9DmjuDaMst1TrFi8,4170
+hindsight_api/extensions/operation_validator.py,sha256=ciXvTtlX4c5VcLze5cVbuaD6B-10IxnfgnNhbY8LGLc,13360
+hindsight_api/extensions/tenant.py,sha256=0LraksQ1gzsOYLEGrx2q2F0or596Ywfo_MqD1FJMNRM,2617
+hindsight_api/extensions/builtin/__init__.py,sha256=hLx2oFYZ1JtZhTWfab6AYcR02SWP2gIdbEqnZezT8ek,526
+hindsight_api/extensions/builtin/tenant.py,sha256=R7jfNR41deGWqQB5P8Qk5njy1bZgvemcTpkXDRiAZBA,1835
+hindsight_api/worker/__init__.py,sha256=hzpMLvOfgL2KKrrik_9ouvEzCdvJSrH-pj5UdFK63J0,256
+hindsight_api/worker/main.py,sha256=1OrQdHL-6u-311W0XMAoLHOXCu8MOETiQkR0TQ23qh8,9547
+hindsight_api/worker/poller.py,sha256=l-y8xpekKZ7zcGo83osOsbFd_tBi49LqrAJsN-mxiMY,19306
+hindsight_api-0.4.1.dist-info/METADATA,sha256=7qQlHBih3InJcpEZv3UAWzBkhhgQ0DgLKayw-hmp9VI,5760
+hindsight_api-0.4.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+hindsight_api-0.4.1.dist-info/entry_points.txt,sha256=1-mxPbRGL_Byf9ZrHYkPW-TEgLYFcwCiSFCxOgI_3vM,206
+hindsight_api-0.4.1.dist-info/RECORD,,

{hindsight_api-0.3.0.dist-info → hindsight_api-0.4.1.dist-info}/entry_points.txt

@@ -2,3 +2,4 @@
 hindsight-admin = hindsight_api.admin.cli:main
 hindsight-api = hindsight_api.main:main
 hindsight-local-mcp = hindsight_api.mcp_local:main
+hindsight-worker = hindsight_api.worker.main:main