hebbrix 2.6.0rc4__tar.gz → 2.6.1__tar.gz

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 2.6.1 — 2026-10-04 (advisory horizon helpers)
+
+- Carry optional remaining_decisions and max_pilot_decisions through evidence reads and the once-only advisor callback.
+- Keep actual caller distribution validation, owner scope and observe-mode logging unchanged.
+- New backend v3 controls remain explicit experimental opt-ins; these helpers do not execute actions or establish performance, calibration or superiority.
+
+## 2.6.0 — 2026-10-04 (stable SDK)
+
+- Bound runtime HTTPX to `>=0.25.0,<1`, excluding incompatible 1.x prereleases.
+- Add sync/async atomic setup options for explicit policy configuration and built-in success-minus-cost metrics.
+- Keep advisor input/probability validation, scope and protected evidence transports unchanged.
+- Backend v3 learning methods remain explicit experimental opt-ins. Stable packaging does not establish performance, calibrated confidence or execution permission.
+
+## 2.6.0rc5 — 2026-10-03 (prerelease)
+
+- Snapshot advisor context/candidates and reject scope overrides or mutable identities.
+- Validate the complete finite logging distribution against original candidates before writing.
+- Invoke the callback once; preserve caller probabilities without normalization or retries.
+- Caller probabilities are not authenticated randomization; no execution authority or measured learning-performance gain is claimed.
+
 ## 2.6.0rc4 — 2026-10-02 (prerelease)
 
 - Correct both HTTP User-Agent version strings and add a source-version parity

