hebbrix 2.6.2__tar.gz → 2.7.0__tar.gz

{hebbrix-2.6.2 → hebbrix-2.7.0}/CHANGELOG.md

@@ -1,12 +1,26 @@
 # Changelog
 
+## 2.7.0 — 2026-10-19 (compact responses, entity scope, chat answers)
+
+- Behaviour change: `search()` and `search_with_proof()` now request `view="compact"` by default (rows keep content, identity, score, rank, timestamps, `low_confidence` and entity scope; the safety envelope and proof context are unchanged; ranking diagnostics need `debug=True`). Pass `view="full"` for the previous per-row metadata. `search()` returns rows only and no longer requests the unused ProofLoop token unless `include_proof_context=True`.
+- `reason()` now requests `view="compact"` by default: the answer, abstention fields (`decision_abstained`, `abstain_reason`), cited sources and safety envelope are kept and the internal decision diagnostics are omitted. Pass `view="full"` or `debug=True` for the full response.
+- Add `prefer_entity_match` (both search methods) and `include_profile` (`search_with_proof`), sent only when enabled; type `query_entities`, `profile` and `view` on the search envelope.
+- `MemoryChat.send()` and `send_with_context()` accept optional `answer_style` (`"natural"`, the server default, or `"quote"`) and `no_information_reply`; they are sent only when set.
+- Requires the server release of 2026-10-19 for the `/search/reason` compact view; the other options are accepted by current servers.
+
+## 2.6.3 — 2026-10-14 (candidate memory_ids)
+
+- Candidates may carry optional `memory_ids` (at most 50 ids of 1-255 characters) naming the exact memories that action applies; when the candidate becomes the decision's action, its outcome is credited to those memories.
+- The advisor input snapshot (`decide_with_advice`) admits and validates `memory_ids` before any evidence read, callback or write; `proofloop.decide` documents the candidate shape.
+- Requires the server release that credits outcomes only to memories bound to the action taken; a `proof_context` attests what was retrieved and no longer earns per-memory outcome credit by itself.
+
 ## 2.6.2 — 2026-10-06 (compact advice, batches and confirmation)
 
 - Correct canonical documentation metadata and simplify the stable three-call guide.
 - Add optional compact search/advice, bounded independently committed decision/outcome batches, and explicit caller-confirmation transports.
 - Add bounded chat-learning wait options while preserving the original job receipt.
 - Keep historical confidence scope aliases, ACT-as-advice and protected outcome boundaries intact.
-- Requires matching Round9 server routes; no benchmark superiority, latency SLA or automatic execution is implied.
+- Requires a matching server release; no benchmark superiority, latency SLA or automatic execution is implied.
 
 ## 2.6.1 — 2026-10-04 (advisory horizon helpers)
 

