b3-prosaic-runtime 0.8.1__py3-none-any.whl

prosaic_runtime/accounting_capture.py

@@ -0,0 +1,275 @@
+"""Per-request capture independent of diagnostic sinks and cancellation."""
+import json
+import uuid
+from .accounting import AccountingError, normalize_usage, utc_now
+
+
+class InvalidEvidence(ValueError):
+    pass
+
+
+def strict_json(raw):
+    def pairs(items):
+        result = {}
+        for key, value in items:
+            if key in result:
+                raise InvalidEvidence('duplicate response key')
+            result[key] = value
+        return result
+    def constant(value):
+        raise InvalidEvidence('nonfinite response value')
+    return json.loads(raw, object_pairs_hook=pairs, parse_constant=constant)
+
+
+class Capture:
+    def __init__(self, recorder, context, artifact, profile, provider='openai-compatible'):
+        self.recorder, self.context = recorder, context
+        self.artifact, self.profile = artifact, profile
+        self.call_ids = []
+        self.provider = provider
+
+    def open(self, opener, request, timeout, *, before_dispatch=None):
+        call_id = uuid.uuid4().hex
+        payload = json.loads(request.data)
+        card = self.recorder.rate_card
+        intent = {'version': 1, 'provider_call_id': call_id,
+                  'namespace': self.recorder.namespace, 'environment': self.recorder.environment,
+                  'context': self.context.to_dict(), 'artifact_id': self.artifact.id,
+                  'artifact_sha256': self.artifact.digest, 'profile': self.profile,
+                  'provider_id': self.recorder.provider_id, 'credential_account': self.recorder.credential_account,
+                  'requested_model': payload['model'], 'started_at': utc_now(),
+                  'rate_card': card.to_dict() if card else None}
+        try:
+            self.recorder.prepare(intent)
+        except Exception as exc:
+            raise AccountingError('intent persistence failed') from exc
+        self.call_ids.append(call_id)
+        observer = AnthropicObservation if self.provider == 'anthropic' else Observation
+        observation = observer(self.recorder, call_id)
+        try:
+            if before_dispatch is not None:
+                timeout = before_dispatch(timeout)
+            response = opener.open(request, timeout=timeout)
+        except BaseException as exc:
+            from .events import Cancelled
+            observation.finish('cancelled' if isinstance(exc, (Cancelled, KeyboardInterrupt)) else 'failed')
+            raise
+        return RecordedResponse(response, observation)
+
+
+class Observation:
+    eager_events = True
+    def __init__(self, recorder, call_id):
+        self.recorder, self.call_id = recorder, call_id
+        self.usage, self.model, self.request_id, self.tier = None, None, None, None
+        self.conflict = False
+        self.finished = False
+        self.terminal = False
+
+    def capture(self, event):
+        if type(event) is not dict:
+            return
+        choices = event.get('choices')
+        if type(choices) is list and any(type(choice) is dict and choice.get('finish_reason') in {'stop', 'tool_calls', 'length', 'content_filter'} for choice in choices):
+            self.terminal = True
+        for key, attr in (('model', 'model'), ('id', 'request_id'), ('service_tier', 'tier')):
+            value = event.get(key)
+            if type(value) is str and len(value) <= 256:
+                previous = getattr(self, attr)
+                if previous is not None and previous != value:
+                    self.conflict = True
+                setattr(self, attr, value)
+        if event.get('usage') is not None:
+            usage = normalize_usage(event['usage'])
+            # Repeated snapshots are not deltas. Conflicting nonidentical usage
+            # is quarantined rather than choosing a potentially wrong bill.
+            if self.usage is not None and self.usage != usage:
+                self.conflict = True
+            self.usage = usage
+
+    def finish(self, outcome):
+        if self.finished:
+            return
+        usage = self.usage or normalize_usage(None)
+        if self.conflict:
+            usage = {**usage, 'status': 'untrusted'}
+        elif usage['status'] == 'reported' and not self.terminal:
+            usage = {**usage, 'status': 'partial'}
+        value = {'version': 1, 'provider_call_id': self.call_id,
+                 'finished_at': utc_now(), 'outcome': outcome,
+                 'response_model': self.model, 'provider_request_id': self.request_id,
+                 'service_tier': self.tier, 'usage': usage}
+        try:
+            self.recorder.observe(self.call_id, value)
+        except Exception as exc:
+            raise AccountingError('observation persistence failed') from exc
+        self.finished = True
+
+
+class AnthropicObservation(Observation):
+    eager_events = False
+
+    def __init__(self, recorder, call_id):
+        super().__init__(recorder, call_id)
+        from .anthropic_stream import StreamState
+        self.state = StreamState(lambda text: None)
+
+    def capture(self, event):
+        from .anthropic import parse_message
+        from .anthropic_usage import normalize_anthropic_usage
+        if type(event) is not dict:
+            self.conflict = True
+            return
+        if event.get('type') == 'message':
+            message = event
+            self.usage = normalize_anthropic_usage(message.get('usage'))
+            try:
+                parse_message(message)
+                self.terminal = message.get('stop_reason') in {
+                    'end_turn', 'stop_sequence', 'tool_use', 'max_tokens', 'refusal', 'pause_turn'}
+            except (ValueError, TypeError, RecursionError):
+                self.conflict = True
+        else:
+            try:
+                self.state.push(event)
+                if self.state.stopped:
+                    parse_message(self.state.message)
+                    self.terminal = True
+            except (ValueError, TypeError, RecursionError):
+                self.conflict = True
+            message = self.state.message or {}
+            self.usage = self.state.usage.normalized()
+            self.conflict |= self.state.usage.conflict
+        for key, attr in (('model', 'model'), ('id', 'request_id')):
+            value = message.get(key)
+            if type(value) is str and 0 < len(value) <= 256:
+                previous = getattr(self, attr)
+                if previous is not None and previous != value:
+                    self.conflict = True
+                setattr(self, attr, value)
+            elif key in message:
+                self.conflict = True
+        raw_usage = message.get('usage')
+        if isinstance(raw_usage, dict) and raw_usage.get('service_tier') is not None:
+            tier = raw_usage['service_tier']
+            tier = 'default' if tier == 'standard' else tier
+            if not isinstance(tier, str) or len(tier) > 256 or (self.tier is not None and self.tier != tier):
+                self.conflict = True
+            else:
+                self.tier = tier
+
+
+class RecordedResponse:
+    def __init__(self, response, observation):
+        self.response, self.observation = response, observation
+        self.data = []
+        self.event_name = None
+        self.body = bytearray()
+
+    def __getattr__(self, name):
+        return getattr(self.response, name)
+
+    def __enter__(self):
+        self.response.__enter__()
+        return self
+
+    def __exit__(self, typ, value, traceback):
+        try:
+            if self.body:
+                self._capture_body(bytes(self.body))
+                self.body.clear()
+            if not self.observation.eager_events and (self.data or self.event_name is not None):
+                self.observation.conflict = True
+            self._flush()
+            self.observation.finish('cancelled' if typ and typ.__name__ in {'Cancelled', 'KeyboardInterrupt'}
+                                    else 'failed' if typ or not self.observation.terminal else 'completed')
+        finally:
+            return_value = self.response.__exit__(typ, value, traceback)
+        return return_value
+
+    def _flush(self):
+        if self.data:
+            try:
+                event = strict_json('\n'.join(self.data))
+                if self.event_name is not None and (not isinstance(event, dict) or event.get('type') != self.event_name):
+                    self.observation.conflict = True
+                self.observation.capture(event)
+            except (ValueError, TypeError, RecursionError):
+                self.observation.conflict = True
+            self.data = []
+        elif self.event_name is not None:
+            self.observation.conflict = True
+        self.event_name = None
+
+    def _line(self, raw):
+        if self.observation.eager_events:
+            line = raw.decode('utf-8', errors='replace').strip()
+        else:
+            try:
+                line = raw.decode('utf-8', errors='strict').rstrip('\r\n')
+            except UnicodeError:
+                self.observation.conflict = True
+                return
+        if not line:
+            self._flush()
+        elif not self.observation.eager_events and line.startswith('event:'):
+            if self.event_name is not None:
+                self.observation.conflict = True
+            self.event_name = line[6:].lstrip()
+        elif line.startswith('data:'):
+            value = line[5:].lstrip()
+            if value == '[DONE]' and self.observation.eager_events:
+                self._flush()
+            else:
+                self.data.append(value)
+                if not self.observation.eager_events:
+                    return
+                # Capture before the normal parser can emit a text callback
+                # that requests cancellation. Multi-line JSON remains buffered.
+                try:
+                    event = strict_json('\n'.join(self.data))
+                except InvalidEvidence:
+                    self.observation.conflict = True
+                    self.data = []
+                    return
+                except ValueError:
+                    return
+                self.observation.capture(event)
+                self.data = []
+
+    def readline(self, *args):
+        raw = self.response.readline(*args)
+        self._line(raw)
+        return raw
+
+    def read_chunk(self, size):
+        """Line assembly reads bounded chunks; evidence is admitted per line."""
+        return self.response.read1(size)
+
+    def capture_line(self, raw):
+        self._line(raw)
+
+    def read(self, *args):
+        raw = self.response.read(*args)
+        self._capture_body(raw)
+        return raw
+
+    def read1(self, *args):
+        raw = self.response.read1(*args)
+        self.body.extend(raw)
+        if not raw:
+            self._capture_body(bytes(self.body))
+            self.body.clear()
+        return raw
+
+    def _capture_body(self, raw):
+        try:
+            self.observation.capture(strict_json(raw))
+        except InvalidEvidence:
+            self.observation.conflict = True
+        except RecursionError:
+            self.observation.conflict = True
+        except (ValueError, TypeError):
+            for line in raw.splitlines():
+                self._line(line)
+            self._flush()