{hebbrix-2.6.0rc4/hebbrix.egg-info → hebbrix-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.6.0rc4
+Version: 2.6.1
 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>
@@ -33,7 +33,7 @@ Project-URL: Issues, https://github.com/Hebbrix/hebbrix-python/issues
 Project-URL: Support, https://www.hebbrix.com/contact
 Project-URL: API Reference, https://api.hebbrix.com/docs
 Keywords: ai,memory,agents,llm,chatbot,assistant,ml,reinforcement-learning,knowledge-graph,vector-search,rag,temporal,procedural-memory,working-memory
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -49,7 +49,7 @@ Classifier: Framework :: AsyncIO
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: httpx>=0.25.0
+Requires-Dist: httpx<1,>=0.25.0
 Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
@@ -65,15 +65,15 @@ Dynamic: license-file
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-This branch is the **2.6.0rc2 prerelease**. The new policy configuration and
+This branch is the **2.6.0 stable SDK**. The new policy configuration and
 advice helpers require backend schema `e5f6g7h8i868` or a compatible successor.
-A prerelease SDK does not enable autonomous execution. ASK/REVIEW/ACT is advice;
+A stable SDK does not qualify experimental learning or enable autonomous execution. ASK/REVIEW/ACT is advice;
 an action still requires independent permission.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.0rc2
+pip install hebbrix==2.6.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -81,6 +81,15 @@ supports the core collection, memory, search, correction, procedure, and
 ProofLoop workflows; advanced temporal, working-memory, consolidation,
 memory-tool, and RL resources are currently async-only.
 
+The runtime requires `httpx>=0.25.0,<1`; incompatible 1.x prereleases are excluded.
+For the matching Round 5 backend, `setup_policy` accepts explicit `configuration`
+options for versioned change response and declared optional-field sharing, plus
+`value_objective={"success_value":10,"max_cost":20,"cost_unit":"USD"}`.
+Report both actual success and cost with `record_outcome`. Chat follow-up capture
+requires `features.learning: true` and an exact `outcome_followup.decision_id`;
+captured signals are provisional, not verified execution or autonomy evidence.
+These options require the matching runtime, not only the unchanged database schema.
+
 ## Quick start
 
 October 2 follow-up: `proofloop.setup_policy` atomically creates a new

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/README.md

@@ -2,15 +2,15 @@
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-This branch is the **2.6.0rc2 prerelease**. The new policy configuration and
+This branch is the **2.6.0 stable SDK**. The new policy configuration and
 advice helpers require backend schema `e5f6g7h8i868` or a compatible successor.
-A prerelease SDK does not enable autonomous execution. ASK/REVIEW/ACT is advice;
+A stable SDK does not qualify experimental learning or enable autonomous execution. ASK/REVIEW/ACT is advice;
 an action still requires independent permission.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.0rc2
+pip install hebbrix==2.6.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -18,6 +18,15 @@ supports the core collection, memory, search, correction, procedure, and
 ProofLoop workflows; advanced temporal, working-memory, consolidation,
 memory-tool, and RL resources are currently async-only.
 
+The runtime requires `httpx>=0.25.0,<1`; incompatible 1.x prereleases are excluded.
+For the matching Round 5 backend, `setup_policy` accepts explicit `configuration`
+options for versioned change response and declared optional-field sharing, plus
+`value_objective={"success_value":10,"max_cost":20,"cost_unit":"USD"}`.
+Report both actual success and cost with `record_outcome`. Chat follow-up capture
+requires `features.learning: true` and an exact `outcome_followup.decision_id`;
+captured signals are provisional, not verified execution or autonomy evidence.
+These options require the matching runtime, not only the unchanged database schema.
+
 ## Quick start
 
 October 2 follow-up: `proofloop.setup_policy` atomically creates a new

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/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.0rc4"
+__version__ = "2.6.1"
 __author__ = "Hebbrix Team"
 __license__ = "MIT"
 

hebbrix-2.6.1/hebbrix/_advice.py

@@ -0,0 +1,152 @@
+"""Local advisor wire-integrity checks; not authorization or propensity proof."""
+
+import json
+import math
+import re
+
+
+def _validate_advisor_horizon(remaining_decisions, max_pilot_decisions):
+    for field, value, maximum in (("remaining_decisions", remaining_decisions, 10000),
+                                  ("max_pilot_decisions", max_pilot_decisions, 8)):
+        if value is not None and (type(value) is not int or not 1 <= value <= maximum):
+            raise ValueError("{} must be an integer within the API limit".format(field))
+
+
+def _validate_advisor_scope(policy_key, collection_id, user_id, idempotency_key):
+    if (
+        type(policy_key) is not str
+        or not 1 <= len(policy_key) <= 100
+        or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._:-]*", policy_key)
+    ):
+        raise ValueError("policy_key must be an exact valid policy identity")
+    for field, value, limit in (
+        ("collection_id", collection_id, None),
+        ("user_id", user_id, 255),
+        ("idempotency_key", idempotency_key, 160),
+    ):
+        if value is not None and (
+            type(value) is not str or (limit is not None and len(value) > limit)
+        ):
+            raise ValueError(
+                "{} must be an immutable string within the API limit".format(field)
+            )
+
+
+def _json_snapshot(value, field, max_bytes):
+    def check(item):
+        if type(item) is dict:
+            for key, child in item.items():
+                if type(key) is not str:
+                    raise ValueError("{} must contain string JSON keys".format(field))
+                check(child)
+        elif type(item) is list:
+            for child in item:
+                check(child)
+        elif type(item) not in (str, int, float, bool, type(None)):
+            raise ValueError("{} must contain only JSON values".format(field))
+
+    try:
+        check(value)
+        encoded = json.dumps(
+            value, ensure_ascii=False, separators=(",", ":"), allow_nan=False
+        )
+        if len(encoded.encode("utf-8")) > max_bytes:
+            raise ValueError("{} exceeds the API JSON size limit".format(field))
+        return json.loads(encoded)
+    except (TypeError, OverflowError, RecursionError) as exc:
+        raise ValueError(
+            "{} must contain finite acyclic JSON values".format(field)
+        ) from exc
+
+
+def _snapshot_advisor_inputs(candidates, context):
+    """Detach inputs before the first evidence request/callback, without coercion."""
+    if type(context) is not dict:
+        raise ValueError("context must be a JSON object")
+    if type(candidates) is not list or not 1 <= len(candidates) <= 50:
+        raise ValueError("candidates must contain 1-50 distinct actions")
+    context_copy = _json_snapshot(context, "context", 16_384)
+    candidates_copy = _json_snapshot(candidates, "candidates", 64_000)
+    keys = []
+    for candidate in candidates_copy:
+        if type(candidate) is not dict or set(candidate) - {
+            "action_key",
+            "description",
+            "features",
+        }:
+            raise ValueError(
+                "candidates must contain only action_key, description and features"
+            )
+        key = candidate.get("action_key")
+        if (
+            type(key) is not str
+            or not 1 <= len(key) <= 160
+            or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._:/-]*", key)
+        ):
+            raise ValueError(
+                "candidate action_key must be an exact valid action identity"
+            )
+        if key in keys:
+            raise ValueError("candidate action_key must be unique")
+        if candidate.get("description") is not None and (
+            type(candidate["description"]) is not str
+            or len(candidate["description"]) > 1000
+        ):
+            raise ValueError(
+                "candidate description must be a string of at most 1000 characters"
+            )
+        if "features" in candidate and type(candidate["features"]) is not dict:
+            raise ValueError("candidate features must be a JSON object")
+        keys.append(key)
+    return candidates_copy, context_copy, keys
+
+
+def _validated_advisor_selection(selection, candidate_keys):
+    message = (
+        "advisor must return the choice and its actual complete logging distribution"
+    )
+    if type(selection) is not dict or set(selection) != {
+        "chosen_action_key",
+        "action_probability",
+        "behavior_probabilities",
+    }:
+        raise ValueError(message)
+    chosen = selection["chosen_action_key"]
+    if type(chosen) is not str or chosen not in candidate_keys:
+        raise ValueError("chosen_action_key must be one of the original candidates")
+    probabilities = selection["behavior_probabilities"]
+    if type(probabilities) is not dict or set(probabilities) != set(candidate_keys):
+        raise ValueError(
+            "behavior_probabilities must cover exactly all original candidates"
+        )
+
+    def probability(value):
+        if (
+            type(value) not in (int, float)
+            or not 0 <= value <= 1
+            or not math.isfinite(value)
+        ):
+            raise ValueError(
+                "logging probabilities must be finite numbers in [0, 1], not confidence strings or booleans"
+            )
+        return value
+
+    detached = {key: probability(probabilities[key]) for key in candidate_keys}
+    if not math.isclose(sum(detached.values()), 1.0, abs_tol=1e-8, rel_tol=0):
+        raise ValueError(
+            "behavior_probabilities must sum to 1; the helper never renormalizes"
+        )
+    selected_probability = probability(selection["action_probability"])
+    if selected_probability <= 0 or detached[chosen] <= 0:
+        raise ValueError("chosen action must have a positive logging probability")
+    if not math.isclose(
+        detached[chosen], selected_probability, abs_tol=1e-8, rel_tol=0
+    ):
+        raise ValueError(
+            "action_probability must match the chosen action's behavior probability"
+        )
+    return dict(
+        chosen_action_key=chosen,
+        action_probability=selected_probability,
+        behavior_probabilities=detached,
+    )

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/hebbrix/client.py

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

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/hebbrix/resources.py