{hebbrix-2.6.2/hebbrix.egg-info → hebbrix-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.6.2
+Version: 2.7.0
 Summary: Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
@@ -65,14 +65,14 @@ Dynamic: license-file
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-The current stable package is **2.6.2**. Start with memory storage and search, or
+The current stable package is **2.7.0**. Start with memory storage and search, or
 the three-call outcome-learning workflow below. Advanced evidence and execution
 permission transports are opt-in; installing the SDK never permits an action.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.2
+pip install hebbrix==2.7.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -151,8 +151,21 @@ The canonical `gate` is `ASK`, `REVIEW`, `ACT`, or `BLOCK`. `BLOCK` dominates;
 `ACT` is advice, not permission. Apply your own current authorization and human
 approval policy before executing any tool. Do not infer permission from a score.
 
+Version 2.7.0 makes search and reason responses compact by default: rows keep
+content, identity, score, timestamps, confidence and entity scope (`applies_to`,
+`entity_match`), and Reason keeps the answer, `decision_abstained`,
+`abstain_reason` and cited sources. Pass `view="full"` or `debug=True` for
+diagnostics. `search_with_proof(include_profile=True)` returns standing profile
+facts and preferences, and `MemoryChat.send(answer_style="quote")` returns the
+stored source text verbatim instead of a plain-language reply.
+
+Version 2.6.3 lets each `proofloop.decide` candidate carry `memory_ids`: the exact
+memories that action applies. When that candidate becomes the decision's action,
+its outcome is credited to those memories; a `proof_context` attests what was
+retrieved but never earns per-memory outcome credit by itself.
+
 Version 2.6.2 adds compact advice, batch, and explicit confirmation helpers.
-They require matching Round9 server routes. Compact views retain scope and safety
+They require a matching server release. Compact views retain scope and safety
 caveats; complete receipts remain on the server.
 
 ## Durable readiness

{hebbrix-2.6.2 → hebbrix-2.7.0}/README.md

@@ -2,14 +2,14 @@
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-The current stable package is **2.6.2**. Start with memory storage and search, or
+The current stable package is **2.7.0**. Start with memory storage and search, or
 the three-call outcome-learning workflow below. Advanced evidence and execution
 permission transports are opt-in; installing the SDK never permits an action.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.2
+pip install hebbrix==2.7.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -88,8 +88,21 @@ The canonical `gate` is `ASK`, `REVIEW`, `ACT`, or `BLOCK`. `BLOCK` dominates;
 `ACT` is advice, not permission. Apply your own current authorization and human
 approval policy before executing any tool. Do not infer permission from a score.
 
+Version 2.7.0 makes search and reason responses compact by default: rows keep
+content, identity, score, timestamps, confidence and entity scope (`applies_to`,
+`entity_match`), and Reason keeps the answer, `decision_abstained`,
+`abstain_reason` and cited sources. Pass `view="full"` or `debug=True` for
+diagnostics. `search_with_proof(include_profile=True)` returns standing profile
+facts and preferences, and `MemoryChat.send(answer_style="quote")` returns the
+stored source text verbatim instead of a plain-language reply.
+
+Version 2.6.3 lets each `proofloop.decide` candidate carry `memory_ids`: the exact
+memories that action applies. When that candidate becomes the decision's action,
+its outcome is credited to those memories; a `proof_context` attests what was
+retrieved but never earns per-memory outcome credit by itself.
+
 Version 2.6.2 adds compact advice, batch, and explicit confirmation helpers.
-They require matching Round9 server routes. Compact views retain scope and safety
+They require a matching server release. Compact views retain scope and safety
 caveats; complete receipts remain on the server.
 
 ## Durable readiness

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/__init__.py

@@ -5,7 +5,7 @@ production OpenAPI and ``GET /v1/users/me/capabilities``. The experimental
 World Model is intentionally absent from this release.
 """
 
-__version__ = "2.6.2"
+__version__ = "2.7.0"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/_advice.py

@@ -121,9 +121,11 @@ def _snapshot_advisor_inputs(candidates, context):
             "action_key",
             "description",
             "features",
+            "memory_ids",
         }:
             raise ValueError(
-                "candidates must contain only action_key, description and features"
+                "candidates must contain only action_key, description, features "
+                "and memory_ids"
             )
         key = candidate.get("action_key")
         if (
@@ -145,6 +147,18 @@ def _snapshot_advisor_inputs(candidates, context):
             )
         if "features" in candidate and type(candidate["features"]) is not dict:
             raise ValueError("candidate features must be a JSON object")
+        memory_ids = candidate.get("memory_ids")
+        if memory_ids is not None and (
+            type(memory_ids) is not list
+            or len(memory_ids) > 50
+            or any(
+                type(memory_id) is not str or not 1 <= len(memory_id) <= 255
+                for memory_id in memory_ids
+            )
+        ):
+            raise ValueError(
+                "candidate memory_ids must be a list of at most 50 memory ids"
+            )
         keys.append(key)
     return candidates_copy, context_copy, keys
 

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/chat.py

@@ -32,6 +32,34 @@ def _chat_readiness_options(wait_for_learning_seconds, include_low_confidence):
     }
 
 
+_ANSWER_STYLES = ("natural", "quote")
+
+
+def _chat_answer_options(answer_style, no_information_reply):
+    """Optional reply-phrasing fields; omitted unless set (server defaults apply).
+
+    answer_style: "natural" (server default) composes a plain reply from the
+    stored sources a personal question is answered from; "quote" returns that
+    source text verbatim. no_information_reply replaces the default reply
+    ("I don't know that yet.") when no stored source answers.
+    """
+    if answer_style is not None and answer_style not in _ANSWER_STYLES:
+        raise ValueError("answer_style must be 'natural' or 'quote'")
+    if no_information_reply is not None and (
+        not isinstance(no_information_reply, str)
+        or not 1 <= len(no_information_reply) <= 500
+    ):
+        raise ValueError("no_information_reply must be 1-500 characters")
+    return {
+        **({"answer_style": answer_style} if answer_style is not None else {}),
+        **(
+            {"no_information_reply": no_information_reply}
+            if no_information_reply is not None
+            else {}
+        ),
+    }
+
+
 class MemoryChat:
     """
     Simple chat interface with automatic memory integration.
@@ -112,6 +140,8 @@ class MemoryChat:
         max_tokens: Optional[int] = None,
         *, wait_for_learning_seconds: float = 0,
         include_low_confidence: bool = False,
+        answer_style: Optional[str] = None,
+        no_information_reply: Optional[str] = None,
     ) -> str:
         """
         Send a message and get a response with automatic memory integration.
@@ -123,6 +153,12 @@ class MemoryChat:
             session_id: Session identifier (user ID or conversation ID)
             temperature: Response randomness (0-2, default: 0.7)
             max_tokens: Maximum response length (default: None)
+            answer_style: "natural" (server default) or "quote" (verbatim
+                stored source text) for personal questions answered from memory
+            no_information_reply: Reply when no stored source answers
+            answer_style: "natural" (server default) or "quote" (verbatim
+                stored source text) for personal questions answered from memory
+            no_information_reply: Reply when no stored source answers
 
         Returns:
             Assistant's response as a string
@@ -141,6 +177,7 @@ class MemoryChat:
             "memory_limit": self.memory_limit,
             "temperature": temperature,
             **_chat_readiness_options(wait_for_learning_seconds, include_low_confidence),
+            **_chat_answer_options(answer_style, no_information_reply),
         }
 
         if max_tokens:
@@ -167,6 +204,8 @@ class MemoryChat:
         max_tokens: Optional[int] = None,
         *, wait_for_learning_seconds: float = 0,
         include_low_confidence: bool = False,
+        answer_style: Optional[str] = None,
+        no_information_reply: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Send a message and get full response with memory context.
@@ -178,6 +217,12 @@ class MemoryChat:
             session_id: Session identifier
             temperature: Response randomness (0-2, default: 0.7)
             max_tokens: Maximum response length (default: None)
+            answer_style: "natural" (server default) or "quote" (verbatim
+                stored source text) for personal questions answered from memory
+            no_information_reply: Reply when no stored source answers
+            answer_style: "natural" (server default) or "quote" (verbatim
+                stored source text) for personal questions answered from memory
+            no_information_reply: Reply when no stored source answers
 
         Returns:
             Full response dict with memory context
@@ -198,6 +243,7 @@ class MemoryChat:
             "memory_limit": self.memory_limit,
             "temperature": temperature,
             **_chat_readiness_options(wait_for_learning_seconds, include_low_confidence),
+            **_chat_answer_options(answer_style, no_information_reply),
         }
 
         if max_tokens:

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/client.py

@@ -93,7 +93,7 @@ class MemoryClient:
         """Get request headers."""
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.6.2",
+            "User-Agent": "hebbrix-python/2.7.0",
         }
 
         if self.api_key:
@@ -332,6 +332,8 @@ class MemoryClient:
         agent_id: Optional[str] = None,
         run_id: Optional[str] = None,
         facets: Optional[List[str]] = None,
+        view: str = "compact",
+        debug: bool = False,
     ) -> Dict[str, Any]:
         """
         Perform reasoning over memories.