prosaic_runtime/admission.py

@@ -0,0 +1,57 @@
+"""Pure execution-metadata checks for already inspected Prosaic artifacts."""
+from .artifacts import ProsaicArtifact
+from .config import EndpointConfig, RuntimeConfig
+from .policy import requested_tools
+from .anthropic import validate_anthropic_controls
+
+
+def _inspection_artifact(artifact):
+    if not isinstance(artifact, ProsaicArtifact):
+        raise ValueError('execution admission requires a Prosaic inspection artifact')
+    try:
+        return ProsaicArtifact.from_inspection({
+            'id': artifact.id, 'type': artifact.type, 'frontmatter': artifact.frontmatter,
+            'body': artifact.body, 'resources': list(artifact.resources)})
+    except (TypeError, AttributeError) as exc:
+        raise ValueError('invalid Prosaic inspection artifact') from exc
+
+
+def validate_execution_artifact(artifact, config, *, acquisition=None) -> None:
+    """Check structural and supported execution metadata without preparing a run.
+
+    Inputs must already be inspected artifacts and a RuntimeConfig. This function
+    does not inspect paths, discover tools, render prompts, construct a Runtime or
+    invoke callbacks/transports. Tool registration/grants and invocation-dependent
+    limits remain separate checks. Canonical prose fields belong to Prosaic.
+    """
+    artifact = _inspection_artifact(artifact)
+    if not isinstance(config, RuntimeConfig):
+        raise ValueError('execution admission requires a RuntimeConfig')
+    requested = requested_tools(artifact.frontmatter.get('tools'))
+    effort = artifact.frontmatter.get('effort')
+    if effort is not None and (not isinstance(effort, str) or effort not in {'low', 'medium', 'high'}):
+        raise ValueError(f'unsupported effort: {effort}')
+    tier = artifact.frontmatter.get('model_tier')
+    try:
+        if tier is not None and (not isinstance(tier, str) or tier not in config.routes):
+            raise ValueError(f'no endpoint route for model_tier: {tier}')
+        profile = config.routes[tier] if tier is not None else config.default_profile
+        endpoint = config.profiles[profile]
+        if not isinstance(endpoint, EndpointConfig):
+            raise ValueError('selected profile requires an EndpointConfig')
+        # Runtime disables these controls regardless of operator configuration.
+        features = {**endpoint.features, 'web_tools': False, 'transcript': False}
+    except (TypeError, KeyError, AttributeError) as exc:
+        raise ValueError('invalid selected runtime profile or route') from exc
+    if endpoint.provider == 'anthropic':
+        validate_anthropic_controls(features, {'effort': effort})
+    if acquisition is not None:
+        acquisition = _inspection_artifact(acquisition)
+        acquisition_tools = requested_tools(acquisition.frontmatter.get('tools'))
+        if acquisition_tools - requested:
+            raise ValueError('acquisition tools cannot broaden final prose tools')
+        for key in ('model_tier', 'effort'):
+            if key in acquisition.frontmatter and acquisition.frontmatter[key] != artifact.frontmatter.get(key):
+                raise ValueError(f'acquisition {key} must match final prose or be omitted')
+        # Acquisitions use the selected final endpoint and effort, never a new
+        # route/default selection based on their omitted metadata.

