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

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

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.9.2 — 2026-10-13
+
+- Add a host-owned ExecutionBudget that shares deadlines, provider/tool dispatch
+  allowances and known/unknown reported-token evidence across nested calls/retries.
+- Preserve trusted parent accounting context in tool callbacks and expose bounded
+  child lineage and remaining-time helpers without placing attribution in prompts.
+- Qualify SDK and existing PostgreSQL recorder compatibility; publish only the SDK.
+
 ## 0.9.1 — 2026-10-13
 
 - Add versioned `RuntimeAdapter` for trusted host projections and normalization

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3-prosaic-runtime
-Version: 0.9.1
+Version: 0.9.2
 Summary: Bounded execution of neutral Prosaic agents on OpenAI-compatible and native Anthropic endpoints
 Author: B3 Cognition
 License-Expression: Apache-2.0
@@ -653,3 +653,45 @@ For endpoints where the host deliberately chooses JSON tool requests, use the
 shared [`StructuredToolLoop`](docs/structured-tools.md). It reuses registered
 `CustomTool` contracts and bounded execution, with application-owned final-result
 admission. Harness can drive each turn without embedding product rules in Runtime.
+
+### Shared budgets for nested host execution (Runtime 0.9.2)
+
+Use `ExecutionBudget` around a complete host operation to share one absolute
+monotonic deadline, provider/tool dispatch caps and an optional reported-token cap
+across `run()`, `turn()`, RuntimeAdapter retries and synchronous nested callbacks:
+
+```python
+from prosaic_runtime import ExecutionBudget
+
+budget = ExecutionBudget(timeout_s=30, max_provider_requests=50,
+                         max_tool_calls=1, max_reported_tokens=40960,
+                         cancelled=request_cancelled)
+with budget.activate():
+    reply = conversation.send(...)
+```
+
+Reactivation never replenishes counters or the deadline. Nested budget scopes
+must satisfy every enclosing allowance. Provider/tool attempts are reserved
+atomically; explicit worker threads must activate the same budget object because
+context variables are not automatically inherited by threads. This cooperative
+host contract does not sandbox or preempt trusted callbacks. Callback networking
+must narrow its own timeout to the supplied deadline and check cancellation.
+
+`ToolExecutionContext.accounting_context` holds the actual frozen resolved parent
+attribution when accounting is enabled. `child_context(invocation_id=..., run_id=...,
+step_id=...)` derives nested lineage without taking identities from model arguments.
+`remaining_timeout(maximum)` narrows a callback timeout to the original deadline.
+Attribution is private host context and must not be copied into prompts/results.
+
+Known reported tokens remain available through `budget.reported_tokens`; unknown
+usage remains unknown through `budget.usage_complete`. A configured token cap
+stops subsequent dispatch on unknown usage. A response can itself exceed a
+reported-token cap; its paid evidence is retained and the operation fails rather
+than pretending the provider call was prevented. This is not a currency cap.
+
+ALWAYS persist host operation identity and conservative remaining reservations
+before dispatch when crash recovery matters. NEVER treat this process-local
+budget as a durable ledger or reset uncertain allowances after a restart.
+PostgreSQL accounting remains the authoritative provider-call evidence. Saved
+host outcomes require a fenced ToolJournal or equivalent durable application
+repository; interrupted effects must not be repeated automatically.

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/README.md

@@ -631,3 +631,45 @@ For endpoints where the host deliberately chooses JSON tool requests, use the
 shared [`StructuredToolLoop`](docs/structured-tools.md). It reuses registered
 `CustomTool` contracts and bounded execution, with application-owned final-result
 admission. Harness can drive each turn without embedding product rules in Runtime.