@@ -345,6 +347,8 @@ class MemoryClient:
             agent_id: Agent isolation scope
             run_id: Run isolation scope
             facets: Optional typed decomposition facets
+            view: ``"compact"`` (default) or ``"full"`` diagnostics
+            debug: Return the full diagnostic response
 
         Returns:
             Reasoning result with answer and sources
@@ -358,6 +362,8 @@ class MemoryClient:
             agent_id=agent_id,
             run_id=run_id,
             facets=facets,
+            view=view,
+            debug=debug,
         )
 
     async def close(self):

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/models.py

@@ -53,3 +53,9 @@ class SearchSafetyEnvelope(TypedDict, total=False):
     degraded: bool
     sdk_safety_reason: str
     proof_context: Dict[str, Any]
+    # Entities the query names; each row carries applies_to/entity_match.
+    query_entities: List[str]
+    # Standing profile facts and preferences (search include_profile=True).
+    profile: Dict[str, Any]
+    # "compact" (SDK default) or absent for the full projection.
+    view: str

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/resources.py

@@ -992,6 +992,101 @@ class CorrectionsResource(BaseResource):
         return await self.client.delete(f"/v1/corrections/{correction_id}")
 
 
+def _search_payload(
+    query: str,
+    *,
+    collection_id: Optional[str] = None,
+    limit: int = 10,
+    search_type: str = "hybrid",
+    filters: Optional[Dict[str, Any]] = None,
+    user_id: Optional[str] = None,
+    agent_id: Optional[str] = None,
+    run_id: Optional[str] = None,
+    fast: Optional[bool] = None,
+    threshold: Optional[float] = None,
+    include_low_confidence: bool = False,
+    group_by_source: bool = True,
+    debug: bool = False,
+    view: Optional[str] = "compact",
+    include_proof_context: Optional[bool] = None,
+    prefer_entity_match: bool = False,
+    include_profile: bool = False,
+) -> Dict[str, Any]:
+    """Build the identical /v1/search body for sync and async clients.
+
+    ``view`` defaults to ``"compact"``: rows keep content, identity, score,
+    rank, timestamps, confidence and entity scope, and the safety envelope and
+    proof context are unchanged; ranking diagnostics are omitted unless
+    ``debug=True``. Pass ``view="full"`` for the complete per-row metadata.
+    New opt-in fields are sent only when enabled, so older servers that
+    reject unknown fields keep accepting default requests.
+    """
+
+    _validate_advice_view(view)
+    payload: Dict[str, Any] = {
+        "query": query,
+        "collection_id": collection_id,
+        "user_id": user_id,
+        "agent_id": agent_id,
+        "run_id": run_id,
+        "limit": limit,
+        "search_type": search_type,
+        "filters": filters or {},
+        "include_low_confidence": include_low_confidence,
+        "group_by_source": group_by_source,
+        "debug": debug,
+        "view": view,
+        "include_proof_context": include_proof_context,
+    }
+    if fast is not None:
+        payload["fast"] = fast
+    if threshold is not None:
+        payload["threshold"] = threshold
+    if prefer_entity_match:
+        payload["prefer_entity_match"] = True
+    if include_profile:
+        payload["include_profile"] = True
+    return {key: value for key, value in payload.items() if value is not None}
+
+
+def _reason_payload(
+    query: str,
+    *,
+    collection_id: Optional[str] = None,
+    provider: Optional[str] = None,
+    include_steps: bool = False,
+    user_id: Optional[str] = None,
+    agent_id: Optional[str] = None,
+    run_id: Optional[str] = None,
+    facets: Optional[List[str]] = None,
+    view: str = "compact",
+    debug: bool = False,
+) -> Dict[str, Any]:
+    """Build the identical /v1/search/reason body for sync and async clients.
+
+    ``view`` defaults to ``"compact"``: the answer, abstention fields, cited
+    sources and safety envelope are kept and the internal decision
+    diagnostics are omitted; ``view="full"`` or ``debug=True`` returns them.
+    """
+
+    if view not in {"compact", "full"}:
+        raise ValueError("view must be 'compact' or 'full'")
+    payload: Dict[str, Any] = {
+        "query": query,
+        "collection_id": collection_id,
+        "provider": provider,
+        "include_steps": include_steps,
+        "user_id": user_id,
+        "agent_id": agent_id,
+        "run_id": run_id,
+        "facets": facets or [],
+        "view": view,
+    }
+    if debug:
+        payload["debug"] = True
+    return payload
+
+
 class SearchResource(BaseResource):
     """Search and reasoning endpoints."""
 
