hebbrix 2.3.1__tar.gz → 2.3.2__tar.gz

{hebbrix-2.3.1 → hebbrix-2.3.2}/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 2.3.2 — 2026-08-27
+
+- Align procedure create/list/get/update/execute/delete with the canonical
+  `/v1/procedures` REST and OpenAPI contract, including idempotent `204`
+  deletion.
+- Add explicit synchronous/asynchronous batch readiness receipts to the async
+  and synchronous clients.
+- Add batch wait helpers that poll every accepted memory, propagate terminal
+  failures, respect deadlines, and support asynchronous cancellation.
+
 ## 2.3.1 — 2026-08-26
 
 - Make `wait_for_index=True` poll the authoritative memory or job readiness

{hebbrix-2.3.1/hebbrix.egg-info → hebbrix-2.3.2}/PKG-INFO

@@ -1,10 +1,31 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.3.1
+Version: 2.3.2
 Summary: Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
-License-Expression: MIT
+License: MIT License
+        
+        Copyright (c) 2025 Hebbrix
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
 Project-URL: Homepage, https://hebbrix.com
 Project-URL: Documentation, https://docs.hebbrix.com
 Project-URL: Repository, https://github.com/hebbrix/hebbrix-python
@@ -96,6 +117,18 @@ async def main():
     # It returns only when searchable=true, raises on terminal failure, and
     # raises TimeoutError if the caller's readiness deadline expires.
 
