memwal 0.1.11.dev11__tar.gz → 0.1.11.dev13__tar.gz

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memwal
-Version: 0.1.11.dev11
+Version: 0.1.11.dev13
 Summary: Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing
 Project-URL: Homepage, https://memory.walrus.xyz
 Project-URL: Documentation, https://memory.walrus.xyz

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/memwal/__init__.py

@@ -128,4 +128,4 @@ __all__ = [
     "RecallManualResult",
 ]
 
-__version__ = "0.1.11.dev11"
+__version__ = "0.1.11.dev13"

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/memwal/client.py

@@ -1055,6 +1055,8 @@ class MemWal:
                 blob_id=m["blob_id"],
                 text=m["text"],
                 distance=m["distance"],
+                score=m.get("score"),
+                created_at=m.get("created_at"),
             )
             for m in data.get("results", [])
         ]
@@ -1063,14 +1065,12 @@ class MemWal:
             dropped = int(raw_dropped)
         except (TypeError, ValueError):
             dropped = 0
+        total_count = data.get("total", len(memories))
         if max_distance is not None:
             memories = [m for m in memories if m.distance < max_distance]
-            return RecallResult(
-                results=memories, total=len(memories), dropped_count=dropped
-            )
         return RecallResult(
             results=memories,
-            total=data.get("total", len(memories)),
+            total=total_count,
             dropped_count=dropped,
         )
 
@@ -1455,7 +1455,12 @@ class MemWal:
             include_seal_session=False,
         )
         hits = [
-            RecallManualHit(blob_id=h["blob_id"], distance=h["distance"])
+            RecallManualHit(
+                blob_id=h["blob_id"],
+                distance=h["distance"],
+                created_at=h.get("created_at"),
+                importance=h.get("importance"),
+            )
             for h in data.get("results", [])
         ]
         return RecallManualResult(results=hits, total=data.get("total", len(hits)))
@@ -1817,7 +1822,7 @@ class MemWalClockDriftError(MemWalError):
 
 def _redact_internal_urls(text: str) -> str:
     return re.sub(
-        r"https?://(?:localhost|127\.0\.0\.1)(?::\d+)?[^\s)\]>'\"]*",
+        r"https?://(?:(?:[\w-]+\.)*localhost|127\.\d{1,3}\.\d{1,3}\.\d{1,3}|\[::1\]|0\.0\.0\.0)(?::\d+)?[^\s)\]>'\"]*",
         "[internal]",
         text,
         flags=re.IGNORECASE,

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/memwal/mock.py

@@ -278,14 +278,21 @@ class MemWalMock:
             for memory in self._memories
             if memory.namespace == resolved_namespace
         ]
-        if max_distance is not None:
-            ranked = [item for item in ranked if item[1] < max_distance]
         ranked.sort(key=lambda item: (item[1], item[0].sequence))
+        page = ranked[:limit]
+        if max_distance is not None:
+            page = [item for item in page if item[1] < max_distance]
         results = [
-            RecallMemory(blob_id=memory.blob_id, text=memory.text, distance=score)
-            for memory, score in ranked[:limit]
+            RecallMemory(
+                blob_id=memory.blob_id,
+                text=memory.text,
+                distance=score,
+                score=1.0 - score,
+                created_at=_mock_timestamp(memory.sequence),
+            )
+            for memory, score in page
         ]