@@ -1010,7 +1105,9 @@ class SearchResource(BaseResource):
         include_low_confidence: bool = False,
         group_by_source: bool = True,
         debug: bool = False,
-        view: Optional[str] = None,
+        view: Optional[str] = "compact",
+        include_proof_context: Optional[bool] = False,
+        prefer_entity_match: bool = False,
     ) -> List[Dict[str, Any]]:
         """
         Search memories.
@@ -1021,6 +1118,11 @@ class SearchResource(BaseResource):
             limit: Number of results
             search_type: Type of search (hybrid, vector, bm25, graph)
             filters: Additional filters
+            view: ``"compact"`` (default) or ``"full"`` per-row metadata
+            include_proof_context: This method returns only the rows, so the
+                ProofLoop token is not requested by default; use
+                ``search_with_proof`` to keep it.
+            prefer_entity_match: Rank rows naming the query's entities first.
 
         Returns:
             Search results
@@ -1040,6 +1142,8 @@ class SearchResource(BaseResource):
             group_by_source=group_by_source,
             debug=debug,
             view=view,
+            include_proof_context=include_proof_context,
+            prefer_entity_match=prefer_entity_match,
         )
         return response["results"]
 
@@ -1058,36 +1162,41 @@ class SearchResource(BaseResource):
         include_low_confidence: bool = False,
         group_by_source: bool = True,
         debug: bool = False,
-        view: Optional[str] = None,
+        view: Optional[str] = "compact",
+        include_proof_context: Optional[bool] = None,
+        prefer_entity_match: bool = False,
+        include_profile: bool = False,
     ) -> SearchSafetyEnvelope:
         """Search and preserve the automatic ProofLoop context.
 
         The legacy ``search`` method still returns only the result list. Use
-        this method when the selected evidence will feed a learned decision.
+        this method when the selected evidence will feed a learned decision,
+        or to read ``profile`` (``include_profile=True``) and
+        ``query_entities``. Responses are compact by default; pass
+        ``view="full"`` or ``debug=True`` for diagnostics.
         """
 
-        _validate_advice_view(view)
-        payload: Dict[str, Any] = {
-            "query": query,
-            "collection_id": collection_id,
-            "user_id": user_id,
-            "agent_id": agent_id,
-            "run_id": run_id,
-            "limit": limit,
-            "search_type": search_type,
-            "filters": filters or {},
-            "include_low_confidence": include_low_confidence,
-            "group_by_source": group_by_source,
-            "debug": debug,
-            "view": view,
-        }
-        if fast is not None:
-            payload["fast"] = fast
-        if threshold is not None:
-            payload["threshold"] = threshold
         response = await self.client.post(
             "/v1/search",
-            json={key: value for key, value in payload.items() if value is not None},
+            json=_search_payload(
+                query,
+                collection_id=collection_id,
+                limit=limit,
+                search_type=search_type,
+                filters=filters,
+                user_id=user_id,
+                agent_id=agent_id,
+                run_id=run_id,
+                fast=fast,
+                threshold=threshold,
+                include_low_confidence=include_low_confidence,
+                group_by_source=group_by_source,
+                debug=debug,
+                view=view,
+                include_proof_context=include_proof_context,
+                prefer_entity_match=prefer_entity_match,
+                include_profile=include_profile,
+            ),
         )
         return _canonical_search_envelope(response)
 
@@ -1123,6 +1232,8 @@ class SearchResource(BaseResource):
         agent_id: Optional[str] = None,
         run_id: Optional[str] = None,
         facets: Optional[List[str]] = None,
+        view: str = "compact",
+        debug: bool = False,
     ) -> SearchSafetyEnvelope:
         """
         Perform reasoning over memories.