+
+### Shared budgets for nested host execution (Runtime 0.9.2)
+
+Use `ExecutionBudget` around a complete host operation to share one absolute
+monotonic deadline, provider/tool dispatch caps and an optional reported-token cap
+across `run()`, `turn()`, RuntimeAdapter retries and synchronous nested callbacks:
+
+```python
+from prosaic_runtime import ExecutionBudget
+
+budget = ExecutionBudget(timeout_s=30, max_provider_requests=50,
+                         max_tool_calls=1, max_reported_tokens=40960,
+                         cancelled=request_cancelled)
+with budget.activate():
+    reply = conversation.send(...)
+```
+
+Reactivation never replenishes counters or the deadline. Nested budget scopes
+must satisfy every enclosing allowance. Provider/tool attempts are reserved
+atomically; explicit worker threads must activate the same budget object because
+context variables are not automatically inherited by threads. This cooperative
+host contract does not sandbox or preempt trusted callbacks. Callback networking
+must narrow its own timeout to the supplied deadline and check cancellation.
+
+`ToolExecutionContext.accounting_context` holds the actual frozen resolved parent
+attribution when accounting is enabled. `child_context(invocation_id=..., run_id=...,
+step_id=...)` derives nested lineage without taking identities from model arguments.
+`remaining_timeout(maximum)` narrows a callback timeout to the original deadline.
+Attribution is private host context and must not be copied into prompts/results.
+
+Known reported tokens remain available through `budget.reported_tokens`; unknown
+usage remains unknown through `budget.usage_complete`. A configured token cap
+stops subsequent dispatch on unknown usage. A response can itself exceed a
+reported-token cap; its paid evidence is retained and the operation fails rather
+than pretending the provider call was prevented. This is not a currency cap.
+
+ALWAYS persist host operation identity and conservative remaining reservations
+before dispatch when crash recovery matters. NEVER treat this process-local
+budget as a durable ledger or reset uncertain allowances after a restart.
+PostgreSQL accounting remains the authoritative provider-call evidence. Saved
+host outcomes require a fenced ToolJournal or equivalent durable application
+repository; interrupted effects must not be repeated automatically.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "b3-prosaic-runtime"
-version = "0.9.1"
+version = "0.9.2"
 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.1 → b3_prosaic_runtime-0.9.2}/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.1'),
+            (api, 'b3-prosaic-runtime', '0.9.2'),
             (recorder, 'b3-prosaic-runtime-postgres', '0.3.0')):
         owner = metadata.distribution(distribution)
         assert module.__version__ == owner.version == version

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/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.1"),
+            (runtime, "b3-prosaic-runtime", "0.9.2"),
             (postgres, "b3-prosaic-runtime-postgres", "0.3.0")):
         owner = metadata.distribution(name)
         assert owner.version == package.__version__ == version

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3-prosaic-runtime
-Version: 0.9.1
+Version: 0.9.2
 Summary: Bounded execution of neutral Prosaic agents on OpenAI-compatible and native Anthropic endpoints
 Author: B3 Cognition
 License-Expression: Apache-2.0
@@ -653,3 +653,45 @@ For endpoints where the host deliberately chooses JSON tool requests, use the
 shared [`StructuredToolLoop`](docs/structured-tools.md). It reuses registered
 `CustomTool` contracts and bounded execution, with application-owned final-result
 admission. Harness can drive each turn without embedding product rules in Runtime.
+
+### Shared budgets for nested host execution (Runtime 0.9.2)
+
+Use `ExecutionBudget` around a complete host operation to share one absolute
+monotonic deadline, provider/tool dispatch caps and an optional reported-token cap
+across `run()`, `turn()`, RuntimeAdapter retries and synchronous nested callbacks:
+
+```python
+from prosaic_runtime import ExecutionBudget
+
+budget = ExecutionBudget(timeout_s=30, max_provider_requests=50,
+                         max_tool_calls=1, max_reported_tokens=40960,
+                         cancelled=request_cancelled)
+with budget.activate():
+    reply = conversation.send(...)
+```
+
+Reactivation never replenishes counters or the deadline. Nested budget scopes
+must satisfy every enclosing allowance. Provider/tool attempts are reserved
+atomically; explicit worker threads must activate the same budget object because
+context variables are not automatically inherited by threads. This cooperative
+host contract does not sandbox or preempt trusted callbacks. Callback networking
+must narrow its own timeout to the supplied deadline and check cancellation.
+
+`ToolExecutionContext.accounting_context` holds the actual frozen resolved parent
+attribution when accounting is enabled. `child_context(invocation_id=..., run_id=...,
+step_id=...)` derives nested lineage without taking identities from model arguments.
+`remaining_timeout(maximum)` narrows a callback timeout to the original deadline.
+Attribution is private host context and must not be copied into prompts/results.
+
+Known reported tokens remain available through `budget.reported_tokens`; unknown
+usage remains unknown through `budget.usage_complete`. A configured token cap
+stops subsequent dispatch on unknown usage. A response can itself exceed a
+reported-token cap; its paid evidence is retained and the operation fails rather
+than pretending the provider call was prevented. This is not a currency cap.
+
+ALWAYS persist host operation identity and conservative remaining reservations
+before dispatch when crash recovery matters. NEVER treat this process-local
+budget as a durable ledger or reset uncertain allowances after a restart.
+PostgreSQL accounting remains the authoritative provider-call evidence. Saved
+host outcomes require a fenced ToolJournal or equivalent durable application
+repository; interrupted effects must not be repeated automatically.

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