-        return RecallResult(results=results, total=len(results))
+        return RecallResult(results=results, total=len(ranked[:limit]))
 
     async def analyze(
         self,

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/memwal/types.py

@@ -88,6 +88,8 @@ class RecallMemory:
     blob_id: str
     text: str
     distance: float
+    score: Optional[float] = None
+    created_at: Optional[str] = None
 
 
 @dataclass
@@ -328,6 +330,8 @@ class RecallManualHit:
 
     blob_id: str
     distance: float
+    created_at: Optional[str] = None
+    importance: Optional[float] = None
 
 
 @dataclass

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/memwal/utils.py

@@ -299,7 +299,9 @@ def normalize_private_key(key: str) -> str:
     candidate = key.strip()
     if candidate.lower().startswith("suiprivkey1"):
         return bytes_to_hex(decode_sui_private_key(candidate))
-    return candidate[2:] if candidate.startswith("0x") else candidate
+    if candidate.startswith(("0x", "0X")):
+        return candidate[2:]
+    return candidate
 
 
 def encode_sui_private_key(seed_bytes: bytes) -> str:

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memwal"
-version = "0.1.11.dev11"
+version = "0.1.11.dev13"
 description = "Python SDK for Walrus Memory — Privacy-first AI memory with Ed25519 signing"
 readme = "README.md"
 license = "MIT"

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/tests/test_client.py

@@ -841,6 +841,40 @@ class TestRecall:
         assert result.results == []
         assert result.dropped_count == 3
 
+    @respx.mock
+    async def test_recall_preserves_score_and_created_at(
+        self, memwal_client: MemWal
+    ) -> None:
+        mock_seal_session_prereqs()
+        respx.post(f"{_TEST_SERVER}/api/recall").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "results": [
+                        {
+                            "blob_id": "b1",
+                            "text": "Fact with metadata",
+                            "distance": 0.1,
+                            "score": 0.95,
+                            "created_at": "2026-03-30T12:00:00Z",
+                        },
+                        {
+                            "blob_id": "b2",
+                            "text": "Legacy fact",
+                            "distance": 0.3,
+                        },
+                    ],
+                    "total": 2,
+                },
+            )
+        )
+        result = await memwal_client.recall("test")
+        assert len(result.results) == 2
+        assert result.results[0].score == 0.95
+        assert result.results[0].created_at == "2026-03-30T12:00:00Z"
+        assert result.results[1].score is None
+        assert result.results[1].created_at is None
+
     @respx.mock
     async def test_accepts_recall_params_object(
         self, memwal_client: MemWal
@@ -935,9 +969,33 @@ class TestRecall:
         body = json.loads(route.calls[0].request.content)
         assert body["limit"] == 10
         assert len(result.results) == 1
-        assert result.total == 1
+        assert result.total == 2
         assert result.results[0].blob_id == "b1"
 
+    @respx.mock
+    async def test_max_distance_filters_all_preserves_total(
+        self, memwal_client: MemWal
+    ) -> None:
+        """When all matches exceed max_distance, results is empty but total
+        preserves matches (#1066)."""
+        mock_seal_session_prereqs()
+        respx.post(f"{_TEST_SERVER}/api/recall").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "results": [
+                        {"blob_id": "b1", "text": "I love coffee", "distance": 0.8},
+                        {"blob_id": "b2", "text": "I live in Tokyo", "distance": 0.9},
+                    ],
+                    "total": 2,
+                },
+            )
+        )
+
+        result = await memwal_client.recall("coffee", limit=10, max_distance=0.5)
+        assert len(result.results) == 0
+        assert result.total == 2
+
     @respx.mock
     async def test_get_signed_request_uses_empty_body_hash_and_no_wire_body(
         self, memwal_client: MemWal
@@ -1451,6 +1509,41 @@ class TestManualAPI:
         assert len(result.results) == 1
         assert result.results[0].blob_id == "b1"
 
+    @respx.mock
+    async def test_recall_manual_preserves_created_at_and_importance(
+        self, memwal_client: MemWal
+    ) -> None:
+        _mock_version()
+        respx.post(f"{_TEST_SERVER}/api/recall/manual").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "results": [
+                        {
+                            "blob_id": "b1",
+                            "distance": 0.15,
+                            "created_at": "2026-03-30T12:00:00Z",
+                            "importance": 0.85,
+                        },
+                        {
+                            "blob_id": "b2",
+                            "distance": 0.4,
+                        },
+                    ],
+                    "total": 2,
+                },
+            )
+        )
+
+        opts = RecallManualOptions(vector=[0.1, 0.2, 0.3], limit=5)
+        result = await memwal_client.recall_manual(opts)
+
+        assert len(result.results) == 2
+        assert result.results[0].created_at == "2026-03-30T12:00:00Z"
+        assert result.results[0].importance == 0.85
+        assert result.results[1].created_at is None
+        assert result.results[1].importance is None
+
     @respx.mock
     async def test_recall_manual_forwards_scoring_weights(self, memwal_client: MemWal) -> None:
         _mock_version()
