b3-prosaic-runtime 0.9.2__tar.gz → 0.9.4__tar.gz

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.9.3 — 2026-10-14
+
+- Normalize negative provider timeout exit statuses to 124 in conversation turn
+  results so Harness can persist failed timeout receipts without `store_corrupt`.
+- Preserve existing run/CLI timeout statuses and the conversation storage format.
+- Cover streaming and nonstreaming provider timeouts through the public turn API.
+
 ## 0.9.2 — 2026-10-13
 
 - Add a host-owned ExecutionBudget that shares deadlines, provider/tool dispatch

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3-prosaic-runtime
-Version: 0.9.2
+Version: 0.9.4
 Summary: Bounded execution of neutral Prosaic agents on OpenAI-compatible and native Anthropic endpoints
 Author: B3 Cognition
 License-Expression: Apache-2.0

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/docs/conversations.md

@@ -1,5 +1,47 @@
 # Stateless conversation turns (0.9.0 candidate)
 
+## Optional token-aware context admission
+
+`context_assembly_v1` adds optional `ContextPolicy` and host-supplied
+`TokenCounterRegistry` arguments to preparation and execution. Existing calls
+keep their version-1 encoding and identity. Opted-in preparation uses
+`conversation-turn-v2` and exposes an owned `context_report`, `context_selection`
+and `context_work`. Supply the same counter registry when executing a prepared
+turn. Durable hosts retain the frozen selection/report and remaining work state.
+
+Choose `fullHistory` to reject overflow, or explicitly choose `omitOldestTurns`
+to omit oldest complete turns only from this request. Source history stays
+unchanged. Instructions, current user/inputData, tool schemas and current-turn
+tool exchanges remain mandatory. Tool continuations that cannot fit terminate
+with bounded failure evidence; completed or uncertain effects are preserved and
+never automatically retried. Counters operate on copies of final native payloads.
+
+Counters must match the provider, model, pinned tokenizer/template digests and
+framing revision, and certify exact or conservative-upper-bound counts. Runtime
+ships no universal tokenizer or qualified production counter. Synthetic fixture
+counts demonstrate admission behavior only. Provider-reported usage is execution
+accounting evidence; Lago receives billing events separately.
+
+Policies also bound candidate checks, cumulative encoded candidate bytes and
+active assembly time. Provider waiting is excluded. Time checks are cooperative:
+trusted counters must be bounded local code without network I/O or inference.
+`context_checkpoint` durably records resource reservations before callbacks;
+`on_admitted` lets the host mark dispatch only after successful readmission and
+all static checks, before accounting intent and provider effects.
+
+```python
+from prosaic_runtime import ContextPolicy
+
+# token_counters is a host-qualified immutable TokenCounterRegistry.
+context_policy = ContextPolicy(
+    mode='omitOldestTurns', context_window_tokens=32768,
+    reserved_output_tokens=2048, safety_margin_tokens=256,
+    counter_identity='host-pinned-counter-v1')
+prepared = runtime.prepare_turn(agent, message='Next question', history=history,
+    policy=policy, context_policy=context_policy, token_counters=token_counters)
+result = runtime.turn(prepared, token_counters=token_counters)
+```
+
 `conversation_turn_v1` adds `prepare_turn()` and `turn()` to `ProsaicRuntime`.
 Runtime owns one bounded model/tool execution. Your host supplies inspected,
 approved prose, admitted user input and the complete portable history. Durable

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "b3-prosaic-runtime"
-version = "0.9.2"
+version = "0.9.4"
 description = "Bounded execution of neutral Prosaic agents on OpenAI-compatible and native Anthropic endpoints"
 requires-python = ">=3.11"
 readme = "README.md"

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/scripts/conversation_wheel_smoke.py

@@ -22,7 +22,7 @@ def ownership():
     import prosaic_runtime as api
     import prosaic_runtime_postgres as recorder
     for module, distribution, version in ((prosaic, 'b3-prosaic', '0.4.1'),
-            (api, 'b3-prosaic-runtime', '0.9.2'),
+            (api, 'b3-prosaic-runtime', '0.9.4'),
             (recorder, 'b3-prosaic-runtime-postgres', '0.3.0')):
         owner = metadata.distribution(distribution)
         assert module.__version__ == owner.version == version