@@ -87,6 +87,7 @@ src/prosaic_runtime/conversation_preparation.py
 src/prosaic_runtime/diagnostics.py
 src/prosaic_runtime/events.py
 src/prosaic_runtime/execution.py
+src/prosaic_runtime/execution_budget.py
 src/prosaic_runtime/http_bounds.py
 src/prosaic_runtime/openai_compatible.py
 src/prosaic_runtime/openai_compatible_compaction.py
@@ -133,6 +134,7 @@ tests/test_custom_tool_example.py
 tests/test_custom_tool_transport.py
 tests/test_custom_tools.py
 tests/test_distribution_metadata.py
+tests/test_execution_budget.py
 tests/test_features.py
 tests/test_http_boundaries.py
 tests/test_input_boundary.py

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

@@ -1,5 +1,5 @@
 """Execute neutral Prosaic artifacts with explicitly granted authority."""
-__version__ = '0.9.1'
+__version__ = '0.9.2'
 
 from .artifacts import ProsaicArtifact
 from .config import EndpointConfig, RuntimeConfig, RunLimits, CliSandboxConfig
@@ -33,3 +33,6 @@ __all__ += ["ConversationMessage", "CompletedTurn", "TurnEvidence", "TurnResult"
 
 from .adapter import RuntimeAdapter
 __all__ += ["RuntimeAdapter"]
+
+from .execution_budget import ExecutionBudget
+__all__ += ["ExecutionBudget"]

b3_prosaic_runtime-0.9.2/src/prosaic_runtime/execution_budget.py

@@ -0,0 +1,108 @@
+"""Host-owned, process-local allowance across nested synchronous Runtime calls."""
+from contextlib import contextmanager
+from contextvars import ContextVar
+import math
+from threading import RLock
+import time
+
+from .budgets import InvocationBudgetExceeded
+from .events import Cancelled
+from .tools import ToolDeadlineExceeded
+
+_active = ContextVar('prosaic_execution_budgets', default=())
+
+
+class ExecutionBudget:
+    """A fixed deadline and dispatch caps; activation never replenishes allowance.
+
+    This is admission, not a durable ledger or a sandbox for trusted callbacks.
+    Activate the same object explicitly in worker threads to share its counters.
+    """
+    def __init__(self, *, timeout_s, max_provider_requests, max_tool_calls, max_reported_tokens=None, cancelled=None):
+        if type(timeout_s) not in (int,float) or not math.isfinite(timeout_s) or timeout_s<=0:
+            raise ValueError('invalid execution timeout')
+        for cap in (max_provider_requests,max_tool_calls):
+            if type(cap) is not int or cap<0: raise ValueError('invalid execution allowance')
+        if max_reported_tokens is not None and (type(max_reported_tokens) is not int or max_reported_tokens<0):
+            raise ValueError('invalid reported token allowance')
+        if cancelled is not None and not callable(cancelled): raise ValueError('invalid cancellation callback')
+        self._deadline=time.monotonic()+timeout_s
+        self._provider_cap,self._tool_cap=max_provider_requests,max_tool_calls
+        self._provider_requests=self._tool_calls=self._reported_tokens=0
+        self._token_cap=max_reported_tokens
+        self._usage_complete=True
+        self._cancelled=cancelled
+        self._lock=RLock()
+
+    @property
+    def deadline(self): return self._deadline
+    @property
+    def provider_requests(self):
+        with self._lock: return self._provider_requests
+    @property
+    def tool_calls(self):
+        with self._lock: return self._tool_calls
+
+    @property
+    def reported_tokens(self):
+        with self._lock: return self._reported_tokens
+    @property
+    def usage_complete(self):
+        with self._lock: return self._usage_complete
+
+    def _check_tokens(self, *, dispatch=False):
+        if self._token_cap is not None:
+            if not self._usage_complete: raise InvocationBudgetExceeded('usage_unknown')
+            if self._reported_tokens>self._token_cap or (dispatch and self._reported_tokens>=self._token_cap):
+                raise InvocationBudgetExceeded('token_limit')
+
+    def check(self):
+        if self._cancelled is not None and self._cancelled(): raise Cancelled()
+        if time.monotonic()>=self._deadline: raise ToolDeadlineExceeded('execution deadline exceeded')
+
+    @contextmanager
+    def activate(self):
+        stack=_active.get()
+        token=_active.set(stack if self in stack else (*stack,self))
+        try: yield self
+        finally: _active.reset(token)
+
+
+def active_budgets(): return _active.get()
+
+
+def check_budgets(budgets):
+    for budget in budgets: budget.check()
+
+
+def reserve_dispatch(budgets, *, tool=False, reserve=True):
+    """All enclosing allowances are checked under ordered locks before any debit."""
+    check_budgets(budgets)
+    ordered=sorted(budgets,key=id)
+    for budget in ordered: budget._lock.acquire()
+    try:
+        for budget in budgets:
+            budget._check_tokens(dispatch=True)
+            count=budget._tool_calls if tool else budget._provider_requests
+            cap=budget._tool_cap if tool else budget._provider_cap
+            if count>=cap:
+                raise InvocationBudgetExceeded('tool_call_limit' if tool else 'provider_request_limit')
+        if reserve:
+            for budget in budgets:
+                if tool: budget._tool_calls+=1
+                else: budget._provider_requests+=1
+    finally:
+        for budget in reversed(ordered): budget._lock.release()
+
+
+def record_shared_usage(budgets, usage):
+    # Retain all enclosing paid evidence before reporting any violated cap.
+    ordered=sorted(budgets,key=id)
+    for budget in ordered: budget._lock.acquire()
+    try:
+        for budget in budgets:
+            if type(usage) is not int or usage<0: budget._usage_complete=False
+            else: budget._reported_tokens+=usage
+        for budget in budgets: budget._check_tokens()
+    finally:
+        for budget in reversed(ordered): budget._lock.release()

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/src/prosaic_runtime/operation_context.py

@@ -1,5 +1,5 @@
 """Opaque host correlation, independent of billing attribution."""
-from dataclasses import dataclass, fields
+from dataclasses import dataclass, fields, field
 from collections.abc import Callable
 import unicodedata
 
@@ -37,3 +37,25 @@ class ToolExecutionContext:
     deadline: float
     cancelled: Callable
     operation_key: str | None = None
+
+    accounting_context: object = field(default=None, repr=False)
+
+    def child_context(self, *, invocation_id, run_id=None, step_id=None):
+        """Derive nested attribution from the actual resolved parent, never tool arguments."""
+        from .accounting import ResolvedContext
+        if type(self.accounting_context) is not ResolvedContext:
+            raise ValueError('accounted parent context required')
+        return self.accounting_context.child(invocation_id=invocation_id,run_id=run_id,step_id=step_id)
+
+    def remaining_timeout(self, maximum):
+        """Narrow a child's timeout to this tool's original absolute deadline."""
+        import math
+        import time
+        from .events import Cancelled
+        from .tools import ToolDeadlineExceeded
+        if type(maximum) not in (int,float) or not math.isfinite(maximum) or maximum<=0:
+            raise ValueError('invalid timeout')
+        if self.cancelled(): raise Cancelled()
+        remaining=self.deadline-time.monotonic()
+        if remaining<=0: raise ToolDeadlineExceeded('tool deadline exceeded')
+        return min(maximum,remaining)

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/src/prosaic_runtime/runtime.py

@@ -29,6 +29,7 @@ from .tool_effects import admit_tool_effects, ToolEffectFailure
 from .telemetry import ObserverEmitter, observation_context, observe, execution_started
 from .budgets import InvocationBudget, InvocationBudgetExceeded
 from .turn_capture import TurnOutputExceeded
+from .execution_budget import active_budgets, check_budgets, reserve_dispatch, record_shared_usage
 
 
 class _NoRedirect(urllib.request.HTTPRedirectHandler):
@@ -55,7 +56,8 @@ class _BoundedMixin:
         self.usage_complete = True
         self.turns = 0
         self.custom_tools = custom_tools
-        self.deadline = deadline
+        self.execution_budgets = active_budgets()
+        self.deadline = min([deadline, *(b.deadline for b in self.execution_budgets)])
         self.capture = capture
         self.budget = budget
         self.scope, self.tool_journal = scope, tool_journal
@@ -66,11 +68,13 @@ class _BoundedMixin:
         self._latest_usage_complete = None
         self._previous_usage_details = {}
         self._provider_attempts = 0
+        self.accounting_context = None
         self.turn_mode = False
         self.turn_capture = None
         self.known_usage_details = {}
 
     def check_boundary(self):
+        check_budgets(self.execution_budgets)
         check_cancelled()
         from .conformance import _check_suite_deadline
         _check_suite_deadline()
@@ -81,14 +85,23 @@ class _BoundedMixin:
         builtin = DisabledBuiltinRegistry() if cwd is None else super().make_registry(cwd, features, metadata)
         return BoundedToolRegistry(builtin,
                                    self.custom_tools, metadata.get('allowed_tools', ()), self.check_boundary,
-                                   self.budget.before_tool if self.budget is not None else None,
+                                   self.before_tool_dispatch,
                                    self.tool_execution_options, index_all_calls=self.turn_mode)
 
+    def before_tool_dispatch(self):
+        if self.budget is not None:
+            self.budget._check_reported_allowance()
+            cap=self.budget.policy.max_tool_calls
+            if cap is not None and self.budget.tool_calls>=cap:
+                raise InvocationBudgetExceeded('tool_call_limit')
+        reserve_dispatch(self.execution_budgets,tool=True)
+        if self.budget is not None: self.budget.before_tool()
+
     def tool_execution_options(self):
         index = self.tool_call_index
         self.tool_call_index += 1
         options = dict(scope=self.scope, deadline=self.deadline, cancelled=self.cancelled,
-                       call_index=index, tool_journal=self.tool_journal)
+                       call_index=index, tool_journal=self.tool_journal, accounting_context=self.accounting_context)
         if self.turn_capture is not None:
             options['on_completion'] = lambda outcome, status='completed', **refs: self.turn_capture.record_tool_completion(
                 index, outcome, status, **refs)
