hindsight-client 0.1.0__tar.gz → 0.1.1__tar.gz

{hindsight_client-0.1.0 → hindsight_client-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hindsight-client
-Version: 0.1.0
+Version: 0.1.1
 Summary: Python client for Hindsight - Semantic memory system with personality-driven thinking
 Author: Hindsight Team
 Requires-Python: >=3.10

{hindsight_client-0.1.0 → hindsight_client-0.1.1}/hindsight_client/hindsight_client.py

@@ -157,7 +157,11 @@ class Hindsight:
         types: Optional[List[str]] = None,
         max_tokens: int = 4096,
         budget: str = "mid",
-    ) -> List[RecallResult]:
+        trace: bool = False,
+        query_timestamp: Optional[str] = None,
+        include_entities: bool = False,
+        max_entity_tokens: int = 500,
+    ) -> RecallResponse:
         """
         Recall memories using semantic similarity.
 
@@ -167,20 +171,31 @@ class Hindsight:
             types: Optional list of fact types to filter (world, experience, opinion, observation)
             max_tokens: Maximum tokens in results (default: 4096)
             budget: Budget level for recall - "low", "mid", or "high" (default: "mid")
+            trace: Enable trace output (default: False)
+            query_timestamp: Optional ISO format date string (e.g., '2023-05-30T23:40:00')
+            include_entities: Include entity observations in results (default: False)
+            max_entity_tokens: Maximum tokens for entity observations (default: 500)
 
         Returns:
-            List of RecallResult objects
+            RecallResponse with results, optional entities, and optional trace
         """
+        from hindsight_client_api.models import include_options, entity_include_options
+
+        include_opts = include_options.IncludeOptions(
+            entities=entity_include_options.EntityIncludeOptions(max_tokens=max_entity_tokens) if include_entities else None
+        )
+
         request_obj = recall_request.RecallRequest(
             query=query,
             types=types,
             budget=budget,
             max_tokens=max_tokens,
-            trace=False,
+            trace=trace,
+            query_timestamp=query_timestamp,
+            include=include_opts,
         )
 
-        response = _run_async(self._api.recall_memories(bank_id, request_obj))
-        return response.results if hasattr(response, 'results') else []
+        return _run_async(self._api.recall_memories(bank_id, request_obj))
 
     def reflect(
         self,
@@ -209,55 +224,6 @@ class Hindsight:
 
         return _run_async(self._api.reflect(bank_id, request_obj))
 
-    # Full-featured methods (expose more options)
-
-    def recall_memories(
-        self,
-        bank_id: str,
-        query: str,
-        types: Optional[List[str]] = None,
-        budget: str = "mid",
-        max_tokens: int = 4096,
-        trace: bool = False,
-        query_timestamp: Optional[str] = None,
-        include_entities: bool = True,
-        max_entity_tokens: int = 500,
-    ) -> RecallResponse:
-        """
-        Recall memories with all options (full-featured).
-
-        Args:
-            bank_id: The memory bank ID
-            query: Search query
-            types: Optional list of fact types to filter (world, experience, opinion, observation)
-            budget: Budget level - "low", "mid", or "high"
-            max_tokens: Maximum tokens in results
-            trace: Enable trace output
-            query_timestamp: Optional ISO format date string (e.g., '2023-05-30T23:40:00')
-            include_entities: Include entity observations in results (default: True)
-            max_entity_tokens: Maximum tokens for entity observations (default: 500)
-
-        Returns:
-            RecallResponse with results, optional entities, and optional trace
-        """
-        from hindsight_client_api.models import include_options, entity_include_options
-
-        include_opts = include_options.IncludeOptions(
-            entities=entity_include_options.EntityIncludeOptions(max_tokens=max_entity_tokens) if include_entities else None
-        )
-
-        request_obj = recall_request.RecallRequest(
-            query=query,
-            types=types,
-            budget=budget,
-            max_tokens=max_tokens,
-            trace=trace,
-            query_timestamp=query_timestamp,
-            include=include_opts,
-        )
-
-        return _run_async(self._api.recall_memories(bank_id, request_obj))
-
     def list_memories(
         self,
         bank_id: str,

{hindsight_client-0.1.0 → hindsight_client-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hindsight-client"
-version = "0.1.0"
+version = "0.1.1"
 description = "Python client for Hindsight - Semantic memory system with personality-driven thinking"
 authors = [
     {name = "Hindsight Team"}

{hindsight_client-0.1.0 → hindsight_client-0.1.1}/tests/test_main_operations.py

@@ -92,32 +92,33 @@ class TestRecall:
 
     def test_recall_basic(self, client, bank_id):
         """Test basic memory search."""
-        results = client.recall(
+        response = client.recall(
             bank_id=bank_id,
             query="What does Alice like?",
         )
 
-        assert results is not None
-        assert len(results) > 0
+        assert response is not None
+        assert response.results is not None
+        assert len(response.results) > 0
 
         # Check that at least one result contains relevant information
-        result_texts = [r.text for r in results]
+        result_texts = [r.text for r in response.results]
         assert any("Alice" in text or "Python" in text or "programming" in text for text in result_texts)
 
     def test_recall_with_max_tokens(self, client, bank_id):
         """Test search with token limit."""
-        results = client.recall(
+        response = client.recall(
             bank_id=bank_id,
             query="outdoor activities",
             max_tokens=1024,
         )
 
-        assert results is not None
-        assert isinstance(results, list)
+        assert response is not None
+        assert response.results is not None
 
-    def test_recall_memories_full_featured(self, client, bank_id):
-        """Test recall_memories with all features."""
-        response = client.recall_memories(
+    def test_recall_full_featured(self, client, bank_id):
+        """Test recall with all features."""
+        response = client.recall(
             bank_id=bank_id,
             query="What are people's hobbies?",
             types=["world"],