prosaic_runtime/anthropic.py

@@ -0,0 +1,205 @@
+"""Native Anthropic Messages transport; tools execute only in the shared loop."""
+import json
+import socket
+import time
+import urllib.error
+import urllib.request
+
+from .accounting_capture import strict_json
+from .execution import ExecutionBackend
+from .provider_types import ProviderTurn
+from .anthropic_usage import normalize_anthropic_usage
+from .types import Result
+from .tools import depth
+from .openai_compatible import (
+    OpenAICompatibleBackend, _OpenAIToolRegistry, _api_key, _feature_enabled,
+    _http_status, _is_sse_response, _prompt_metadata, _raw_response_headers,
+    _tool_call_summary,
+)
+from .openai_compatible_transcript import ProviderTranscript
+
+API_VERSION = '2023-06-01'
+
+
+def validate_anthropic_controls(features, prompt_metadata):
+    """Validate known Messages controls without constructing a model request."""
+    unsupported = {'json_mode', 'reasoning_effort', 'effort', 'thinking', 'stream_options', 'web_tools'}
+    for name in unsupported:
+        value = features.get(name)
+        if value not in (None, False, 'off', 'false', 'disabled'):
+            raise ValueError(f'unsupported Anthropic feature: {name}')
+    if any(prompt_metadata.get(k) is not None for k in ('effort', 'reasoning_effort')):
+        raise ValueError('unsupported Anthropic effort control')
+
+
+def native_headers(token):
+    headers = {'Content-Type': 'application/json', 'anthropic-version': API_VERSION}
+    if token:
+        headers['x-api-key'] = token
+    return headers
+
+
+def encode_messages(payload):
+    """Convert the loop's internal history after acquisition/tool-choice edits."""
+    messages, system = [], []
+    for message in payload['messages']:
+        role = message['role']
+        if role == 'system':
+            system.append(message['content'])
+            continue
+        if role == 'tool':
+            content = message['content']
+            block = {'type': 'tool_result', 'tool_use_id': message['tool_call_id'], 'content': content}
+            if json.loads(content).get('status') == 'error':
+                block['is_error'] = True
+            role, blocks = 'user', [block]
+        elif role == 'assistant' and 'provider_content' in message:
+            blocks = message['provider_content']
+        else:
+            blocks = [{'type': 'text', 'text': message['content']}]
+        if messages and messages[-1]['role'] == role:
+            messages[-1]['content'].extend(blocks)
+        else:
+            messages.append({'role': role, 'content': list(blocks)})
+    native = {'model': payload['model'], 'max_tokens': payload['max_tokens'], 'messages': messages}
+    if system:
+        native['system'] = '\n\n'.join(system)
+    if payload.get('temperature') is not None:
+        native['temperature'] = payload['temperature']
+    if payload.get('stream'):
+        native['stream'] = True
+    if payload.get('tools'):
+        native['tools'] = [{'name': t['function']['name'],
+                            'description': t['function'].get('description', ''),
+                            'input_schema': t['function']['parameters']} for t in payload['tools']]
+        choice = payload.get('tool_choice', 'auto')
+        native['tool_choice'] = ({'type': 'tool', 'name': choice['function']['name'],
+                                  'disable_parallel_tool_use': True}
+                                 if isinstance(choice, dict) else {'type': 'auto'})
+    return native
+
+
+def usage_details(raw):
+    usage = normalize_anthropic_usage(raw)
+    if usage['status'] in {'untrusted', 'unknown'} or usage['total_tokens'] is None:
+        return {}
+    return {'prompt_tokens': usage['input_tokens'], 'completion_tokens': usage['output_tokens'],
+            'total_tokens': usage['total_tokens']}
+
+
+def parse_message(value, *, streamed=False, http_status=200, headers=None, usage_conflict=False):
+    """Validate native content before exposing any executable tool request."""
+    if (not isinstance(value, dict) or value.get('type') != 'message' or
+            value.get('role') != 'assistant' or not isinstance(value.get('content'), list) or
+            not isinstance(value.get('id'), str) or not value['id'] or
+            not isinstance(value.get('model'), str) or not value['model']):
+        raise ValueError('invalid Messages response')
+    depth(value)
+    text, calls, ids = [], [], set()
+    for block in value['content']:
+        if not isinstance(block, dict):
+            raise ValueError('invalid content block')
+        if block.get('type') == 'text' and isinstance(block.get('text'), str):
+            text.append(block['text'])
+        elif block.get('type') == 'tool_use':
+            if (not isinstance(block.get('id'), str) or not block['id'] or block['id'] in ids or
+                    not isinstance(block.get('name'), str) or not block['name'] or
+                    type(block.get('input')) is not dict):
+                raise ValueError('invalid tool_use block')
+            ids.add(block['id'])
+            calls.append({'id': block['id'], 'type': 'function', 'function': {
+                'name': block['name'], 'arguments': json.dumps(block['input'], allow_nan=False)}})
+        else:
+            raise ValueError('unsupported content block')
+    details = {} if usage_conflict else usage_details(value.get('usage'))
+    raw = {k: value[k] for k in ('id', 'model', 'stop_reason', 'stop_sequence', 'usage') if k in value}
+    raw['usage_status'] = 'untrusted' if usage_conflict else normalize_anthropic_usage(value.get('usage'))['status']
+    metadata = {'provider': 'anthropic', 'streamed': streamed, 'http_status': http_status,
+                'raw_response_headers': headers or {}, 'raw_response_metadata': raw,
+                'token_usage_details': details}
+    stop = value.get('stop_reason')
+    if stop not in {'end_turn', 'stop_sequence', 'tool_use'}:
+        code = 'incomplete_generation' if stop == 'max_tokens' else 'unsupported_stop_reason'
+        return Result(1, ''.join(text), 'Anthropic did not complete the requested turn',
+                      token_usage=details.get('total_tokens'), metadata={**metadata,
+                      'provider_error_code': code, 'failure_reason': code, 'finish_reason': stop})
+    if bool(calls) != (stop == 'tool_use'):
+        raise ValueError('tool use and stop reason disagree')
+    return ProviderTurn(''.join(text), 'tool_calls' if calls else 'stop', details.get('total_tokens', 0),
+                        details, raw, False, calls, streamed, http_status, headers or {},
+                        continuation=value['content'])
+
+
+class AnthropicBackend(ExecutionBackend):
+    name = 'anthropic'
+
+    def __init__(self, config):
+        self._config = config
+
+    def make_registry(self, cwd, features, metadata):
+        return _OpenAIToolRegistry(cwd, features, metadata)
+
+    def tool_call_summary(self, call):
+        return _tool_call_summary(call)
+
+    def tool_event_metadata(self, name):
+        return {}
+
+    def strict_tool_names(self):
+        return frozenset()
+
+    def open_transcript(self, request):
+        return ProviderTranscript(None)
+
+    def tool_guidance(self):
+        return OpenAICompatibleBackend.tool_guidance(self)
+
+    def run_prompt(self, request):
+        return self._run_prompt_with_tools(request, _prompt_metadata(request),
+                                           _feature_enabled(self._config.features, 'streaming', default=True))
+
+    def _chat_payload(self, messages, prompt_metadata, *, streaming, tools=None):
+        validate_anthropic_controls(self._config.features, prompt_metadata)
+        payload = OpenAICompatibleBackend._chat_payload(self, messages, prompt_metadata, streaming=streaming, tools=tools)
+        if type(payload.get('max_tokens')) is not int or payload['max_tokens'] <= 0:
+            raise ValueError('Anthropic max_tokens must be a positive integer')
+        payload.pop('stream_options', None)
+        return payload
+
+    def _post_chat_turn(self, payload, request, deadline, streaming):
+        native = encode_messages(payload)
+        self.validate_payload(native)
+        token, error = _api_key(self._config.api_key_env, self._config.api_key_file, request.env)
+        if error:
+            return Result(1, '', error, metadata={'provider': self.name, 'provider_error_code': 'api_key_file_error'})
+        http_request = urllib.request.Request(self._config.base_url.rstrip('/') + '/messages',
+            data=json.dumps(native, allow_nan=False).encode('utf-8'), headers=native_headers(token), method='POST')
+        try:
+            with self.open_http(http_request, timeout=max(0.001, min(request.timeout_s, deadline - time.monotonic()))) as response:
+                status, headers = _http_status(response), _raw_response_headers(response)
+                if streaming and _is_sse_response(response):
+                    return self._read_sse_turn(response, deadline)
+                body = self.read_response(response)
+        except (TimeoutError, socket.timeout):
+            return Result(1, '', 'Anthropic request timed out', timed_out=True,
+                          metadata={'provider': self.name, 'provider_error_code': 'timeout'})
+        except UnicodeError:
+            return Result(1, '', 'Malformed Anthropic response', metadata={
+                'provider': self.name, 'provider_error_code': 'malformed_response'})
+        except urllib.error.HTTPError as exc:
+            exc.close()
+            return Result(exc.code, '', 'Anthropic request rejected', metadata={
+                'provider': self.name, 'http_status': exc.code, 'provider_error_code': 'http_error'})
+        except (urllib.error.URLError, OSError) as exc:
+            return Result(1, '', 'Anthropic transport failed', metadata={
+                'provider': self.name, 'provider_error_code': 'url_error'})
+        try:
+            return parse_message(strict_json(body), http_status=status, headers=headers)
+        except (ValueError, TypeError, UnicodeError, RecursionError):
+            return Result(1, '', 'Malformed or unsupported Anthropic response', metadata={
+                'provider': self.name, 'http_status': status, 'provider_error_code': 'malformed_response'})
+
+    def _read_sse_turn(self, response, deadline):
+        # Implemented separately from JSON framing; partial tool inputs are never executable.
+        from .anthropic_stream import read_anthropic_turn
+        return read_anthropic_turn(response, deadline)