@@ -1136,22 +1247,26 @@ class SearchResource(BaseResource):
             agent_id: Agent isolation scope
             run_id: Run isolation scope
             facets: Optional typed decomposition facets
+            view: ``"compact"`` (default) or ``"full"`` diagnostics
+            debug: Return the full diagnostic response
 
         Returns:
             Reasoning result with answer and sources
         """
         response = await self.client.post(
             "/v1/search/reason",
-            json={
-                "query": query,
-                "collection_id": collection_id,
-                "provider": provider,
-                "include_steps": include_steps,
-                "user_id": user_id,
-                "agent_id": agent_id,
-                "run_id": run_id,
-                "facets": facets or [],
-            },
+            json=_reason_payload(
+                query,
+                collection_id=collection_id,
+                provider=provider,
+                include_steps=include_steps,
+                user_id=user_id,
+                agent_id=agent_id,
+                run_id=run_id,
+                facets=facets,
+                view=view,
+                debug=debug,
+            ),
         )
         return _canonical_search_envelope(response, rows_key="sources")
 
@@ -1170,6 +1285,15 @@ class ProofLoopResource(BaseResource):
         idempotency_key: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, Any]:
+        """Log one decision among 1-50 candidate actions.
+
+        Each candidate is ``{"action_key": str, "description"?: str,
+        "features"?: dict, "memory_ids"?: list[str]}``. ``memory_ids`` (at most
+        50) names the exact memories the action applies, such as its runbook;
+        when that candidate becomes the decision's action, its outcome is
+        credited to those memories. A ``proof_context`` attests what was
+        retrieved but never earns per-memory outcome credit by itself.
+        """
         token = (
             proof_context.get("token")
             if isinstance(proof_context, dict)
@@ -1633,6 +1757,9 @@ class RLResource(BaseResource):
         """
         Train the Memory Manager agent using RL.
 
+        Operator-only: the server requires a Hebbrix administrator session and
+        refuses API keys with 403, so this route is not in the public OpenAPI.
+
         Args:
             num_episodes: Number of training episodes
             **kwargs: Additional training parameters
