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

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

@@ -1,6 +1,23 @@
 # Changelog
 
-## Unreleased
+## 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
+  around an unmodified Runtime. Execution callbacks can only reduce authority.
+- Share deadline, request/tool allowances and reported-token evidence across all
+  adapter attempts; preserve known partial and unknown usage and callback failures.
+- Ordinary execution, conversation APIs, accounting and PostgreSQL remain unchanged.
+- Publish only the SDK distribution; retain adapter compatibility qualification.
+
+## Unreleased historical candidates
 
 - Prepare Runtime 0.8.1 and the paired PostgreSQL recorder 0.2.1 patch candidates.
 - Recheck cancellation and absolute deadlines after observer/accounting preparation,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b3-prosaic-runtime
-Version: 0.9.0
+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.0 → 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.0 → 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.0"
+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.0 → 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.0'),
+            (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.0 → 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.0"),
+            (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.0 → b3_prosaic_runtime-0.9.2}/scripts/release_artifacts.py

@@ -443,10 +443,16 @@ def fetch_public(url):
         raise
 
 
-def check_index(directory, commit, *, allow_missing=False, fetch=fetch_public):
+def check_index(directory, commit, *, allow_missing=False, fetch=fetch_public, distributions=None):
     receipt = verify_receipt(directory, commit)
+    available = {item['name'] for item in receipt['distributions']}
+    selected = available if distributions is None else set(distributions)
+    if not selected or not selected.issubset(available):
+        raise ReleaseError('invalid index distribution selection')
     missing = False
     for distribution in receipt['distributions']:
+        if distribution['name'] not in selected:
+            continue
         name, version = distribution['name'], distribution['version']
         if not re.fullmatch('[A-Za-z0-9_.-]+', name) or not re.fullmatch('[A-Za-z0-9_.+-]+', version):
             raise ReleaseError('invalid index package identity')
@@ -561,6 +567,7 @@ def main():
             command.add_argument('--require', action='append', required=True)
         elif action == 'index-check':
             command.add_argument('--allow-missing', action='store_true')
+            command.add_argument('--distribution', action='append')
     args = parser.parse_args()
     if args.action == 'build':
         expected = dict(value.split('=', 1) for value in args.expect)
@@ -574,7 +581,8 @@ def main():
         command = args.command[1:] if args.command[:1] == ['--'] else args.command
         result = qualify(args.directory, args.commit, args.label, command, junit=args.junit)
     elif args.action == 'index-check':
-        result = check_index(args.directory, args.commit, allow_missing=args.allow_missing)
+        result = check_index(args.directory, args.commit, allow_missing=args.allow_missing,
+                             distributions=args.distribution)
     else:
         result = require_qualification(args.directory, args.commit, args.require)
     print(json.dumps(result, sort_keys=True))

{b3_prosaic_runtime-0.9.0 → 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.0
+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.0 → b3_prosaic_runtime-0.9.2}/src/b3_prosaic_runtime.egg-info/SOURCES.txt

@@ -70,6 +70,7 @@ src/b3_prosaic_runtime.egg-info/top_level.txt
 src/prosaic_runtime/__init__.py
 src/prosaic_runtime/accounting.py
 src/prosaic_runtime/accounting_capture.py
+src/prosaic_runtime/adapter.py
 src/prosaic_runtime/admission.py
 src/prosaic_runtime/anthropic.py
 src/prosaic_runtime/anthropic_stream.py
@@ -86,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
@@ -132,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
@@ -143,6 +146,7 @@ tests/test_provider_execution.py
 tests/test_read_provenance.py
 tests/test_redirect_safety.py
 tests/test_release_artifacts.py
+tests/test_run_adapter.py
 tests/test_runtime.py
 tests/test_sample_program.py
 tests/test_sandbox_probe_example.py

{b3_prosaic_runtime-0.9.0 → 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.0'
+__version__ = '0.9.2'
 
 from .artifacts import ProsaicArtifact
 from .config import EndpointConfig, RuntimeConfig, RunLimits, CliSandboxConfig
@@ -30,3 +30,9 @@ from .conversation import (ConversationMessage, CompletedTurn, TurnEvidence,
                            TurnResult, TurnLimits, PreparedTurn, TurnAdmissionError)
 __all__ += ["ConversationMessage", "CompletedTurn", "TurnEvidence", "TurnResult",
             "TurnLimits", "PreparedTurn", "TurnAdmissionError"]
+
+from .adapter import RuntimeAdapter
+__all__ += ["RuntimeAdapter"]
+
+from .execution_budget import ExecutionBudget
+__all__ += ["ExecutionBudget"]

b3_prosaic_runtime-0.9.2/src/prosaic_runtime/adapter.py

@@ -0,0 +1,200 @@
+"""Trusted host adaptation around an unmodified Runtime and one shared allowance.
+
+ALWAYS dispatch through execute and retain every attempt's evidence.
+NEVER broaden host policy or manufacture successful execution from a failed call.
+"""
+from copy import deepcopy
+from dataclasses import dataclass, replace
+import hashlib
+import math
+import re
+import time
+
+from .runtime import ProsaicRuntime
+from .policy import RunPolicy
+from .types import Result
+from .budgets import InvocationBudgetExceeded
+
+
+class AdapterBoundary(Exception):
+    def __init__(self, reason):
+        self.reason = reason
+        super().__init__(reason)
+
+
+class _Attempts:
+    def __init__(self, policy, maximum, deadline, cancelled):
+        self.policy, self.maximum, self.deadline, self.cancelled = policy, maximum, deadline, cancelled
+        self.records = []
+        self.requests = self.tools = self.tokens = 0
+        self.complete = True
+        self.cost = 0.0
+        self.last = None
+
+    def remaining(self, timeout_s=None, allowed_tools=None, max_tool_rounds=None, max_input_bytes=None):
+        if self.cancelled():
+            raise AdapterBoundary('adapter_cancelled')
+        remaining = self.deadline - time.monotonic()
+        if remaining <= 0:
+            raise AdapterBoundary('adapter_timeout')
+        if len(self.records) >= self.maximum:
+            raise AdapterBoundary('adapter_attempt_limit')
+        policy = self.policy
+        values = {}
+        for name, consumed in (('max_provider_requests', self.requests), ('max_tool_calls', self.tools), ('max_reported_tokens', self.tokens)):
+            cap = getattr(policy, name)
+            if cap is not None:
+                if name == 'max_reported_tokens' and not self.complete:
+                    raise InvocationBudgetExceeded('usage_unknown')
+                if consumed >= cap and name != 'max_tool_calls':
+                    raise InvocationBudgetExceeded('token_limit' if name == 'max_reported_tokens' else 'provider_request_limit')
+                values[name] = max(0, cap - consumed)
+        if allowed_tools is not None:
+            grant = frozenset(allowed_tools)
+            if grant - policy.allowed_tools:
+                raise ValueError('adapter cannot broaden tool grants')
+            values['allowed_tools'] = grant
+        for name, value in (('max_tool_rounds', max_tool_rounds), ('max_input_bytes', max_input_bytes)):
+            if value is not None:
+                if type(value) is not int or value <= 0:
+                    raise ValueError('adapter bounds must be positive integers')
+                values[name] = min(getattr(policy, name), value)
+        if timeout_s is not None:
+            if not isinstance(timeout_s, (float, int)) or isinstance(timeout_s, bool) or not math.isfinite(timeout_s) or timeout_s <= 0:
+                raise ValueError('adapter timeout must be finite and positive')
+            remaining = min(remaining, timeout_s)
+        return replace(policy, timeout_s=remaining, **values)
+
+    def add(self, result, arguments):
+        if type(result) is not Result:
+            raise ValueError('adapter delegate must return Result')
+        owned = deepcopy(result)
+        info = owned.metadata.get('invocation_budgets_v1', {})
+        requests = info.get('provider_requests', 1)
+        tools = info.get('tool_calls', 0)
+        if any(type(value) is not int or value < 0 for value in (requests, tools)):
+            raise ValueError('invalid delegate allowance evidence')
+        usage = owned.token_usage
+        if usage is not None and (type(usage) is not int or usage < 0):
+            raise ValueError('invalid delegate usage evidence')
+        complete = info.get('usage_complete', usage is not None or requests == 0)
+        if type(complete) is not bool:
+            raise ValueError('invalid delegate usage completeness')
+        self.complete &= complete and (usage is not None or requests == 0)
+        reported = info.get('reported_tokens', usage or 0)
+        if type(reported) is not int or reported < 0:
+            raise ValueError('invalid partial usage evidence')
+        known = max(reported, usage or 0)
+        self.tokens += known
+        self.requests += requests
+        self.tools += tools
+        if not isinstance(owned.cost_usd, (int, float)) or not math.isfinite(owned.cost_usd) or owned.cost_usd < 0:
+            raise ValueError('invalid delegate cost evidence')
+        self.cost += owned.cost_usd
+        self.last = owned
+        self.records.append({'index': len(self.records) + 1, 'exit_code': owned.exit_code,
+            'timed_out': owned.timed_out, 'token_usage': usage, 'known_tokens': known, 'provider_requests': requests,
+            'tool_calls': tools, 'arguments_sha256': hashlib.sha256(arguments.encode()).hexdigest()})
+
+    def finish(self, result, descriptor):
+        if type(result) is not Result:
+            result = Result(1, '', 'adapter returned an invalid result', metadata={'failure_reason': 'adapter_result_mismatch'})
+        if result.exit_code == 0 and (self.last is None or self.last.exit_code != 0):
+            result = Result(1, '', 'adapter cannot admit a failed execution', metadata={'failure_reason': 'adapter_result_mismatch'})
+        reason = None
+        for name, value, code in (('max_provider_requests', self.requests, 'provider_request_limit'),
+                                  ('max_tool_calls', self.tools, 'tool_call_limit'),
+                                  ('max_reported_tokens', self.tokens, 'token_limit')):
+            cap = getattr(self.policy, name)
+            if cap is not None and value > cap:
+                reason = code
+        if self.policy.max_reported_tokens is not None and not self.complete:
+            reason = 'usage_unknown'
+        if result.exit_code == 0 and self.cancelled():
+            result = Result(130, '', 'invocation cancelled', metadata={'failure_reason': 'cancelled'})
+        elif result.exit_code == 0 and time.monotonic() >= self.deadline:
+            result = Result(1, '', 'invocation deadline exceeded', timed_out=True)
+        if reason:
+            result = Result(1, '', reason, metadata={'failure_reason': reason})
+        metadata = deepcopy(self.last.metadata if self.last is not None else {})
+        for key, value in result.metadata.items():
+            if key not in metadata or key == 'failure_reason':
+                metadata[key] = deepcopy(value)
+        result = replace(result, stdout=result.stdout if result.exit_code == 0 else '', metadata=metadata,
+                         token_usage=self.tokens if self.complete and self.records else None, cost_usd=self.cost)
+        result.metadata['invocation_budgets_v1'] = {'provider_requests': self.requests,
+            'tool_calls': self.tools, 'reported_tokens': self.tokens, 'usage_complete': self.complete}
+        result.metadata['runtime_adapter_v1'] = {**descriptor, 'attempts': deepcopy(self.records)}
+        return result
+
+
+@dataclass(frozen=True)
+class RuntimeAdapter:
+    """Versioned trusted invocation hook; execute accepts only reduced authority.
+
+    invoke(artifact, arguments, *, execute, policy, on_event, cancelled, **options)
+    must return Result. execute(arguments, **reductions) performs a real Runtime
+    invocation. Hooks are cooperative trusted host code, not a sandbox.
+    """
+    runtime: ProsaicRuntime
+    version: str
+    invoke: object
+    max_attempts: int = 3
+
+    def __post_init__(self):
+        if type(self.version) is not str or not re.fullmatch(r'[A-Za-z0-9_.-]{1,128}', self.version):
+            raise ValueError('adapter needs a bounded version')
+        if not callable(self.invoke) or type(self.max_attempts) is not int or not 1 <= self.max_attempts <= 8:
+            raise ValueError('adapter needs a callback and bounded attempts')
+        self.validate_binding()
+
+    def validate_binding(self):
+        if (type(self.runtime) is not ProsaicRuntime or
+                getattr(self.runtime.run, '__func__', None) is not ProsaicRuntime.run):
+            raise ValueError('adapter requires an unmodified concrete ProsaicRuntime')
+
+    @property
+    def descriptor(self):
+        self.validate_binding()
+        return {'version': self.version, 'contract': 'runtime_adapter_v1', 'max_attempts': self.max_attempts}
+
+    @property
+    def config(self):
+        return self.runtime.config
+
+    @property
+    def capabilities(self):
+        return self.runtime.capabilities | frozenset({'runtime_adapter_v1'})
+
+    @property
+    def tool_descriptors(self):
+        return self.runtime.tool_descriptors
+
+    @property
+    def cli_tool_names(self):
+        return self.runtime.cli_tool_names
+
+    def run(self, artifact, arguments='', *, policy=None, on_event=None, cancelled=None, **options):
+        self.validate_binding()
+        policy = policy or RunPolicy()
+        cancelled = cancelled or (lambda: False)
+        ledger = _Attempts(policy, self.max_attempts, time.monotonic() + policy.timeout_s, cancelled)
+        descriptor = self.descriptor
+        def execute(projected, **reductions):
+            self.validate_binding()
+            effective = ledger.remaining(**reductions)
+            if type(projected) is not str:
+                raise ValueError('adapter arguments must be text')
+            result = self.runtime.run(artifact, projected, policy=effective, on_event=on_event,
+                                      cancelled=cancelled, **options)
+            ledger.add(result, projected)
+            return result
+        try:
+            result = self.invoke(artifact, arguments, execute=execute, policy=policy,
+                                 on_event=on_event, cancelled=cancelled, **options)
+        except (InvocationBudgetExceeded, AdapterBoundary) as exc:
+            result = Result(130 if exc.reason == 'adapter_cancelled' else 1, '', exc.reason,
+                timed_out=exc.reason == 'adapter_timeout', metadata={'failure_reason': exc.reason})
+        except Exception:
+            result = Result(1, '', 'trusted adapter callback failed', metadata={'failure_reason': 'adapter_callback_failed'})
+        return ledger.finish(result, descriptor)

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.0 → 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)