@@ -98,7 +111,8 @@ class _BoundedMixin:
         details = super().usage_details(parsed)
         # Compatibility parsers omit invalid quantities. A strict cap must see
         # those fields before omission could turn them into trusted evidence.
-        if self.turn_mode or (self.budget is not None and self.budget.policy.max_reported_tokens is not None):
+        if (self.turn_mode or any(b._token_cap is not None for b in self.execution_budgets)
+                or (self.budget is not None and self.budget.policy.max_reported_tokens is not None)):
             usage = parsed.get('usage') if isinstance(parsed, dict) else None
             if usage is not None:
                 self._latest_usage_complete = _reported_usage(details) is not None
@@ -125,7 +139,8 @@ class _BoundedMixin:
                 return value
             except (ValueError, TypeError, UnicodeError, RecursionError):
                 raise InvalidToolRequest() from None
-        if self.budget is not None and self.budget.policy.max_reported_tokens is not None:
+        if (any(b._token_cap is not None for b in self.execution_budgets)
+                or (self.budget is not None and self.budget.policy.max_reported_tokens is not None)):
             try:
                 return strict_json(raw)
             except InvalidEvidence:
@@ -144,8 +159,12 @@ class _BoundedMixin:
         else:
             self.reported_token_usage = (self.reported_token_usage or 0) + usage
             self.known_usage_details = _merge_token_usage_details(self.known_usage_details, details or {})