+    # Batch contract: a successful synchronous return means every accepted item
+    # is searchable. A bounded server timeout raises explicitly and is safe to
+    # retry with the same idempotency key; it is never a successful 202.
+    batch = await client.memories.create_batch(
+        [{"content": "First fact"}, {"content": "Second fact"}],
+        collection_id=collection["id"],
+        wait_for_index=True,
+        idempotency_key="import-42",
+    )
+    # For wait_for_index=False receipts:
+    # batch = await client.memories.wait_batch_until_searchable(batch)
+
     # Search memories
     results = await client.search(
         query="What programming language does user like?",

{hebbrix-2.3.1 → hebbrix-2.3.2}/README.md

@@ -55,6 +55,18 @@ async def main():
     # It returns only when searchable=true, raises on terminal failure, and
     # raises TimeoutError if the caller's readiness deadline expires.
 
+    # Batch contract: a successful synchronous return means every accepted item
+    # is searchable. A bounded server timeout raises explicitly and is safe to
+    # retry with the same idempotency key; it is never a successful 202.
+    batch = await client.memories.create_batch(
+        [{"content": "First fact"}, {"content": "Second fact"}],
+        collection_id=collection["id"],
+        wait_for_index=True,
+        idempotency_key="import-42",
+    )
+    # For wait_for_index=False receipts:
+    # batch = await client.memories.wait_batch_until_searchable(batch)
+
     # Search memories
     results = await client.search(
         query="What programming language does user like?",

{hebbrix-2.3.1 → hebbrix-2.3.2}/hebbrix/__init__.py

@@ -41,7 +41,7 @@ Features:
 - ✅ Type hints throughout
 """
 
-__version__ = "2.3.1"
+__version__ = "2.3.2"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 

{hebbrix-2.3.1 → hebbrix-2.3.2}/hebbrix/client.py

@@ -91,7 +91,7 @@ class MemoryClient:
         """Get request headers."""
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.3.1",
+            "User-Agent": "hebbrix-python/2.3.2",
         }
 
         if self.api_key:

{hebbrix-2.3.1 → hebbrix-2.3.2}/hebbrix/resources.py

@@ -435,6 +435,106 @@ class MemoriesResource(BaseResource):
             )
         return receipt
 
+    async def create_batch(
+        self,
+        memories: List[Dict[str, Any]],
+        *,
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        app_id: Optional[str] = None,
+        namespace: Optional[str] = None,
+        wait_for_index: bool = False,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Create a durable batch with explicit synchronous/async readiness.
+
+        When ``wait_for_index`` is true, a successful return is guaranteed to
+        have ``processing_status=completed`` and ``searchable=true``. A bounded
+        server timeout raises an HTTP error and may be retried with the same
+        idempotency key; it is never returned as a successful processing state.
+        """
+
+        if not 1 <= len(memories) <= 100:
+            raise ValueError("memories must contain between 1 and 100 items")
+        if any(not str(item.get("content") or "").strip() for item in memories):
+            raise ValueError("every batch memory must contain non-empty content")
+        payload = {
+            "memories": memories,
+            "wait_for_index": wait_for_index,
+        }
+        optional = {
+            "collection_id": collection_id,
+            "user_id": user_id,
+            "agent_id": agent_id,
+            "run_id": run_id,
+            "app_id": app_id,
+            "namespace": namespace,
+        }
+        payload.update(
+            {key: value for key, value in optional.items() if value is not None}
+        )
+        kwargs: Dict[str, Any] = {"json": payload}
+        if idempotency_key:
+            kwargs["headers"] = {"Idempotency-Key": idempotency_key}
+        receipt = await self.client.post("/v1/memories/batch", **kwargs)
+        if wait_for_index and not (
+            receipt.get("searchable") is True
+            and str(receipt.get("processing_status") or "").casefold() == "completed"
+        ):
+            raise RuntimeError(
+                "wait_for_index batch response was not fully searchable; retry "
+                "with the same Idempotency-Key"
+            )
+        return receipt
+
+    async def wait_batch_until_searchable(
+        self,
+        receipt: Dict[str, Any],
+        *,
+        timeout: float = 60.0,
+        poll_interval: float = 0.5,
+    ) -> Dict[str, Any]:
+        """Poll every item in an asynchronous batch receipt to one terminal state.
+
+        Cancellation uses normal asyncio task cancellation. A failed/cancelled
+        item or a local deadline raises explicitly; a successful return means
+        every batch item reported ``searchable=true``.
+        """
+
+        memory_ids = list(dict.fromkeys(map(str, receipt.get("memory_ids") or [])))
+        if not memory_ids:
+            raise ValueError("batch receipt does not contain memory_ids")
+        deadline = time.monotonic() + max(0.0, timeout)
+        while True:
+            rows = await asyncio.gather(
+                *(self.get(memory_id) for memory_id in memory_ids)
+            )
+            for row in rows:
+                state = str(row.get("processing_status") or "").casefold()
+                if state in {"failed", "cancelled", "canceled"}:
+                    raise RuntimeError(
+                        f"memory {row.get('id')} indexing reached terminal state {state}"
+                    )
+            if all(row.get("searchable") is True for row in rows):
+                return {
+                    **receipt,
+                    "processing_status": "completed",
+                    "searchable": True,
+                    "results": [
+                        {
+                            "id": memory_id,
+                            "memory_id": memory_id,
+                            "processing_status": "completed",
+                        }
+                        for memory_id in memory_ids
+                    ],
+                }
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"batch was not searchable within {timeout}s")
+            await asyncio.sleep(max(0.05, poll_interval))
+
     async def wait_until_searchable(
         self,
         memory_id: str,
@@ -1187,6 +1287,15 @@ class RLResource(BaseResource):
 class ProceduralResource(BaseResource):
     """Procedural memory endpoints."""
 
+    @staticmethod
+    def _unwrap_procedure(response: Dict[str, Any]) -> Dict[str, Any]:
+        procedure = response.get("procedure")
+        if isinstance(procedure, dict):
+            return procedure
+        if response.get("procedure_id") and not response.get("id"):
+            return {**response, "id": response["procedure_id"]}
+        return response
+
     async def create(
         self,
         name: str,
@@ -1212,18 +1321,19 @@ class ProceduralResource(BaseResource):
         Returns:
             Created procedure
         """
-        return await self.client.post(
-            "/procedural",
+        response = await self.client.post(
+            "/v1/procedures",
             json={
                 "name": name,
                 "description": description,
-                "trigger_condition": trigger_condition,
-                "action_sequence": action_sequence,
+                "condition": {"expression": trigger_condition},
+                "action": {"steps": action_sequence},
                 "collection_id": collection_id,
                 "category": category,
-                "metadata": metadata or {},
+                "parameters": metadata or {},
             },
         )
+        return self._unwrap_procedure(response)
 
     async def list(
         self,
@@ -1250,7 +1360,10 @@ class ProceduralResource(BaseResource):
         if category:
             params["category"] = category
 
-        return await self.client.get("/procedural", params=params)
+        response = await self.client.get("/v1/procedures", params=params)
+        return (
+            response if isinstance(response, list) else response.get("procedures", [])
+        )
 
     async def get(self, procedure_id: str) -> Dict[str, Any]:
         """
@@ -1262,7 +1375,8 @@ class ProceduralResource(BaseResource):
         Returns:
             Procedure data
         """
-        return await self.client.get(f"/procedural/{procedure_id}")
+        response = await self.client.get(f"/v1/procedures/{procedure_id}")
+        return self._unwrap_procedure(response)
 
     async def execute(
         self,
@@ -1279,10 +1393,12 @@ class ProceduralResource(BaseResource):
         Returns:
             Execution result
         """
-        return await self.client.post(
-            f"/procedural/{procedure_id}/execute",
-            json={"context": context or {}},
+        response = await self.client.post(
+            f"/v1/procedures/{procedure_id}/execute",
+            json={"input_state": context or {}},
         )
+        result = response.get("execution_result")
+        return result if isinstance(result, dict) else response
 
     async def update(
         self,
@@ -1313,13 +1429,14 @@ class ProceduralResource(BaseResource):
         if description is not None:
             data["description"] = description
         if trigger_condition is not None:
-            data["trigger_condition"] = trigger_condition
+            data["condition"] = {"expression": trigger_condition}
         if action_sequence is not None:
-            data["action_sequence"] = action_sequence
+            data["action"] = {"steps": action_sequence}
         if metadata is not None:
-            data["metadata"] = metadata
+            data["parameters"] = metadata
 
-        return await self.client.patch(f"/procedural/{procedure_id}", json=data)
+        response = await self.client.patch(f"/v1/procedures/{procedure_id}", json=data)
+        return self._unwrap_procedure(response)
 
     async def delete(self, procedure_id: str) -> None:
         """
@@ -1328,7 +1445,7 @@ class ProceduralResource(BaseResource):
         Args:
             procedure_id: Procedure ID
         """
-        await self.client.delete(f"/procedural/{procedure_id}")
+        await self.client.delete(f"/v1/procedures/{procedure_id}")
 
 
 class TemporalResource(BaseResource):

{hebbrix-2.3.1 → hebbrix-2.3.2}/hebbrix/sync_client.py

@@ -101,6 +101,91 @@ class SyncMemoriesResource:
             )
         return receipt
 
+    def create_batch(
+        self,
+        memories: List[Dict[str, Any]],
+        *,
+        collection_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        run_id: Optional[str] = None,
+        app_id: Optional[str] = None,
+        namespace: Optional[str] = None,
+        wait_for_index: bool = False,
+        idempotency_key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        if not 1 <= len(memories) <= 100:
+            raise ValueError("memories must contain between 1 and 100 items")
+        if any(not str(item.get("content") or "").strip() for item in memories):
+            raise ValueError("every batch memory must contain non-empty content")
+        payload: Dict[str, Any] = {
+            "memories": memories,
+            "wait_for_index": wait_for_index,
+        }
+        optional = {
+            "collection_id": collection_id,
+            "user_id": user_id,
+            "agent_id": agent_id,
+            "run_id": run_id,
+            "app_id": app_id,
+            "namespace": namespace,
+        }
+        payload.update(
+            {key: value for key, value in optional.items() if value is not None}
+        )
+        kwargs: Dict[str, Any] = {"json": payload}
+        if idempotency_key:
+            kwargs["headers"] = {"Idempotency-Key": idempotency_key}
+        receipt = self.client.post("/v1/memories/batch", **kwargs)
+        if wait_for_index and not (
+            receipt.get("searchable") is True
+            and str(receipt.get("processing_status") or "").casefold() == "completed"
+        ):
+            raise RuntimeError(
+                "wait_for_index batch response was not fully searchable; retry "
+                "with the same Idempotency-Key"
+            )
+        return receipt
+
+    def wait_batch_until_searchable(
+        self,
+        receipt: Dict[str, Any],
+        *,
+        timeout: float = 60.0,
+        poll_interval: float = 0.5,
+    ) -> Dict[str, Any]:
+        """Poll every item in an asynchronous batch receipt until searchable."""
+
+        memory_ids = list(dict.fromkeys(map(str, receipt.get("memory_ids") or [])))
+        if not memory_ids:
+            raise ValueError("batch receipt does not contain memory_ids")
+        deadline = time.monotonic() + max(0.0, timeout)
+        while True:
+            rows = [self.get(memory_id) for memory_id in memory_ids]
+            for row in rows:
+                state = str(row.get("processing_status") or "").casefold()
+                if state in {"failed", "cancelled", "canceled"}:
+                    raise RuntimeError(
+                        f"memory {row.get('id')} indexing reached terminal state {state}"
+                    )
+            if all(row.get("searchable") is True for row in rows):
+                return {
+                    **receipt,
+                    "processing_status": "completed",
+                    "searchable": True,
+                    "results": [
+                        {
+                            "id": memory_id,
+                            "memory_id": memory_id,
+                            "processing_status": "completed",
+                        }
+                        for memory_id in memory_ids
+                    ],
+                }
+            if time.monotonic() >= deadline:
+                raise TimeoutError(f"batch was not searchable within {timeout}s")
+            time.sleep(max(0.05, poll_interval))
+
     def wait_until_searchable(
         self,
         memory_id: str,
@@ -310,6 +395,115 @@ class SyncCorrectionsResource:
         return self.client.delete(f"/v1/corrections/{correction_id}")
 
 
+class SyncProceduralResource:
+    """Blocking procedure lifecycle mapped to the canonical REST contract."""
+
+    def __init__(self, client: "SyncMemoryClient"):
+        self.client = client
+
+    @staticmethod
+    def _unwrap(response: Dict[str, Any]) -> Dict[str, Any]:
+        procedure = response.get("procedure")
+        if isinstance(procedure, dict):
+            return procedure
+        if response.get("procedure_id") and not response.get("id"):
+            return {**response, "id": response["procedure_id"]}
+        return response
+
+    def create(
+        self,
+        *,
+        name: str,
+        description: str,
+        trigger_condition: str,
+        action_sequence: List[str],
+        collection_id: Optional[str] = None,
+        category: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        response = self.client.post(
+            "/v1/procedures",
+            json={
+                "name": name,
+                "description": description,
+                "condition": {"expression": trigger_condition},
+                "action": {"steps": action_sequence},
+                "collection_id": collection_id,
+                "category": category,
+                "parameters": metadata or {},
+            },
+        )
+        return self._unwrap(response)
+
+    def list(
+        self,
+        *,
+        collection_id: Optional[str] = None,
+        category: Optional[str] = None,
+        skip: int = 0,
+        limit: int = 100,
+    ) -> List[Dict[str, Any]]:
+        response = self.client.get(
+            "/v1/procedures",
+            params={
+                key: value
+                for key, value in {
+                    "collection_id": collection_id,
+                    "category": category,
+                    "skip": skip,
+                    "limit": limit,
+                }.items()
+                if value is not None
+            },
+        )
+        return (
+            response if isinstance(response, list) else response.get("procedures", [])
+        )
+
+    def get(self, procedure_id: str) -> Dict[str, Any]:
+        return self._unwrap(self.client.get(f"/v1/procedures/{procedure_id}"))
+
+    def update(
+        self,
+        procedure_id: str,
+        *,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+        trigger_condition: Optional[str] = None,
+        action_sequence: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        payload: Dict[str, Any] = {}
+        if name is not None:
+            payload["name"] = name
+        if description is not None:
+            payload["description"] = description
+        if trigger_condition is not None:
+            payload["condition"] = {"expression": trigger_condition}
+        if action_sequence is not None:
+            payload["action"] = {"steps": action_sequence}
+        if metadata is not None:
+            payload["parameters"] = metadata
+        return self._unwrap(
+            self.client.patch(f"/v1/procedures/{procedure_id}", json=payload)
+        )
+
+    def execute(
+        self,
+        procedure_id: str,
+        context: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        response = self.client.post(
+            f"/v1/procedures/{procedure_id}/execute",
+            json={"input_state": context or {}},
+        )
+        result = response.get("execution_result")
+        return result if isinstance(result, dict) else response
+
+    def delete(self, procedure_id: str) -> None:
+        self.client.delete(f"/v1/procedures/{procedure_id}")
+
+
 class SyncSearchResource:
     def __init__(self, client: "SyncMemoryClient"):
         self.client = client
@@ -544,7 +738,7 @@ class SyncMemoryClient:
         self.source = source or os.getenv("HEBBRIX_SOURCE")
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.3.1",
+            "User-Agent": "hebbrix-python/2.3.2",
         }
         if api_key:
             headers["Authorization"] = f"Bearer {api_key}"
@@ -559,6 +753,7 @@ class SyncMemoryClient:
         self.memories = SyncMemoriesResource(self)
         self.memory_jobs = SyncMemoryJobsResource(self)
         self.corrections = SyncCorrectionsResource(self)
+        self.procedural = SyncProceduralResource(self)
         self.search_resource = SyncSearchResource(self)
         self.proofloop = SyncProofLoopResource(self)
 

{hebbrix-2.3.1 → hebbrix-2.3.2/hebbrix.egg-info}/PKG-INFO

@@ -1,10 +1,31 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.3.1
+Version: 2.3.2
 Summary: Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
-License-Expression: MIT
+License: MIT License
+        
+        Copyright (c) 2025 Hebbrix
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
 Project-URL: Homepage, https://hebbrix.com
 Project-URL: Documentation, https://docs.hebbrix.com
 Project-URL: Repository, https://github.com/hebbrix/hebbrix-python
@@ -96,6 +117,18 @@ async def main():
     # It returns only when searchable=true, raises on terminal failure, and
     # raises TimeoutError if the caller's readiness deadline expires.
 
+    # Batch contract: a successful synchronous return means every accepted item
+    # is searchable. A bounded server timeout raises explicitly and is safe to
+    # retry with the same idempotency key; it is never a successful 202.
+    batch = await client.memories.create_batch(
+        [{"content": "First fact"}, {"content": "Second fact"}],
+        collection_id=collection["id"],
+        wait_for_index=True,
+        idempotency_key="import-42",
+    )
+    # For wait_for_index=False receipts:
+    # batch = await client.memories.wait_batch_until_searchable(batch)
+
     # Search memories
     results = await client.search(
         query="What programming language does user like?",

{hebbrix-2.3.1 → hebbrix-2.3.2}/hebbrix.egg-info/SOURCES.txt

@@ -17,4 +17,5 @@ hebbrix.egg-info/requires.txt
 hebbrix.egg-info/top_level.txt
 tests/test_memories_resource.py
 tests/test_openapi_parity.py
+tests/test_procedural_resource.py
 tests/test_sync_client.py

{hebbrix-2.3.1 → hebbrix-2.3.2}/pyproject.toml

@@ -1,15 +1,14 @@
 [build-system]
-requires = ["setuptools>=77.0", "wheel"]
+requires = ["setuptools>=68.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "hebbrix"
-version = "2.3.1"
+version = "2.3.2"
 description = "Advanced Memory API for AI Agents with Reinforcement Learning - 3-line integration"
 readme = "README.md"
 requires-python = ">=3.8"
-license = "MIT"
-license-files = ["LICENSE"]
+license = {file = "LICENSE"}
 authors = [
     {name = "Hebbrix Team", email = "support@hebbrix.com"}
 ]

{hebbrix-2.3.1 → hebbrix-2.3.2}/tests/test_memories_resource.py

@@ -30,6 +30,10 @@ class RecordingClient:
         self.calls.append((path, kwargs))
         return {"id": "memory-1"}
 
+    async def delete(self, path, **kwargs):
+        self.calls.append((path, kwargs))
+        return {}
+
 
 @pytest.mark.asyncio
 async def test_create_forwards_every_supported_scope_and_source_field():
@@ -102,6 +106,71 @@ async def test_create_sends_idempotency_as_transport_header_not_payload():
     assert "idempotency_key" not in request["json"]
 
 
+@pytest.mark.asyncio
+async def test_batch_create_has_one_truthful_readiness_contract():
+    client = RecordingClient()
+
+    async def post(path, **kwargs):
+        client.calls.append((path, kwargs))
+        return {
+            "created": 1,
+            "failed": 0,
+            "memory_ids": ["memory-1"],
+            "results": [{"id": "memory-1", "processing_status": "completed"}],
+            "processing_status": "completed",
+            "searchable": True,
+        }
+
+    client.post = post
+    receipt = await MemoriesResource(client).create_batch(
+        [{"content": "A batch fact"}],
+        collection_id="collection-1",
+        wait_for_index=True,
+        idempotency_key="batch-retry-1",
+    )
+
+    path, request = client.calls[0]
+    assert path == "/v1/memories/batch"
+    assert receipt["searchable"] is True
+    assert request["json"]["wait_for_index"] is True
+    assert request["headers"] == {"Idempotency-Key": "batch-retry-1"}
+
+
+@pytest.mark.asyncio
+async def test_async_batch_polling_requires_every_item_to_be_searchable(monkeypatch):
+    client = RecordingClient()
+    calls = {"memory-1": 0, "memory-2": 0}
+
+    async def get(path, **_kwargs):
+        memory_id = path.rsplit("/", 1)[-1]
+        calls[memory_id] += 1
+        ready = calls[memory_id] >= 2
+        return {
+            "id": memory_id,
+            "processing_status": "completed" if ready else "processing",
+            "searchable": ready,
+        }
+
+    client.get = get
+    monkeypatch.setattr("hebbrix.resources.asyncio.sleep", AsyncMock())
+    receipt = await MemoriesResource(client).wait_batch_until_searchable(
+        {
+            "memory_ids": ["memory-1", "memory-2"],
+            "processing_status": "processing",
+            "searchable": False,
+        },
+        timeout=2,
+        poll_interval=0.05,
+    )
+
+    assert receipt["processing_status"] == "completed"
+    assert receipt["searchable"] is True
+    assert {row["memory_id"] for row in receipt["results"]} == {
+        "memory-1",
+        "memory-2",
+    }
+
+
 @pytest.mark.asyncio
 async def test_create_rejects_empty_content_before_network_io():
     client = RecordingClient()

{hebbrix-2.3.1 → hebbrix-2.3.2}/tests/test_openapi_parity.py

@@ -1,13 +1,12 @@
 """Release guard: GA SDK methods must remain mapped to exported OpenAPI operations."""
 
 import inspect
-import json
-from pathlib import Path
 
 from hebbrix.resources import (
     CorrectionsResource,
     MemoriesResource,
     MemoryJobsResource,
+    ProceduralResource,
     ProofLoopResource,
     SearchResource,
 )
@@ -15,50 +14,22 @@ from hebbrix.sync_client import (
     SyncCorrectionsResource,
     SyncMemoriesResource,
     SyncMemoryJobsResource,
+    SyncProceduralResource,
     SyncProofLoopResource,
     SyncSearchResource,
 )
 
-
-OPENAPI = json.loads(
-    (Path(__file__).resolve().parents[3] / "docs/api/openapi.json").read_text()
-)
-
-
-GA_OPERATIONS = {
-    ("/v1/memories", "post"),
-    ("/v1/memories", "get"),
-    ("/v1/memory-jobs/{job_id}", "get"),
-    ("/v1/corrections", "post"),
-    ("/v1/corrections/relevant", "get"),
-    ("/v1/corrections/{correction_id}", "get"),
-    ("/v1/corrections/{correction_id}", "delete"),
-    ("/v1/search", "post"),
-    ("/v1/search/reason", "post"),
-    ("/v1/learning/decisions", "post"),
-    ("/v1/learning/decisions/{decision_id}", "get"),
-    ("/v1/learning/decisions/{decision_id}/outcomes", "post"),
-    ("/v1/learning/decisions/{decision_id}/proof", "get"),
-    ("/v1/learning/metrics", "post"),
-    ("/v1/learning/metrics", "get"),
-    ("/v1/learning/policies/{policy_key}/insights", "get"),
-    ("/v1/learning/policies/{policy_key}/evaluate", "post"),
-    ("/v1/learning/proof-key", "get"),
-}
-
-
-def test_ga_operation_manifest_exists_in_exported_openapi():
-    missing = sorted(
-        (path, method)
-        for path, method in GA_OPERATIONS
-        if path not in OPENAPI["paths"] or method not in OPENAPI["paths"][path]
-    )
-    assert missing == []
-
-
 def test_async_and_sync_resources_cover_the_ga_lifecycle():
     required = {
-        MemoriesResource: {"create", "list_page", "get", "update", "delete"},
+        MemoriesResource: {
+            "create",
+            "create_batch",
+            "wait_batch_until_searchable",
+            "list_page",
+            "get",
+            "update",
+            "delete",
+        },
         MemoryJobsResource: {"get", "wait"},
         CorrectionsResource: {"create", "relevant", "get", "delete"},
         SearchResource: {"search_with_proof", "reason"},
@@ -73,7 +44,16 @@ def test_async_and_sync_resources_cover_the_ga_lifecycle():
             "proof",
             "public_key",
         },
-        SyncMemoriesResource: {"create", "list_page", "get", "update", "delete"},
+        ProceduralResource: {"create", "list", "get", "update", "execute", "delete"},
+        SyncMemoriesResource: {
+            "create",
+            "create_batch",
+            "wait_batch_until_searchable",
+            "list_page",
+            "get",
+            "update",
+            "delete",
+        },
         SyncMemoryJobsResource: {"get", "wait"},
         SyncCorrectionsResource: {"create", "relevant", "get", "delete"},
         SyncSearchResource: {"search_with_proof", "reason"},
@@ -88,6 +68,14 @@ def test_async_and_sync_resources_cover_the_ga_lifecycle():
             "proof",
             "public_key",
         },
+        SyncProceduralResource: {
+            "create",
+            "list",
+            "get",
+            "update",
+            "execute",
+            "delete",
+        },
     }
     missing = {
         resource.__name__: sorted(

hebbrix-2.3.2/tests/test_procedural_resource.py

@@ -0,0 +1,121 @@
+import pytest
+from hebbrix.resources import ProceduralResource
+from hebbrix.sync_client import SyncProceduralResource
+
+
+class RecordingClient:
+    def __init__(self):
+        self.calls = []
+
+    async def post(self, path, **kwargs):
+        self.calls.append(("POST", path, kwargs))
+        if path == "/v1/procedures":
+            return {"status": "success", "procedure_id": "procedure-1"}
+        if path.endswith("/execute"):
+            return {"execution_result": {"output": "recovered"}}
+        return {"status": "success"}
+
+    async def get(self, path, **kwargs):
+        self.calls.append(("GET", path, kwargs))
+        return {"procedures": []}
+
+    async def patch(self, path, **kwargs):
+        self.calls.append(("PATCH", path, kwargs))
+        return {
+            "status": "success",
+            "procedure": {"id": "procedure-1", "name": "updated"},
+        }
+
+    async def delete(self, path, **kwargs):
+        self.calls.append(("DELETE", path, kwargs))
+        return {}
+
+
+@pytest.mark.asyncio
+async def test_procedure_lifecycle_matches_canonical_rest_contract():
+    client = RecordingClient()
+    resource = ProceduralResource(client)
+
+    created = await resource.create(
+        name="restart proxy",
+        description="Recover the query proxy",
+        trigger_condition="proxy unavailable",
+        action_sequence=["recycle proxy once"],
+        metadata={"owner": "on-call"},
+    )
+    assert await resource.list() == []
+    executed = await resource.execute("procedure-1", {"incident": "INC-1"})
+    updated = await resource.update(
+        "procedure-1",
+        trigger_condition="proxy unhealthy",
+        action_sequence=["page on-call", "recycle proxy once"],
+    )
+    await resource.delete("procedure-1")
+    assert created["id"] == "procedure-1"
+    assert executed == {"output": "recovered"}
+    assert updated == {"id": "procedure-1", "name": "updated"}
+
+    assert [(method, path) for method, path, _ in client.calls] == [
+        ("POST", "/v1/procedures"),
+        ("GET", "/v1/procedures"),
+        ("POST", "/v1/procedures/procedure-1/execute"),
+        ("PATCH", "/v1/procedures/procedure-1"),
+        ("DELETE", "/v1/procedures/procedure-1"),
+    ]
+    create = client.calls[0][2]["json"]
+    assert create["condition"] == {"expression": "proxy unavailable"}
+    assert create["action"] == {"steps": ["recycle proxy once"]}
+    assert create["parameters"] == {"owner": "on-call"}
+    assert client.calls[2][2]["json"] == {"input_state": {"incident": "INC-1"}}
+    update = client.calls[3][2]["json"]
+    assert update["condition"] == {"expression": "proxy unhealthy"}
+    assert update["action"] == {"steps": ["page on-call", "recycle proxy once"]}
+
+
+class SyncRecordingClient:
+    def __init__(self):
+        self.calls = []
+
+    def post(self, path, **kwargs):
+        self.calls.append(("POST", path, kwargs))
+        if path == "/v1/procedures":
+            return {"procedure_id": "procedure-1"}
+        if path.endswith("/execute"):
+            return {"execution_result": {"output": "recovered"}}
+        return {}
+
+    def get(self, path, **kwargs):
+        self.calls.append(("GET", path, kwargs))
+        return {"procedures": []}
+
+    def patch(self, path, **kwargs):
+        self.calls.append(("PATCH", path, kwargs))
+        return {"procedure": {"id": "procedure-1", "name": "updated"}}
+
+    def delete(self, path, **kwargs):
+        self.calls.append(("DELETE", path, kwargs))
+        return None
+
+
+def test_sync_procedure_lifecycle_matches_canonical_rest_contract():
+    client = SyncRecordingClient()
+    resource = SyncProceduralResource(client)
+
+    created = resource.create(
+        name="restart proxy",
+        description="Recover the query proxy",
+        trigger_condition="proxy unavailable",
+        action_sequence=["recycle proxy once"],
+    )
+    assert resource.list() == []
+    assert resource.execute("procedure-1") == {"output": "recovered"}
+    assert resource.update("procedure-1", name="updated")["name"] == "updated"
+    assert resource.delete("procedure-1") is None
+    assert created["id"] == "procedure-1"
+    assert [(method, path) for method, path, _ in client.calls] == [
+        ("POST", "/v1/procedures"),
+        ("GET", "/v1/procedures"),
+        ("POST", "/v1/procedures/procedure-1/execute"),
+        ("PATCH", "/v1/procedures/procedure-1"),
+        ("DELETE", "/v1/procedures/procedure-1"),
+    ]