@@ -13,6 +13,7 @@ from urllib.parse import quote
 
 from hebbrix.exceptions import IndexingTimeoutError
 from hebbrix.models import SearchSafetyEnvelope
+from hebbrix._advice import _snapshot_advisor_inputs, _validated_advisor_selection, _validate_advisor_scope, _validate_advisor_horizon
 
 if TYPE_CHECKING:
     from hebbrix.client import MemoryClient
@@ -1380,14 +1381,18 @@ class ProofLoopResource(BaseResource):
 
     async def setup_policy(self, policy_key: str, *, context_schema: Dict[str, Any],
                            actions: Dict[str, Any], collection_id: Optional[str] = None,
-                           user_id: Optional[str] = None) -> Dict[str, Any]:
+                           user_id: Optional[str] = None,
+                           configuration: Optional[Dict[str, Any]] = None,
+                           value_objective: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """One atomic setup call. Risk/target/description are supplied by the owner.
         Only explicitly low-risk exploration_allowed actions learn by default.
         This neither permits execution nor changes an existing policy.
         """
         return await self.client.post(f"/v1/learning/policies/{quote(policy_key, safe='')}/setup",
             json=dict(collection_id=collection_id, user_id=user_id,
-                context_schema=context_schema, configuration=dict(actions=actions)))
+                context_schema=context_schema,
+                configuration={**(configuration or {}), "actions": actions},
+                **({"value_objective": value_objective} if value_objective is not None else {})))
 
     async def learning_report(self, policy_key: str, *, days: int = 7,
                               collection_id: Optional[str] = None,
@@ -1401,18 +1406,27 @@ class ProofLoopResource(BaseResource):
                                  context: Dict[str, Any], advisor,
                                  collection_id: Optional[str] = None,
                                  user_id: Optional[str] = None,
-                                 idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+                                 idempotency_key: Optional[str] = None,
+                                 remaining_decisions: Optional[int] = None,
+                                 max_pilot_decisions: Optional[int] = None) -> Dict[str, Any]:
         """Read evidence, call your advisor once, then log its explicit choice.
         advisor must return chosen_action_key, action_probability and the complete
         behavior_probabilities. No model confidence is invented as a propensity.
-        No tool execution or outcome is recorded by this helper.
-        """
+        Inputs are detached before reading evidence; callback mutations cannot
+        change the logged scope/candidates/context. Malformed distributions fail
+        before logging, without retries or normalization. Caller probabilities
+        remain caller-reported, not authenticated randomization. No tool execution
+        or outcome is recorded by this helper.
+        """
+        _validate_advisor_scope(policy_key, collection_id, user_id, idempotency_key)
+        _validate_advisor_horizon(remaining_decisions, max_pilot_decisions)
+        candidates, context, keys = _snapshot_advisor_inputs(candidates, context)
+        if not callable(advisor):
+            raise ValueError("advisor must be callable")
         card = await self.policy_advice(policy_key, context=context,
-            collection_id=collection_id, user_id=user_id)
-        selection = await advisor(card)
-        if not isinstance(selection, dict) or set(selection) != {
-            "chosen_action_key", "action_probability", "behavior_probabilities"}:
-            raise ValueError("advisor must return the choice and its actual complete logging distribution")
+            collection_id=collection_id, user_id=user_id,
+            remaining_decisions=remaining_decisions, max_pilot_decisions=max_pilot_decisions)
+        selection = _validated_advisor_selection(await advisor(card), keys)
         return await self.decide(policy_key=policy_key, candidates=candidates, context=context,
             collection_id=collection_id, user_id=user_id, idempotency_key=idempotency_key,
             mode="observe", **selection)
@@ -1432,11 +1446,14 @@ class ProofLoopResource(BaseResource):
             params={k: v for k, v in dict(collection_id=collection_id, user_id=user_id).items() if v is not None})
 
     async def policy_advice(self, policy_key: str, *, context: Optional[Dict[str, Any]] = None,
-                            collection_id: Optional[str] = None, user_id: Optional[str] = None) -> Dict[str, Any]:
+                            collection_id: Optional[str] = None, user_id: Optional[str] = None,
+                            remaining_decisions: Optional[int] = None,
+                            max_pilot_decisions: Optional[int] = None) -> Dict[str, Any]:
         """Read caller-reported evidence and a candidate, never an execution permit."""
         return await self.client.get(f"/v1/learning/policies/{quote(policy_key, safe='')}/advice",
             params={k: v for k, v in dict(context=json.dumps(context or {}),
-                collection_id=collection_id, user_id=user_id).items() if v is not None})
+                collection_id=collection_id, user_id=user_id,
+                remaining_decisions=remaining_decisions, max_pilot_decisions=max_pilot_decisions).items() if v is not None})
 
     async def action_advice(self, query: str, *, policy_key: str, action_key: str,
                            context: Optional[Dict[str, Any]] = None, collection_id: Optional[str] = None,

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/hebbrix/sync_client.py

@@ -18,6 +18,7 @@ from hebbrix.exceptions import (
     ValidationError,
 )
 from hebbrix.resources import _canonical_search_envelope, _memory_create_payload
+from hebbrix._advice import _snapshot_advisor_inputs, _validated_advisor_selection, _validate_advisor_scope, _validate_advisor_horizon
 
 
 class SyncCollectionsResource:
@@ -858,14 +859,18 @@ class SyncProofLoopResource:
 
     def setup_policy(self, policy_key: str, *, context_schema: Dict[str, Any],
                            actions: Dict[str, Any], collection_id: Optional[str] = None,
-                           user_id: Optional[str] = None) -> Dict[str, Any]:
+                           user_id: Optional[str] = None,
+                           configuration: Optional[Dict[str, Any]] = None,
+                           value_objective: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
         """One atomic setup call. Risk/target/description are supplied by the owner.
         Only explicitly low-risk exploration_allowed actions learn by default.
         This neither permits execution nor changes an existing policy.
         """
         return self.client.post(f"/v1/learning/policies/{quote(policy_key, safe='')}/setup",
             json=dict(collection_id=collection_id, user_id=user_id,
-                context_schema=context_schema, configuration=dict(actions=actions)))
+                context_schema=context_schema,
+                configuration={**(configuration or {}), "actions": actions},
+                **({"value_objective": value_objective} if value_objective is not None else {})))
 
     def learning_report(self, policy_key: str, *, days: int = 7,
                               collection_id: Optional[str] = None,
@@ -879,18 +884,27 @@ class SyncProofLoopResource:
                                  context: Dict[str, Any], advisor,
                                  collection_id: Optional[str] = None,
                                  user_id: Optional[str] = None,
-                                 idempotency_key: Optional[str] = None) -> Dict[str, Any]:
+                                 idempotency_key: Optional[str] = None,
+                                 remaining_decisions: Optional[int] = None,
+                                 max_pilot_decisions: Optional[int] = None) -> Dict[str, Any]:
         """Read evidence, call your advisor once, then log its explicit choice.
         advisor must return chosen_action_key, action_probability and the complete
         behavior_probabilities. No model confidence is invented as a propensity.