+        local_error=None
         if self.budget is not None:
-            self.budget.record_usage(usage)
+            try: self.budget.record_usage(usage)
+            except InvocationBudgetExceeded as exc: local_error=exc
+        record_shared_usage(self.execution_budgets,usage)
+        if local_error is not None: raise local_error
 
     def tool_call_summary(self, tool_call):
         function = tool_call.get('function')
@@ -168,6 +187,8 @@ class _BoundedMixin:
     def before_http_dispatch(self, timeout):
         self.check_boundary()
         timeout = min(timeout, self.deadline - time.monotonic())
+        if self.budget is not None: self.budget._check_provider()
+        reserve_dispatch(self.execution_budgets)
         if self.budget is not None:
             self.budget.before_provider()
         self._provider_attempts += 1
@@ -178,6 +199,7 @@ class _BoundedMixin:
         self.check_boundary()
         if self.budget is not None:
             self.budget._check_provider()
+        reserve_dispatch(self.execution_budgets,reserve=False)
         self._turn_usage_unknown = False
         self._latest_usage_complete = None
         self._previous_usage_details = {}
@@ -274,7 +296,7 @@ class _BoundedMixin:
         native_failure = (isinstance(turn, Result) and self._config.provider == 'anthropic' and
             (attempted or _reported_usage(turn.metadata.get('token_usage_details')) is not None))
         strict_attempt_failure = (isinstance(turn, Result) and self.budget is not None and
-            (self.turn_mode or self.budget.policy.max_reported_tokens is not None) and
+            (self.turn_mode or self.execution_budgets or self.budget.policy.max_reported_tokens is not None) and
             attempted)
         if not isinstance(turn, Result) or native_failure or strict_attempt_failure:
             details = turn.metadata.get('token_usage_details') if isinstance(turn, Result) else turn.token_usage_details