@@ -1656,6 +1783,9 @@ class RLResource(BaseResource):
         """
         Train the Answer Agent using RL.
 
+        Operator-only: the server requires a Hebbrix administrator session and
+        refuses API keys with 403, so this route is not in the public OpenAPI.
+
         Args:
             num_episodes: Number of training episodes
             **kwargs: Additional training parameters

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix/sync_client.py

@@ -17,7 +17,12 @@ from hebbrix.exceptions import (
     ServerError,
     ValidationError,
 )
-from hebbrix.resources import _canonical_search_envelope, _memory_create_payload
+from hebbrix.resources import (
+    _canonical_search_envelope,
+    _memory_create_payload,
+    _reason_payload,
+    _search_payload,
+)
 from hebbrix._advice import _snapshot_advisor_inputs, _validated_advisor_selection, _validate_advisor_scope, _validate_advisor_horizon
 
 
@@ -576,35 +581,39 @@ class SyncSearchResource:
         include_low_confidence: bool = False,
         group_by_source: bool = True,
         debug: bool = False,
-        view: Optional[str] = None,
+        view: Optional[str] = "compact",
+        include_proof_context: Optional[bool] = None,
+        prefer_entity_match: bool = False,
+        include_profile: bool = False,
     ) -> Dict[str, Any]:
-        from ._advice import _validate_advice_view
-        _validate_advice_view(view)
-        payload: Dict[str, Any] = {
-            "query": query,
-            "collection_id": collection_id,
-            "user_id": user_id,
-            "agent_id": agent_id,
-            "run_id": run_id,
-            "limit": limit,
-            "search_type": search_type,
-            "filters": filters or {},
-            "include_low_confidence": include_low_confidence,
-            "group_by_source": group_by_source,
-            "debug": debug,
-            "view": view,
-        }
-        if fast is not None:
-            payload["fast"] = fast
-        if threshold is not None:
-            payload["threshold"] = threshold
         response = self.client.post(
             "/v1/search",
-            json={key: value for key, value in payload.items() if value is not None},
+            json=_search_payload(
+                query,
+                collection_id=collection_id,
+                limit=limit,
+                search_type=search_type,
+                filters=filters,
+                user_id=user_id,
+                agent_id=agent_id,
+                run_id=run_id,
+                fast=fast,
+                threshold=threshold,
+                include_low_confidence=include_low_confidence,
+                group_by_source=group_by_source,
+                debug=debug,
+                view=view,
+                include_proof_context=include_proof_context,
+                prefer_entity_match=prefer_entity_match,
+                include_profile=include_profile,
+            ),
         )
         return _canonical_search_envelope(response)
 
     def search(self, *args, **kwargs) -> List[Dict[str, Any]]:
+        # Only the rows are returned, so the proof token is not requested
+        # unless the caller asks for it (parity with the async client).
+        kwargs.setdefault("include_proof_context", False)
         return self.search_with_proof(*args, **kwargs).get("results", [])
 
     def reason(
@@ -617,19 +626,23 @@ class SyncSearchResource:
         agent_id: Optional[str] = None,
         run_id: Optional[str] = None,
         facets: Optional[List[str]] = None,
+        view: str = "compact",
+        debug: bool = False,
     ) -> Dict[str, Any]:
         response = self.client.post(
             "/v1/search/reason",
-            json={
-                "query": query,
-                "collection_id": collection_id,
-                "provider": provider,
-                "include_steps": include_steps,
-                "user_id": user_id,
-                "agent_id": agent_id,
-                "run_id": run_id,
-                "facets": facets or [],
-            },
+            json=_reason_payload(
+                query,
+                collection_id=collection_id,
+                provider=provider,
+                include_steps=include_steps,
+                user_id=user_id,
+                agent_id=agent_id,
+                run_id=run_id,
+                facets=facets,
+                view=view,
+                debug=debug,
+            ),
         )
         return _canonical_search_envelope(response, rows_key="sources")
 
@@ -649,6 +662,15 @@ class SyncProofLoopResource:
         idempotency_key: Optional[str] = None,
         **kwargs,
     ) -> Dict[str, Any]:
+        """Log one decision among 1-50 candidate actions.
+
+        Each candidate is ``{"action_key": str, "description"?: str,
+        "features"?: dict, "memory_ids"?: list[str]}``. ``memory_ids`` (at most
+        50) names the exact memories the action applies, such as its runbook;
+        when that candidate becomes the decision's action, its outcome is
+        credited to those memories. A ``proof_context`` attests what was
+        retrieved but never earns per-memory outcome credit by itself.
+        """
         token = (
             proof_context.get("token")
             if isinstance(proof_context, dict)
@@ -1110,7 +1132,7 @@ class SyncMemoryClient:
         self.source = source or os.getenv("HEBBRIX_SOURCE")
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.6.2",
+            "User-Agent": "hebbrix-python/2.7.0",
         }
         if api_key:
             headers["Authorization"] = f"Bearer {api_key}"

{hebbrix-2.6.2 → hebbrix-2.7.0/hebbrix.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.6.2
+Version: 2.7.0
 Summary: Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs
 Author-email: Hebbrix Team <support@hebbrix.com>
 Maintainer-email: Hebbrix Team <support@hebbrix.com>
@@ -65,14 +65,14 @@ Dynamic: license-file
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-The current stable package is **2.6.2**. Start with memory storage and search, or
+The current stable package is **2.7.0**. Start with memory storage and search, or
 the three-call outcome-learning workflow below. Advanced evidence and execution
 permission transports are opt-in; installing the SDK never permits an action.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.2
+pip install hebbrix==2.7.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -151,8 +151,21 @@ The canonical `gate` is `ASK`, `REVIEW`, `ACT`, or `BLOCK`. `BLOCK` dominates;
 `ACT` is advice, not permission. Apply your own current authorization and human
 approval policy before executing any tool. Do not infer permission from a score.
 
+Version 2.7.0 makes search and reason responses compact by default: rows keep
+content, identity, score, timestamps, confidence and entity scope (`applies_to`,
+`entity_match`), and Reason keeps the answer, `decision_abstained`,
+`abstain_reason` and cited sources. Pass `view="full"` or `debug=True` for
+diagnostics. `search_with_proof(include_profile=True)` returns standing profile
+facts and preferences, and `MemoryChat.send(answer_style="quote")` returns the
+stored source text verbatim instead of a plain-language reply.
+
+Version 2.6.3 lets each `proofloop.decide` candidate carry `memory_ids`: the exact
+memories that action applies. When that candidate becomes the decision's action,
+its outcome is credited to those memories; a `proof_context` attests what was
+retrieved but never earns per-memory outcome credit by itself.
+
 Version 2.6.2 adds compact advice, batch, and explicit confirmation helpers.
-They require matching Round9 server routes. Compact views retain scope and safety
+They require a matching server release. Compact views retain scope and safety
 caveats; complete receipts remain on the server.
 
 ## Durable readiness

{hebbrix-2.6.2 → hebbrix-2.7.0}/hebbrix.egg-info/SOURCES.txt

@@ -27,6 +27,8 @@ hebbrix.egg-info/requires.txt
 hebbrix.egg-info/top_level.txt
 tests/test_advanced_resources.py
 tests/test_advisor_integrity.py
+tests/test_chat_answer_options.py
+tests/test_compact_search_default.py
 tests/test_customer_developer_experience.py
 tests/test_evidence_loop_resource.py
 tests/test_evidence_safety_boundary.py

{hebbrix-2.6.2 → hebbrix-2.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hebbrix"
-version = "2.6.2"
+version = "2.7.0"
 description = "Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs"
 readme = "README.md"
 requires-python = ">=3.8"

{hebbrix-2.6.2 → hebbrix-2.7.0}/tests/test_advisor_integrity.py

@@ -274,3 +274,33 @@ async def test_cyclic_json_is_refused_before_read(kind):
     with pytest.raises(ValueError):
         await invoke(kind, client, params, advisor)
     client.get.assert_not_called()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+async def test_candidate_memory_ids_reach_the_decision_unchanged(kind):
+    """A candidate may bind the memories its action applies (outcome credit)."""
+    client = transport(kind)
+    params = inputs()
+    params["candidates"][1]["memory_ids"] = ["runbook-memory", "checklist-memory"]
+    await invoke(kind, client, params, Mock(return_value=choice()))
+    candidates = client.post.call_args.kwargs["json"]["candidates"]
+    assert candidates[1]["memory_ids"] == ["runbook-memory", "checklist-memory"]
+    assert "memory_ids" not in candidates[0]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize(
+    "memory_ids",
+    ["runbook-memory", [""], ["x" * 256], [7], ["m"] * 51, {"id": "m"}],
+)
+async def test_invalid_candidate_memory_ids_fail_before_reads(kind, memory_ids):
+    client, advisor = transport(kind), Mock(return_value=choice())
+    params = inputs()
+    params["candidates"][0]["memory_ids"] = memory_ids
+    with pytest.raises(ValueError):
+        await invoke(kind, client, params, advisor)
+    client.get.assert_not_called()
+    client.post.assert_not_called()
+    advisor.assert_not_called()

hebbrix-2.7.0/tests/test_chat_answer_options.py

@@ -0,0 +1,57 @@
+"""MemoryChat exposes the reply-phrasing fields of /v1/chat/completions.
+
+answer_style ("natural" by default on the server, or "quote") and
+no_information_reply are sent only when set, so the server defaults apply and
+older servers see the same request as before.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+from hebbrix.chat import MemoryChat
+
+
+def _response():
+    response = Mock()
+    response.json.return_value = {
+        "choices": [{"message": {"content": "You live in Varnhold."}}],
+        "memory_context": {"answer_composition": "composed_from_sources"},
+        "usage": {},
+        "model": "test",
+    }
+    return response
+
+
+@pytest.mark.parametrize("method", ["send", "send_with_context"])
+def test_answer_options_are_sent_only_when_set(method):
+    chat = MemoryChat(api_key="local-test", model="test")
+    with patch("hebbrix.chat.requests.post", return_value=_response()) as post:
+        getattr(chat, method)("Where do I live?", "s")
+        getattr(chat, method)(
+            "Where do I live?",
+            "s",
+            answer_style="quote",
+            no_information_reply="Not on file yet.",
+        )
+    default, explicit = (call.kwargs["json"] for call in post.call_args_list)
+    assert "answer_style" not in default and "no_information_reply" not in default
+    assert explicit["answer_style"] == "quote"
+    assert explicit["no_information_reply"] == "Not on file yet."
+
+
+@pytest.mark.parametrize(
+    "options",
+    [
+        {"answer_style": "verbatim"},
+        {"answer_style": ""},
+        {"no_information_reply": ""},
+        {"no_information_reply": "x" * 501},
+        {"no_information_reply": 3},
+    ],
+)
+def test_invalid_answer_options_fail_before_the_request(options):
+    chat = MemoryChat(api_key="local-test", model="test")
+    with patch("hebbrix.chat.requests.post") as post:
+        with pytest.raises(ValueError):
+            chat.send("Where do I live?", "s", **options)
+    post.assert_not_called()