@@ -1583,3 +1676,25 @@ class TestSealSession:
         assert exported["ttlMin"] == 5
         assert exported["sessionKey"].startswith("suiprivkey")
         assert exported["personalMessageSignature"]
+
+
+class TestRedactInternalUrls:
+    @pytest.mark.parametrize(
+        "raw, expected",
+        [
+            ("Error at http://localhost:8080/path", "Error at [internal]"),
+            ("Error at http://127.0.0.1:3000/api", "Error at [internal]"),
+            ("Error at http://127.0.0.2:8000/status", "Error at [internal]"),
+            ("Error at http://127.128.0.1:9000/info", "Error at [internal]"),
+            ("Error at http://[::1]:9000/seal/encrypt", "Error at [internal]"),
+            ("Error at http://0.0.0.0:8000/health", "Error at [internal]"),
+            ("Error at http://sidecar.localhost:8080/v1", "Error at [internal]"),
+            ("Error at http://sub.domain.localhost:3000/test", "Error at [internal]"),
+            ("Error at https://api.wal.app/v1/remember", "Error at https://api.wal.app/v1/remember"),
+        ],
+    )
+    def test_redact_internal_urls(self, raw: str, expected: str) -> None:
+        from memwal.client import _redact_internal_urls
+
+        assert _redact_internal_urls(raw) == expected
+

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/tests/test_mock.py

@@ -39,7 +39,11 @@ async def test_mock_remember_and_recall_are_deterministic_and_offline(monkeypatc
         "I drink tea at night",
     ]
     assert recalled.results[0].distance == 0
+    assert recalled.results[0].score == 1.0
+    assert recalled.results[0].created_at == "2026-01-01T00:00:01.000Z"
     assert recalled.results[1].distance == 1
+    assert recalled.results[1].score == 0.0
+    assert recalled.results[1].created_at == "2026-01-01T00:00:02.000Z"
 
 
 @pytest.mark.asyncio
@@ -57,6 +61,11 @@ async def test_mock_isolates_namespaces_and_honors_max_distance():
     assert [memory.text for memory in alice.results] == ["Alice likes ramen"]
     assert [memory.text for memory in bob.results] == ["Bob likes tacos"]
     assert empty.total == 0
+    dropped = await mock.recall(
+        RecallParams(query="likes", namespace="user-a", max_distance=0)
+    )
+    assert dropped.results == []
+    assert dropped.total == 1
 
 
 @pytest.mark.asyncio

{memwal-0.1.11.dev11 → memwal-0.1.11.dev13}/tests/test_signing.py

@@ -324,11 +324,20 @@ class TestPrivateKeyFormats:
         for form in (
             self._SEED_HEX,
             f"0x{self._SEED_HEX}",
+            f"0X{self._SEED_HEX}",
+            f"  0X{self._SEED_HEX}  ",
             encode_sui_private_key(seed),
             f"  {encode_sui_private_key(seed)}  ",
         ):
             assert normalize_private_key(form) == self._SEED_HEX
 
+    def test_uppercase_0x_prefix_key_produces_valid_client(self) -> None:
+        from memwal.client import MemWal
+
+        upper_0x = f"0X{self._SEED_HEX}"
+        client = MemWal.create(key=upper_0x, account_id="0xtest")
+        assert client._private_key_hex == self._SEED_HEX
+
     def test_bech32_key_produces_the_same_client_identity(self) -> None:
         from memwal.client import MemWal
         from memwal.utils import encode_sui_private_key