-        No tool execution or outcome is recorded by this helper.
+        Inputs are detached before reading evidence; callback mutations cannot
+        change the logged scope/candidates/context. Malformed distributions fail
+        before logging, without retries or normalization. Caller probabilities
+        remain caller-reported, not authenticated randomization. No tool execution
+        or outcome is recorded by this helper.
         """
+        _validate_advisor_scope(policy_key, collection_id, user_id, idempotency_key)
+        _validate_advisor_horizon(remaining_decisions, max_pilot_decisions)
+        candidates, context, keys = _snapshot_advisor_inputs(candidates, context)
+        if not callable(advisor):
+            raise ValueError("advisor must be callable")
         card = self.policy_advice(policy_key, context=context,
-            collection_id=collection_id, user_id=user_id)
-        selection = advisor(card)
-        if not isinstance(selection, dict) or set(selection) != {
-            "chosen_action_key", "action_probability", "behavior_probabilities"}:
-            raise ValueError("advisor must return the choice and its actual complete logging distribution")
+            collection_id=collection_id, user_id=user_id,
+            remaining_decisions=remaining_decisions, max_pilot_decisions=max_pilot_decisions)
+        selection = _validated_advisor_selection(advisor(card), keys)
         return self.decide(policy_key=policy_key, candidates=candidates, context=context,
             collection_id=collection_id, user_id=user_id, idempotency_key=idempotency_key,
             mode="observe", **selection)
@@ -910,11 +924,14 @@ class SyncProofLoopResource:
             params={k: v for k, v in dict(collection_id=collection_id, user_id=user_id).items() if v is not None})
 
     def policy_advice(self, policy_key: str, *, context: Optional[Dict[str, Any]] = None,
-                            collection_id: Optional[str] = None, user_id: Optional[str] = None) -> Dict[str, Any]:
+                      collection_id: Optional[str] = None, user_id: Optional[str] = None,
+                      remaining_decisions: Optional[int] = None,
+                      max_pilot_decisions: Optional[int] = None) -> Dict[str, Any]:
         """Read caller-reported evidence and a candidate, never an execution permit."""
         return self.client.get(f"/v1/learning/policies/{quote(policy_key, safe='')}/advice",
             params={k: v for k, v in dict(context=json.dumps(context or {}),
-                collection_id=collection_id, user_id=user_id).items() if v is not None})
+                collection_id=collection_id, user_id=user_id,
+                remaining_decisions=remaining_decisions, max_pilot_decisions=max_pilot_decisions).items() if v is not None})
 
     def action_advice(self, query: str, *, policy_key: str, action_key: str,
                            context: Optional[Dict[str, Any]] = None, collection_id: Optional[str] = None,
@@ -1051,7 +1068,7 @@ class SyncMemoryClient:
         self.source = source or os.getenv("HEBBRIX_SOURCE")
         headers = {
             "Content-Type": "application/json",
-            "User-Agent": "hebbrix-python/2.6.0rc4",
+            "User-Agent": "hebbrix-python/2.6.1",
         }
         if api_key:
             headers["Authorization"] = f"Bearer {api_key}"

{hebbrix-2.6.0rc4 → hebbrix-2.6.1/hebbrix.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hebbrix
-Version: 2.6.0rc4
+Version: 2.6.1
 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>
@@ -33,7 +33,7 @@ Project-URL: Issues, https://github.com/Hebbrix/hebbrix-python/issues
 Project-URL: Support, https://www.hebbrix.com/contact
 Project-URL: API Reference, https://api.hebbrix.com/docs
 Keywords: ai,memory,agents,llm,chatbot,assistant,ml,reinforcement-learning,knowledge-graph,vector-search,rag,temporal,procedural-memory,working-memory
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
@@ -49,7 +49,7 @@ Classifier: Framework :: AsyncIO
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: httpx>=0.25.0
+Requires-Dist: httpx<1,>=0.25.0
 Requires-Dist: requests>=2.31.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0.0; extra == "dev"
@@ -65,15 +65,15 @@ Dynamic: license-file
 
 Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs.
 
-This branch is the **2.6.0rc2 prerelease**. The new policy configuration and
+This branch is the **2.6.0 stable SDK**. The new policy configuration and
 advice helpers require backend schema `e5f6g7h8i868` or a compatible successor.
-A prerelease SDK does not enable autonomous execution. ASK/REVIEW/ACT is advice;
+A stable SDK does not qualify experimental learning or enable autonomous execution. ASK/REVIEW/ACT is advice;
 an action still requires independent permission.
 
 ## Install
 
 ```bash
-pip install hebbrix==2.6.0rc2
+pip install hebbrix==2.6.0
 ```
 
 Python 3.8+ is supported. `MemoryClient` is asynchronous. `SyncMemoryClient`
@@ -81,6 +81,15 @@ supports the core collection, memory, search, correction, procedure, and
 ProofLoop workflows; advanced temporal, working-memory, consolidation,
 memory-tool, and RL resources are currently async-only.
 
+The runtime requires `httpx>=0.25.0,<1`; incompatible 1.x prereleases are excluded.
+For the matching Round 5 backend, `setup_policy` accepts explicit `configuration`
+options for versioned change response and declared optional-field sharing, plus
+`value_objective={"success_value":10,"max_cost":20,"cost_unit":"USD"}`.
+Report both actual success and cost with `record_outcome`. Chat follow-up capture
+requires `features.learning: true` and an exact `outcome_followup.decision_id`;
+captured signals are provisional, not verified execution or autonomy evidence.
+These options require the matching runtime, not only the unchanged database schema.
+
 ## Quick start
 
 October 2 follow-up: `proofloop.setup_policy` atomically creates a new

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/hebbrix.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ contracts/openapi-routes.json
 docs/native-experience-operations.md
 examples/native_reflection_worker.py
 hebbrix/__init__.py
+hebbrix/_advice.py
 hebbrix/chat.py
 hebbrix/client.py
 hebbrix/exceptions.py
@@ -25,6 +26,7 @@ hebbrix.egg-info/entry_points.txt
 hebbrix.egg-info/requires.txt
 hebbrix.egg-info/top_level.txt
 tests/test_advanced_resources.py
+tests/test_advisor_integrity.py
 tests/test_evidence_loop_resource.py
 tests/test_evidence_safety_boundary.py
 tests/test_execution_permission.py

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/hebbrix.egg-info/requires.txt

@@ -1,4 +1,4 @@
-httpx>=0.25.0
+httpx<1,>=0.25.0
 requests>=2.31.0
 
 [dev]

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hebbrix"
-version = "2.6.0rc4"
+version = "2.6.1"
 description = "Typed Python client for Hebbrix memory, retrieval, and outcome-learning APIs"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -33,7 +33,7 @@ keywords = [
     "working-memory"
 ]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
@@ -48,7 +48,7 @@ classifiers = [
     "Framework :: AsyncIO",
 ]
 dependencies = [
-    "httpx>=0.25.0",
+    "httpx>=0.25.0,<1",
     "requests>=2.31.0",
 ]
 

hebbrix-2.6.1/tests/test_advisor_integrity.py

@@ -0,0 +1,276 @@
+"""SDK contract controls, not model reliability or learning-performance tests."""
+
+import copy
+import json
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from hebbrix.resources import ProofLoopResource
+from hebbrix.sync_client import SyncProofLoopResource
+
+
+def inputs():
+    return dict(
+        policy_key="integrity",
+        candidates=[
+            {"action_key": "a", "features": {"nested": ["original"]}},
+            {"action_key": "b"},
+        ],
+        context={"scope": {"environment": "sandbox"}},
+        collection_id="c",
+        user_id="u",
+        idempotency_key="once",
+    )
+
+
+def choice():
+    return dict(
+        chosen_action_key="b",
+        action_probability=1.0,
+        behavior_probabilities={"a": 0.0, "b": 1.0},
+    )
+
+
+async def invoke(kind, client, params, advisor):
+    if kind == "sync":
+        return SyncProofLoopResource(client).decide_with_advice(
+            **params, advisor=advisor
+        )
+
+    async def callback(card):
+        return advisor(card)
+
+    return await ProofLoopResource(client).decide_with_advice(
+        **params, advisor=callback
+    )
+
+
+def transport(kind):
+    client = Mock()
+    card = {"authorization_granted": False, "evidence_card": "untrusted"}
+    client.get = (
+        Mock(return_value=card) if kind == "sync" else AsyncMock(return_value=card)
+    )
+    client.post = (
+        Mock(return_value={"decision_id": "d"})
+        if kind == "sync"
+        else AsyncMock(return_value={"decision_id": "d"})
+    )
+    return client
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+async def test_pilot_horizon_is_advice_only_not_a_decision_input(kind):
+    client = transport(kind)
+    await invoke(kind, client, {**inputs(), "remaining_decisions": 80, "max_pilot_decisions": 2}, Mock(return_value=choice()))
+    query = client.get.call_args.kwargs["params"]
+    assert query["remaining_decisions"] == 80 and query["max_pilot_decisions"] == 2
+    body = client.post.call_args.kwargs["json"]
+    assert "remaining_decisions" not in body and "max_pilot_decisions" not in body
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize("horizon", [True, 0, 10001, 1.5])
+async def test_invalid_horizon_fails_before_advisor_or_reads(kind, horizon):
+    client, advisor = transport(kind), Mock(return_value=choice())
+    with pytest.raises(ValueError):
+        await invoke(kind, client, {**inputs(), "remaining_decisions": horizon}, advisor)
+    client.get.assert_not_called()
+    advisor.assert_not_called()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize("stage", ["evidence_read", "advisor"])
+async def test_original_nested_inputs_survive_mutation(kind, stage):
+    client, params, selected = transport(kind), inputs(), choice()
+    original = copy.deepcopy(params)
+
+    def mutate():
+        params["context"]["scope"]["environment"] = "production"
+        params["candidates"][0]["features"]["nested"].append("changed")
+        params["candidates"].append({"action_key": "foreign"})
+
+    if stage == "evidence_read":
+
+        def read(*args, **kwargs):
+            mutate()
+            return {"authorization_granted": False}
+
+        client.get.side_effect = read
+
+    def callback(card):
+        if stage == "advisor":
+            mutate()
+        return selected
+
+    advisor = Mock(side_effect=callback)
+    await invoke(kind, client, params, advisor)
+    assert (
+        json.loads(client.get.call_args.kwargs["params"]["context"])
+        == original["context"]
+    )
+    body = client.post.call_args.kwargs["json"]
+    assert body["context"] == original["context"]
+    assert body["candidates"] == original["candidates"]
+    assert body["user_id"] == "u" and body["collection_id"] == "c"
+    assert body["mode"] == "observe" and body["idempotency_key"] == "once"
+    advisor.assert_called_once()
+    assert client.post.call_count == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+async def test_returned_distribution_is_not_a_mutable_transport_alias(kind):
+    client, selected = transport(kind), choice()
+    await invoke(kind, client, inputs(), Mock(return_value=selected))
+    selected["behavior_probabilities"]["b"] = 0
+    assert client.post.call_args.kwargs["json"]["behavior_probabilities"] == {
+        "a": 0.0,
+        "b": 1.0,
+    }
+
+
+BAD_CHOICES = [
+    None,
+    [],
+    {**choice(), "user_id": "foreign"},
+    {**choice(), "chosen_action_key": "foreign"},
+    {**choice(), "chosen_action_key": None},
+    {**choice(), "behavior_probabilities": None},
+    {**choice(), "behavior_probabilities": {"b": 1}},
+    {**choice(), "behavior_probabilities": {"a": 0, "b": 1, "c": 0}},
+    {**choice(), "behavior_probabilities": {"a": 0, "b": True}},
+    {**choice(), "behavior_probabilities": {"a": 0, "b": "1"}},
+    {**choice(), "behavior_probabilities": {"a": 0, "b": float("nan")}},
+    {**choice(), "behavior_probabilities": {"a": 0, "b": float("inf")}},
+    {**choice(), "behavior_probabilities": {"a": -0.1, "b": 1.1}},
+    {**choice(), "behavior_probabilities": {"a": 0.1, "b": 1}},
+    {**choice(), "action_probability": True},
+    {**choice(), "action_probability": "1"},
+    {**choice(), "action_probability": None},
+    {**choice(), "action_probability": float("nan")},
+    {**choice(), "action_probability": 0},
+    {**choice(), "action_probability": 1.1},
+    {**choice(), "action_probability": 0.5},
+    {
+        "chosen_action_key": "b",
+        "action_probability": 0,
+        "behavior_probabilities": {"a": 1, "b": 0},
+    },
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize("selected", BAD_CHOICES, ids=range(len(BAD_CHOICES)))
+async def test_invalid_advisor_distribution_never_writes(kind, selected):
+    client, advisor = transport(kind), Mock(return_value=selected)
+    with pytest.raises(ValueError):
+        await invoke(kind, client, inputs(), advisor)
+    assert client.get.call_count == 1 and advisor.call_count == 1
+    client.post.assert_not_called()
+
+
+BAD_INPUTS = [
+    {"policy_key": " invalid"},
+    {"policy_key": "path/policy"},
+    {"policy_key": {}},
+    {"collection_id": {}},
+    {"user_id": {}},
+    {"idempotency_key": []},
+    {"user_id": "x" * 256},
+    {"idempotency_key": "x" * 161},
+    {"candidates": []},
+    {"candidates": [{"action_key": "a"}] * 2},
+    {"candidates": [{"action_key": " a"}]},
+    {"candidates": [{"action_key": True}]},
+    {"candidates": [{"action_key": "a", "unexpected": "field"}]},
+    {"candidates": [{"action_key": "a", "features": []}]},
+    {"candidates": [{"action_key": "a", "description": 12}]},
+    {"candidates": [{"action_key": str(i)} for i in range(51)]},
+    {"context": []},
+    {"context": {1: "not a JSON object key"}},
+    {"context": {"x": float("nan")}},
+    {"context": {"x": object()}},
+    {"context": {"x": (1, 2)}},
+    {"context": {"x": "x" * 17000}},
+]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize("bad", BAD_INPUTS, ids=range(len(BAD_INPUTS)))
+async def test_invalid_inputs_fail_before_read_or_advisor(kind, bad):
+    client, advisor = transport(kind), Mock(return_value=choice())
+    with pytest.raises(ValueError):
+        await invoke(kind, client, {**inputs(), **bad}, advisor)
+    client.get.assert_not_called()
+    advisor.assert_not_called()
+    client.post.assert_not_called()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize(
+    "probabilities",
+    [{"a": 0.3, "b": 0.7}, {"a": 0.0, "b": 1.0}, {"a": 0.3, "b": 0.700000005}],
+)
+async def test_valid_distribution_is_preserved_not_renormalized(kind, probabilities):
+    client = transport(kind)
+    selected = dict(
+        chosen_action_key="b",
+        action_probability=probabilities["b"],
+        behavior_probabilities=probabilities,
+    )
+    await invoke(kind, client, inputs(), Mock(return_value=selected))
+    assert (
+        client.post.call_args.kwargs["json"]["behavior_probabilities"] == probabilities
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+async def test_single_action_requires_explicit_complete_distribution(kind):
+    client = transport(kind)
+    params = {**inputs(), "candidates": [{"action_key": "a"}]}
+    await invoke(
+        kind,
+        client,
+        params,
+        Mock(
+            return_value=dict(
+                chosen_action_key="a",
+                action_probability=1,
+                behavior_probabilities={"a": 1},
+            )
+        ),
+    )
+    assert client.post.call_count == 1
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+@pytest.mark.parametrize("stage", ["read", "advisor", "write"])
+async def test_failures_propagate_without_retry(kind, stage):
+    client, advisor = transport(kind), Mock(return_value=choice())
+    target = {"read": client.get, "advisor": advisor, "write": client.post}[stage]
+    target.side_effect = RuntimeError("bounded failure")
+    with pytest.raises(RuntimeError, match="bounded failure"):
+        await invoke(kind, client, inputs(), advisor)
+    assert client.get.call_count == 1
+    assert advisor.call_count == (0 if stage == "read" else 1)
+    assert client.post.call_count == (1 if stage == "write" else 0)
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("kind", ["sync", "async"])
+async def test_cyclic_json_is_refused_before_read(kind):
+    client, advisor, params = transport(kind), Mock(return_value=choice()), inputs()
+    params["context"]["self"] = params["context"]
+    with pytest.raises(ValueError):
+        await invoke(kind, client, params, advisor)
+    client.get.assert_not_called()

{hebbrix-2.6.0rc4 → hebbrix-2.6.1}/tests/test_outcome_advice_resource.py

@@ -13,6 +13,7 @@ from hebbrix.sync_client import SyncProofLoopResource
     ("configure_policy", ("a/b",), {"configuration": {"actions": {}}}, "request", "/v1/learning/policies/a%2Fb/configuration"),
     ("policy_configuration", ("a/b",), {}, "get", "/v1/learning/policies/a%2Fb/configuration"),
     ("policy_advice", ("a/b",), {"context": {"x": "a b"}}, "get", "/v1/learning/policies/a%2Fb/advice"),
+    ("policy_advice", ("a/b",), {"context": {}, "remaining_decisions": 100, "max_pilot_decisions": 2}, "get", "/v1/learning/policies/a%2Fb/advice"),
     ("action_advice", ("Restart sandbox",), {"policy_key": "p", "action_key": "a", "user_id": "scoped"}, "get", "/v1/confidence"),
 ])
 async def test_sync_async_policy_wire_parity(method, args, kwargs, verb, path):
@@ -29,6 +30,25 @@ async def test_sync_async_policy_wire_parity(method, args, kwargs, verb, path):
         assert call.args[0] == "PUT" and call.kwargs["json"]["expected_revision"] == 0
     if method == "policy_advice":
         assert json.loads(call.kwargs["params"]["context"]) == kwargs["context"]
+        for key in ("remaining_decisions", "max_pilot_decisions"):
+            if key in kwargs:
+                assert call.kwargs["params"][key] == kwargs[key]
     if method == "action_advice":
         assert call.kwargs["params"]["end_user_id"] == "scoped"
         assert "user_id" not in call.kwargs["params"]
+
+
+@pytest.mark.asyncio
+async def test_value_and_feature_setup_sync_async_parity():
+    sync, asynchronous = Mock(), Mock()
+    sync.post.return_value = {"execution_permitted": False}
+    asynchronous.post = AsyncMock(return_value={"execution_permitted": False})
+    values = dict(context_schema={"version": "v1", "fields": {}},
+        actions={"a": {"risk_tier": "high"}},
+        configuration={"schema_version": "outcome-policy-v3", "contextual_model": "linear_optional"},
+        value_objective={"success_value": 10, "max_cost": 20, "cost_unit": "USD"})
+    assert SyncProofLoopResource(sync).setup_policy("p", **values) == await ProofLoopResource(asynchronous).setup_policy("p", **values)
+    assert sync.post.call_args == asynchronous.post.call_args
+    body = sync.post.call_args.kwargs["json"]
+    assert body["configuration"]["actions"] == values["actions"]
+    assert body["value_objective"] == values["value_objective"]

hebbrix-2.6.1/tests/test_release_version.py

@@ -0,0 +1,22 @@
+"""Prevent package identity from drifting from either HTTP transport."""
+import inspect
+import re
+
+import hebbrix
+from hebbrix import client, sync_client
+
+
+def test_both_transport_versions_match_package():
+    for module in (client, sync_client):
+        versions = re.findall(r'hebbrix-python/([^\s\"\x27]+)', inspect.getsource(module))
+        assert versions == [hebbrix.__version__]
+
+
+def test_runtime_httpx_is_bounded_below_breaking_major():
+    from pathlib import Path
+    from packaging.requirements import Requirement
+    text = (Path(__file__).resolve().parents[1] / "pyproject.toml").read_text()
+    requirement = Requirement(re.search(r'"(httpx[^"\n]+)"', text).group(1))
+    assert requirement.specifier.contains("0.28.1")
+    assert not requirement.specifier.contains("1.0.dev6", prereleases=True)
+    assert not requirement.specifier.contains("1.0.0")

hebbrix-2.6.0rc4/tests/test_release_version.py

@@ -1,12 +0,0 @@
-"""Prevent package identity from drifting from either HTTP transport."""
-import inspect
-import re
-
-import hebbrix
-from hebbrix import client, sync_client
-
-
-def test_both_transport_versions_match_package():
-    for module in (client, sync_client):
-        versions = re.findall(r'hebbrix-python/([^\s\"\x27]+)', inspect.getsource(module))
-        assert versions == [hebbrix.__version__]