hebbrix-2.7.0/tests/test_compact_search_default.py

@@ -0,0 +1,117 @@
+"""Compact is the SDK search default (customer report 2026-10-18, issue 12)."""
+
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+from hebbrix.resources import SearchResource
+from hebbrix.sync_client import SyncSearchResource
+
+ENVELOPE = {
+    "query": "q",
+    "results": [{"memory_id": "m", "content": "fact", "score": 0.9}],
+    "total": 1,
+    "no_match": False,
+    "abstain_recommended": False,
+    "query_confidence": 0.9,
+    "grounding": {"status": "supported"},
+    "evidence_ids": ["m"],
+    "safety_contract_version": "search-safety-v1",
+    "view": "compact",
+    "query_entities": [],
+    "profile": {"status": "ok", "facts": [], "count": 0},
+}
+
+
+def clients():
+    sync, asynchronous = Mock(), Mock()
+    sync.post.return_value = dict(ENVELOPE)
+    asynchronous.post = AsyncMock(return_value=dict(ENVELOPE))
+    return sync, asynchronous
+
+
+@pytest.mark.asyncio
+async def test_search_with_proof_defaults_to_compact_and_keeps_proof():
+    sync, asynchronous = clients()
+    first = SyncSearchResource(sync).search_with_proof("q", user_id="u")
+    second = await SearchResource(asynchronous).search_with_proof("q", user_id="u")
+    assert first == second
+    assert sync.post.call_args == asynchronous.post.call_args
+    body = sync.post.call_args.kwargs["json"]
+    assert body["view"] == "compact"
+    # The proof token stays the server default for proof-bound workflows.
+    assert "include_proof_context" not in body
+    # Opt-in fields are absent unless enabled (older servers reject unknowns).
+    assert "prefer_entity_match" not in body and "include_profile" not in body
+    assert first["view"] == "compact" and first["profile"]["status"] == "ok"
+
+
+@pytest.mark.asyncio
+async def test_rows_only_search_does_not_request_the_proof_token():
+    sync, asynchronous = clients()
+    rows = SyncSearchResource(sync).search("q", user_id="u")
+    assert rows == ENVELOPE["results"]
+    await SearchResource(asynchronous).search("q", user_id="u")
+    for client in (sync, asynchronous):
+        body = client.post.call_args.kwargs["json"]
+        assert body["view"] == "compact"
+        assert body["include_proof_context"] is False
+
+
+@pytest.mark.asyncio
+async def test_full_view_debug_and_new_options_are_explicit():
+    sync, asynchronous = clients()
+    kwargs = dict(
+        user_id="u",
+        view="full",
+        debug=True,
+        prefer_entity_match=True,
+        include_profile=True,
+        include_proof_context=True,
+    )
+    SyncSearchResource(sync).search_with_proof("q", **kwargs)
+    await SearchResource(asynchronous).search_with_proof("q", **kwargs)
+    assert sync.post.call_args == asynchronous.post.call_args
+    body = sync.post.call_args.kwargs["json"]
+    assert body["view"] == "full" and body["debug"] is True
+    assert body["prefer_entity_match"] is True and body["include_profile"] is True
+    assert body["include_proof_context"] is True
+    SyncSearchResource(sync).search("q", user_id="u", include_proof_context=True)
+    assert sync.post.call_args.kwargs["json"]["include_proof_context"] is True
+
+
+def test_invalid_view_still_fails_before_the_request():
+    sync, _ = clients()
+    with pytest.raises(ValueError, match="view must be full or compact"):
+        SyncSearchResource(sync).search_with_proof("q", view="tiny")
+    sync.post.assert_not_called()
+
+
+REASON = {
+    "answer": "a",
+    "sources": [{"memory_id": "m", "content": "fact", "score": 0.9}],
+    "metadata": {},
+    "no_match": False,
+    "abstain_recommended": False,
+    "query_confidence": 0.9,
+    "grounding": {"status": "supported"},
+    "evidence_ids": ["m"],
+    "safety_contract_version": "search-safety-v1",
+}
+
+
+@pytest.mark.asyncio
+async def test_reason_defaults_to_compact_and_debug_is_explicit():
+    sync, asynchronous = Mock(), Mock()
+    sync.post.return_value = dict(REASON)
+    asynchronous.post = AsyncMock(return_value=dict(REASON))
+    SyncSearchResource(sync).reason("q", user_id="u")
+    await SearchResource(asynchronous).reason("q", user_id="u")
+    assert sync.post.call_args == asynchronous.post.call_args
+    body = sync.post.call_args.kwargs["json"]
+    assert body["view"] == "compact"
+    assert "debug" not in body
+    SyncSearchResource(sync).reason("q", user_id="u", view="full", debug=True)
+    body = sync.post.call_args.kwargs["json"]
+    assert body["view"] == "full" and body["debug"] is True
+    with pytest.raises(ValueError):
+        SyncSearchResource(sync).reason("q", user_id="u", view="tiny")

{hebbrix-2.6.2 → hebbrix-2.7.0}/tests/test_customer_developer_experience.py

@@ -162,6 +162,6 @@ def test_package_docs_metadata_uses_canonical_host():
     assert 'Documentation = "https://hebbrix.com/docs"' in text
     assert "docs.hebbrix.com" not in text
     readme = (root / "README.md").read_text()
-    assert "pip install hebbrix==2.6.2" in readme
+    assert "pip install hebbrix==2.7.0" in readme
     assert "three calls" in readme
     assert "schema `" not in readme