@@ -39,6 +39,7 @@ def ownership():
             continue
         raise AssertionError('legacy distribution overlaps public imports')
     assert 'conversation_turn_v1' in api.ProsaicRuntime.capabilities
+    assert 'context_assembly_v1' in api.ProsaicRuntime.capabilities
     return api
 
 
@@ -56,7 +57,7 @@ def worker():
             self.connection.settimeout(2)
         def do_POST(self):
             length = int(self.headers['Content-Length'])
-            assert 0 < length <= 196608 and len(requests) < 2
+            assert 0 < length <= 196608 and len(requests) < 3
             requests.append(json.loads(self.rfile.read(length)))
             text = ('Prague' if len(requests) == 1 else 'Prague again')
             body = json.dumps({'choices': [{'message': {'role': 'assistant', 'content': text},
@@ -93,9 +94,23 @@ def worker():
         history = requests[1]['messages']
         assert [m['role'] for m in history] == ['system', 'user', 'assistant', 'user']
         assert history[2]['content'] == 'Prague'
+        class FixtureCounter:
+            def count_tokens(self, request):
+                return 250 if 'Which city?' in json.dumps(request) else 10
+        descriptor = api.TokenCounterDescriptor('synthetic-v1', 'openai-compatible',
+            'synthetic', 'openai-chat-v1', 200, '1', '0'*64, '1'*64,
+            'exact', 'Exact units for this synthetic test grammar only.')
+        counters = api.TokenCounterRegistry({'synthetic-v1':
+            api.TokenCounterRegistration(descriptor, FixtureCounter())})
+        context_policy = api.ContextPolicy('omitOldestTurns', 200, 20, 0, 'synthetic-v1')
+        fitted = runtime.turn(agent, message='Now?', history=first.completed_turn.messages,
+            policy=policy, context_policy=context_policy, token_counters=counters)
+        assert fitted.result.exit_code == 0 and len(requests) == 3
+        assert fitted.context_report.omitted_turn_count == 1
+        assert 'Which city?' not in json.dumps(requests[2])
         ownership()
         print(json.dumps({'version': 1, 'runtimeVersion': api.__version__,
-            'checks': ['installedOwnership', 'purePreparation', 'twoTurnHistory', 'noWorkspace'],
+            'checks': ['installedOwnership', 'purePreparation', 'twoTurnHistory', 'noWorkspace', 'syntheticContextAssembly'],
             'providerRequests': len(requests), 'liveProvider': False}))
     finally:
         server.shutdown()

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/scripts/production_wheel_smoke.py

@@ -49,7 +49,7 @@ def installed_origins():
     owners = {}
     origins = {}
     for package, name, version in ((prosaic, "b3-prosaic", "0.4.1"),
-            (runtime, "b3-prosaic-runtime", "0.9.2"),
+            (runtime, "b3-prosaic-runtime", "0.9.4"),
             (postgres, "b3-prosaic-runtime-postgres", "0.3.0")):
         owner = metadata.distribution(name)
         assert owner.version == package.__version__ == version

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/src/b3_prosaic_runtime.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3-prosaic-runtime
-Version: 0.9.2
+Version: 0.9.4
 Summary: Bounded execution of neutral Prosaic agents on OpenAI-compatible and native Anthropic endpoints
 Author: B3 Cognition
 License-Expression: Apache-2.0

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/src/b3_prosaic_runtime.egg-info/SOURCES.txt

@@ -82,6 +82,11 @@ src/prosaic_runtime/cli_tools.py
 src/prosaic_runtime/config.py
 src/prosaic_runtime/conformance.py
 src/prosaic_runtime/console.py
+src/prosaic_runtime/context_assembly.py
+src/prosaic_runtime/context_contracts.py
+src/prosaic_runtime/context_counters.py
+src/prosaic_runtime/context_execution.py
+src/prosaic_runtime/context_work.py
 src/prosaic_runtime/conversation.py
 src/prosaic_runtime/conversation_preparation.py
 src/prosaic_runtime/diagnostics.py
@@ -123,6 +128,9 @@ tests/test_cli_tools.py
 tests/test_cli_tools_boundaries.py
 tests/test_config.py
 tests/test_conformance.py
+tests/test_context_assembly.py
+tests/test_context_contracts.py
+tests/test_context_execution.py
 tests/test_conversation_bounds.py
 tests/test_conversation_contracts.py
 tests/test_conversation_distribution.py
@@ -157,5 +165,6 @@ tests/test_tool_effect_workers.py
 tests/test_tool_effects.py
 tests/test_transport.py
 tests/test_usage_integrity.py
+tests/support/context_counter.py
 tests/support/conversation_server.py
 tests/support/tool_journal.py

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/src/prosaic_runtime/__init__.py

@@ -1,5 +1,5 @@
 """Execute neutral Prosaic artifacts with explicitly granted authority."""
-__version__ = '0.9.2'
+__version__ = '0.9.4'
 
 from .artifacts import ProsaicArtifact
 from .config import EndpointConfig, RuntimeConfig, RunLimits, CliSandboxConfig
@@ -36,3 +36,11 @@ __all__ += ["RuntimeAdapter"]
 
 from .execution_budget import ExecutionBudget
 __all__ += ["ExecutionBudget"]
+
+from .context_contracts import (ContextPolicy, TokenCounterDescriptor,
+    ContextAssemblyReport, ContextSelection, ContextWorkState)
+from .context_counters import (TokenCounter, TokenCounterRegistration,
+    TokenCounterRegistry)
+__all__ += ["ContextPolicy", "TokenCounterDescriptor", "ContextAssemblyReport",
+    "ContextSelection", "ContextWorkState", "TokenCounter", "TokenCounterRegistration",
+    "TokenCounterRegistry"]

{b3_prosaic_runtime-0.9.2 → b3_prosaic_runtime-0.9.4}/src/prosaic_runtime/anthropic.py

@@ -177,8 +177,11 @@ class AnthropicBackend(ExecutionBackend):
         payload.pop('stream_options', None)
         return payload
 
+    def native_payload(self, payload):
+        return encode_messages(payload)
+
     def _post_chat_turn(self, payload, request, deadline, streaming):
-        native = encode_messages(payload)
+        native = self.native_payload(payload)
         self.validate_payload(native)
         data = self.encode_payload(native)
         token, error = _api_key(self._config.api_key_env, self._config.api_key_file, request.env)

b3_prosaic_runtime-0.9.4/src/prosaic_runtime/context_assembly.py

@@ -0,0 +1,92 @@
+"""Full-history-first suffix fitting over validated owned neutral turns."""
+import hashlib
+import json
+from .conversation import TurnAdmissionError, encode_owned
+from .context_contracts import ContextAssemblyReport, ContextSelection, ContextWorkState
+from .context_counters import count_owned
+from .context_work import ContextWorkBudget
+
+
+def context_digest(value):
+    return hashlib.sha256(encode_owned(value)).hexdigest()
+
+
+def _boundaries(history):
+    return [index for index, message in enumerate(history) if message['role'] == 'user']
+
+
+def assemble_context(source_history, build_candidate, policy, registration, limits, *, work=None):
+    budget = ContextWorkBudget(policy, work=work)
+    boundaries = _boundaries(source_history)
+    total, omitted = len(boundaries), 0
+    while True:
+        start = boundaries[omitted] if omitted < total else len(source_history)
+        selected = source_history[start:]
+        def construct():
+            candidate = build_candidate(selected)
+            size = len(json.dumps(candidate, allow_nan=False).encode('utf-8'))
+            return candidate, size
+        native, size = budget.construct(construct)
+        callback = (lambda: count_owned(registration, native)) if size <= limits.max_input_bytes else None
+        count = budget.check_candidate(size, callback)
+        if count is not None and count <= policy.input_capacity_tokens:
+            budget.reserve_readmission(size)
+            report = ContextAssemblyReport.from_dict({'version': 1, 'mode': policy.mode,
+                'counterIdentity': policy.counter_identity,
+                'sourceHistoryDigest': context_digest(source_history),
+                'selectedHistoryDigest': context_digest(selected),
+                'inputTokens': count, 'countingKind': registration.descriptor.counting_kind,
+                'reservedOutputTokens': policy.reserved_output_tokens,
+                'safetyMarginTokens': policy.safety_margin_tokens,
+                'inputCapacityTokens': policy.input_capacity_tokens,
+                'encodedInputBytes': size, 'retainedTurnCount': total - omitted,
+                'omittedTurnCount': omitted,
+                'retainedRange': {'startTurn': omitted + 1, 'endTurnExclusive': total + 1} if omitted < total else None,
+                'omittedRange': {'startTurn': 1, 'endTurnExclusive': omitted + 1} if omitted else None,
+                'candidateChecks': budget.state.candidate_checks,
+                'candidateBytes': budget.state.candidate_bytes})
+            selection = ContextSelection.from_dict({'version': 1,
+                'contextPolicyIdentity': context_digest(policy.to_dict()),
+                'counterDescriptorIdentity': context_digest(registration.descriptor.to_dict()),
+                'sourceHistoryDigest': report.source_history_digest,
+                'selectedHistoryDigest': report.selected_history_digest,
+                'retainedRange': report.retained_range, 'omittedRange': report.omitted_range,
+                'initialReportIdentity': context_digest(report.to_dict())})
+            return selected, report, selection, budget.state
+        if policy.mode == 'fullHistory' or omitted == total:
+            raise TurnAdmissionError('contextLimit',
+                'maxInputBytes' if count is None else 'contextWindowTokens')
+        omitted += 1
+
+
+def restore_selection(source_history, policy, registration, selection, report, work):
+    try:
+        if (type(selection) is not ContextSelection or type(report) is not ContextAssemblyReport
+                or type(work) is not ContextWorkState):
+            raise ValueError('context records')
+        boundaries = _boundaries(source_history)
+        omitted = report.omitted_turn_count
+        if omitted > len(boundaries):
+            raise ValueError('omission range')
+        start = boundaries[omitted] if omitted < len(boundaries) else len(source_history)
+        selected = source_history[start:]
+        expected = {'version': 1, 'contextPolicyIdentity': context_digest(policy.to_dict()),
+            'counterDescriptorIdentity': context_digest(registration.descriptor.to_dict()),
+            'sourceHistoryDigest': context_digest(source_history),
+            'selectedHistoryDigest': context_digest(selected),
+            'retainedRange': report.retained_range, 'omittedRange': report.omitted_range,
+            'initialReportIdentity': context_digest(report.to_dict())}
+        if (selection.to_dict() != expected or report.source_history_digest != expected['sourceHistoryDigest']
+                or report.selected_history_digest != expected['selectedHistoryDigest']
+                or report.retained_turn_count != len(boundaries) - omitted
+                or report.mode != policy.mode or report.counter_identity != policy.counter_identity
+                or report.input_capacity_tokens != policy.input_capacity_tokens
+                or report.reserved_output_tokens != policy.reserved_output_tokens
+                or report.safety_margin_tokens != policy.safety_margin_tokens
+                or report.counting_kind != registration.descriptor.counting_kind
+                or work.candidate_checks < report.candidate_checks
+                or work.candidate_bytes < report.candidate_bytes):
+            raise ValueError('selection binding')
+        return selected, report, selection, work
+    except (ValueError, TypeError, AttributeError):
+        raise TurnAdmissionError('bindingMismatch') from None

b3_prosaic_runtime-0.9.4/src/prosaic_runtime/context_contracts.py

@@ -0,0 +1,230 @@
+"""Optional owned context-admission contracts; no executable serialization."""
+from dataclasses import dataclass, fields
+import json
+import re
+
+from .conversation import TurnAdmissionError, encode_owned, _OwnedRecord
+from .operation_context import bounded_reference
+
+
+MAX_INTEGER = 2**63 - 1
+FRAMING_REVISIONS = {'openai-compatible': 'openai-chat-v1',
+                     'anthropic': 'anthropic-messages-v1'}
+
+
+def _camel(name):
+    head, *tail = name.split('_')
+    return head + ''.join(piece.title() for piece in tail)
+
+
+def _integer(value, minimum=0, maximum=MAX_INTEGER):
+    if type(value) is not int or not minimum <= value <= maximum:
+        raise ValueError('integer bound')
+
+
+def _digest(value):
+    if type(value) is not str or not re.fullmatch('[0-9a-f]{64}', value):
+        raise ValueError('digest')
+
+
+def _reference(value):
+    if not bounded_reference(value):
+        raise ValueError('reference')
+
+
+def _closed(document, keys):
+    if type(document) is not dict or document.keys() != set(keys):
+        raise ValueError('closed fields')
+
+
+def _owned(document, *, maximum=16_384, nodes=512):
+    return json.loads(encode_owned(document, max_bytes=maximum,
+                                   max_depth=16, max_nodes=nodes))
+
+
+def _range(value):
+    if value is None:
+        return 0
+    _closed(value, ('startTurn', 'endTurnExclusive'))
+    _integer(value['startTurn'], 1)
+    _integer(value['endTurnExclusive'], value['startTurn'] + 1)
+    return value['endTurnExclusive'] - value['startTurn']
+
+
+class _DocumentMixin:
+    def to_dict(self):
+        try:
+            document = {_camel(f.name): getattr(self, f.name) for f in fields(self)}
+            return _owned(document)
+        except (ValueError, TypeError, UnicodeError, RecursionError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+    @classmethod
+    def from_dict(cls, document):
+        try:
+            document = _owned(document)
+            names = {_camel(f.name): f.name for f in fields(cls)}
+            _closed(document, names)
+            return cls(**{names[key]: value for key, value in document.items()})
+        except (ValueError, TypeError, UnicodeError, RecursionError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+
+@dataclass(frozen=True)
+class ContextPolicy(_DocumentMixin):
+    mode: str
+    context_window_tokens: int
+    reserved_output_tokens: int
+    safety_margin_tokens: int
+    counter_identity: str
+    max_candidate_checks: int = 128
+    max_assembly_bytes: int = 33_554_432
+    assembly_timeout_ms: int = 2_000
+
+    def __post_init__(self):
+        try:
+            if type(self.mode) is not str or self.mode not in {'fullHistory', 'omitOldestTurns'}:
+                raise ValueError('mode')
+            _integer(self.context_window_tokens, 1)
+            _integer(self.reserved_output_tokens, 1)
+            _integer(self.safety_margin_tokens)
+            _integer(self.max_candidate_checks, 2, 256)
+            _integer(self.max_assembly_bytes, 1, 268_435_456)
+            _integer(self.assembly_timeout_ms, 1, 30_000)
+            _reference(self.counter_identity)
+            if self.reserved_output_tokens + self.safety_margin_tokens >= self.context_window_tokens:
+                raise ValueError('input capacity')
+            self.to_dict()
+        except (ValueError, TypeError, UnicodeError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+    @property
+    def input_capacity_tokens(self):
+        return self.context_window_tokens - self.reserved_output_tokens - self.safety_margin_tokens
+
+
+@dataclass(frozen=True)
+class TokenCounterDescriptor(_DocumentMixin):
+    identity: str
+    provider: str
+    model: str
+    framing_revision: str
+    context_capacity_tokens: int
+    implementation_version: str
+    tokenizer_assets_digest: str
+    template_assets_digest: str
+    counting_kind: str
+    guarantee: str
+
+    def __post_init__(self):
+        try:
+            for name in ('identity', 'model', 'implementation_version'):
+                _reference(getattr(self, name))
+            if (type(self.provider) is not str or self.provider not in FRAMING_REVISIONS
+                    or self.framing_revision != FRAMING_REVISIONS[self.provider]):
+                raise ValueError('unsupported framing')
+            _integer(self.context_capacity_tokens, 1)
+            _digest(self.tokenizer_assets_digest)
+            _digest(self.template_assets_digest)
+            if self.counting_kind not in {'exact', 'conservativeUpperBound'}:
+                raise ValueError('counting guarantee')
+            if (type(self.guarantee) is not str or not self.guarantee.strip()
+                    or len(self.guarantee.encode('utf-8')) > 8192):
+                raise ValueError('guarantee bound')
+            self.to_dict()
+        except (ValueError, TypeError, UnicodeError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+
+class _ContextRecord(_OwnedRecord):
+    maximum = 16_384
+    nodes = 512
+    keys = frozenset()
+
+    def __setattr__(self, name, value):
+        raise AttributeError('immutable context record')
+
+    def __delattr__(self, name):
+        raise AttributeError('immutable context record')
+
+    @classmethod
+    def from_dict(cls, document):
+        try:
+            document = _owned(document, maximum=cls.maximum, nodes=cls.nodes)
+            _closed(document, cls.keys)
+            cls.validate(document)
+            return cls._create(encode_owned(document, max_bytes=cls.maximum,
+                max_depth=16, max_nodes=cls.nodes))
+        except (ValueError, TypeError, KeyError, UnicodeError, RecursionError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+    def __getattr__(self, name):
+        key = _camel(name)
+        if key not in self.keys:
+            raise AttributeError(name)
+        return self.to_dict()[key]
+
+
+class ContextAssemblyReport(_ContextRecord):
+    keys = frozenset({'version', 'mode', 'counterIdentity', 'sourceHistoryDigest',
+        'selectedHistoryDigest', 'inputTokens', 'countingKind', 'reservedOutputTokens',
+        'safetyMarginTokens', 'inputCapacityTokens', 'encodedInputBytes',
+        'retainedTurnCount', 'omittedTurnCount', 'retainedRange', 'omittedRange',
+        'candidateChecks', 'candidateBytes'})
+
+    @staticmethod
+    def validate(d):
+        _integer(d['version'], 1, 1)
+        if d['mode'] not in {'fullHistory', 'omitOldestTurns'} or d['countingKind'] not in {'exact', 'conservativeUpperBound'}:
+            raise ValueError('report enum')
+        _reference(d['counterIdentity'])
+        _digest(d['sourceHistoryDigest'])
+        _digest(d['selectedHistoryDigest'])
+        for name in ('inputTokens', 'safetyMarginTokens', 'retainedTurnCount',
+                     'omittedTurnCount', 'candidateBytes'):
+            _integer(d[name])
+        for name in ('reservedOutputTokens', 'inputCapacityTokens', 'encodedInputBytes', 'candidateChecks'):
+            _integer(d[name], 1)
+        if (d['inputTokens'] > d['inputCapacityTokens'] or
+                _range(d['retainedRange']) != d['retainedTurnCount'] or
+                _range(d['omittedRange']) != d['omittedTurnCount']):
+            raise ValueError('report capacity/range')
+        omitted = d['omittedTurnCount']
+        if ((d['omittedRange'] is not None and d['omittedRange']['startTurn'] != 1) or
+                (d['retainedRange'] is not None and d['retainedRange']['startTurn'] != omitted + 1) or
+                (d['mode'] == 'fullHistory' and omitted)):
+            raise ValueError('report partition')
+
+
+class ContextSelection(_ContextRecord):
+    maximum, nodes = 8192, 256
+    keys = frozenset({'version', 'contextPolicyIdentity', 'counterDescriptorIdentity',
+        'sourceHistoryDigest', 'selectedHistoryDigest', 'retainedRange',
+        'omittedRange', 'initialReportIdentity'})
+
+    @staticmethod
+    def validate(d):
+        _integer(d['version'], 1, 1)
+        for name in ('contextPolicyIdentity', 'counterDescriptorIdentity',
+                     'sourceHistoryDigest', 'selectedHistoryDigest', 'initialReportIdentity'):
+            _digest(d[name])
+        omitted = _range(d['omittedRange'])
+        _range(d['retainedRange'])
+        if ((d['omittedRange'] is not None and d['omittedRange']['startTurn'] != 1) or
+                (d['retainedRange'] is not None and d['retainedRange']['startTurn'] != omitted + 1)):
+            raise ValueError('selection partition')
+
+
+class ContextWorkState(_ContextRecord):
+    maximum, nodes = 4096, 128
+    keys = frozenset({'version', 'candidateChecks', 'candidateBytes',
+        'activeAssemblyMicros', 'reservedActiveMicros', 'readmissionCandidateBytes',
+        'readmissionPending', 'checkpointSequence'})
+
+    @staticmethod
+    def validate(d):
+        _integer(d['version'], 1, 1)
+        for name in ContextWorkState.keys - {'version', 'readmissionPending'}:
+            _integer(d[name])
+        if type(d['readmissionPending']) is not bool:
+            raise ValueError('readmission flag')

b3_prosaic_runtime-0.9.4/src/prosaic_runtime/context_counters.py

@@ -0,0 +1,74 @@
+"""Trusted local counting implementations with immutable admitted descriptors."""
+from collections.abc import Mapping
+from dataclasses import dataclass
+import json
+from types import MappingProxyType
+from typing import Protocol
+
+from .conversation import TurnAdmissionError, encode_owned
+from .context_contracts import ContextPolicy, TokenCounterDescriptor, MAX_INTEGER
+
+
+class TokenCounter(Protocol):
+    def count_tokens(self, request: dict[str, object]) -> int: ...
+
+
+@dataclass(frozen=True)
+class TokenCounterRegistration:
+    descriptor: TokenCounterDescriptor
+    counter: TokenCounter
+
+    def __post_init__(self):
+        if type(self.descriptor) is not TokenCounterDescriptor or not callable(getattr(self.counter, 'count_tokens', None)):
+            raise TurnAdmissionError('invalidPolicy')
+        object.__setattr__(self, 'descriptor', TokenCounterDescriptor.from_dict(self.descriptor.to_dict()))
+
+
+class TokenCounterRegistry:
+    __slots__ = ('_registrations',)
+
+    def __init__(self, registrations):
+        try:
+            if not isinstance(registrations, Mapping) or len(registrations) > 256:
+                raise ValueError('registry bounds')
+            owned = {}
+            for identity, entry in registrations.items():
+                if (type(entry) is not TokenCounterRegistration or type(identity) is not str
+                        or identity != entry.descriptor.identity):
+                    raise ValueError('registration identity')
+                owned[identity] = TokenCounterRegistration(entry.descriptor, entry.counter)
+            object.__setattr__(self, '_registrations', MappingProxyType(owned))
+        except (ValueError, TypeError, AttributeError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+    def __setattr__(self, name, value):
+        raise AttributeError('immutable registry')
+
+    def resolve(self, identity):
+        try:
+            return self._registrations[identity]
+        except (KeyError, TypeError):
+            raise TurnAdmissionError('invalidPolicy') from None
+
+
+def admit_counter(policy, registry, endpoint):
+    if type(policy) is not ContextPolicy or type(registry) is not TokenCounterRegistry:
+        raise TurnAdmissionError('invalidPolicy')
+    registration = registry.resolve(policy.counter_identity)
+    descriptor = registration.descriptor
+    if (descriptor.provider, descriptor.model) != (endpoint.provider, endpoint.model):
+        raise TurnAdmissionError('unsupportedCapability')
+    if policy.context_window_tokens > descriptor.context_capacity_tokens:
+        raise TurnAdmissionError('invalidPolicy')
+    return registration
+
+
+def count_owned(registration, native_request):
+    try:
+        request = json.loads(encode_owned(native_request))
+        count = registration.counter.count_tokens(request)
+        if type(count) is not int or not 0 <= count <= MAX_INTEGER:
+            raise ValueError('count bound')
+        return count
+    except Exception:
+        raise TurnAdmissionError('invalidPolicy') from None