@@ -627,6 +649,7 @@ class ProsaicRuntime:
                 backend = backend_type(endpoint, policy.max_input_bytes, custom,
                                        started + policy.timeout_s, capture, _budget,
                                        _operation_context, _tool_journal, cancelled)
+                backend.accounting_context = _context
                 request = Invocation(str(Path(cwd).resolve()) if cwd is not None else None,
                                      prompt, invocation_env, remaining, {"prompt_metadata": metadata})
                 if _turn_prepared is None:
@@ -643,9 +666,10 @@ class ProsaicRuntime:
                 # The OpenAI text-only path returns Result directly and bypasses
                 # _post_chat_turn. Account its terminal usage once, after Capture
                 # has persisted the response context, preserving the returned text.
-                if _budget.enabled and not backend.turns and (
+                if (_budget.enabled or backend.execution_budgets) and not backend.turns and (
                         result.exit_code == 0 or 'token_usage_details' in result.metadata or
-                        (policy.max_reported_tokens is not None and _budget.provider_requests)):
+                        (policy.max_reported_tokens is not None and _budget.provider_requests) or
+                        (backend.execution_budgets and backend._provider_attempts)):
                     try:
                         backend.record_turn_usage(result.metadata.get('token_usage_details'))
                     except InvocationBudgetExceeded as exc:

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/src/prosaic_runtime/tools.py

@@ -180,7 +180,7 @@ def bounded_result(value, maximum):
 
 def execute_custom_tool(tool, raw_arguments, *, check_boundary, scope=None,
                         deadline=None, cancelled=lambda: False, call_index=0, tool_journal=None,
-                        on_completion=None):
+                        on_completion=None, accounting_context=None):
     check_boundary()
     try:
         arguments = parse_arguments(raw_arguments, tool.parameters, tool.max_argument_bytes)
@@ -196,7 +196,7 @@ def execute_custom_tool(tool, raw_arguments, *, check_boundary, scope=None,
         except (TypeError, ValueError, RecursionError, OverflowError):
             return {'status': 'error', 'error': 'invalid_arguments'}
         context = ToolExecutionContext(scope, tool.name, tool.version, call_index,
-            digest, deadline, cancelled)
+            digest, deadline, cancelled, accounting_context=accounting_context)
 
     def invoke(callback, ctx=context):
         owned = deepcopy(arguments)

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/tests/test_conformance.py

@@ -44,7 +44,7 @@ def test_canonical_order_owned_snapshot_and_source_version():
     encode = lambda value: json.dumps(value, sort_keys=True, ensure_ascii=False,
                                      separators=(',', ':'), allow_nan=False)
     assert encode(a) == encode(b)
-    assert a['version'] == 1 and a['runtimeVersion'] == '0.9.1'
+    assert a['version'] == 1 and a['runtimeVersion'] == '0.9.2'
     assert tuple(case['id'] for case in a['cases']) == CASES
     assert a['cases'][0]['origin'] == 'fixture'
     assert a['cases'][1]['state'] == 'not_run'

{b3_prosaic_runtime-0.9.1 → b3_prosaic_runtime-0.9.2}/tests/test_distribution_metadata.py

@@ -14,7 +14,7 @@ import pytest
 
 
 @pytest.mark.parametrize("project,name,version,package,dependency,licenses", [
-    (".", "b3-prosaic-runtime", "0.9.1", "prosaic_runtime", "b3-prosaic<0.5,>=0.4",
+    (".", "b3-prosaic-runtime", "0.9.2", "prosaic_runtime", "b3-prosaic<0.5,>=0.4",
      ("LICENSE", "LICENSE-MIT", "NOTICE.md")),
     ("adapters/postgres", "b3-prosaic-runtime-postgres", "0.3.0", "prosaic_runtime_postgres",
      "b3-prosaic-runtime<0.10,>=0.9", ("LICENSE", "LICENSE-MIT", "NOTICE.md")),