From 9962e50eecee61fb8d6477c4ae8638d261e9edf9 Mon Sep 17 00:00:00 2001 From: Nikhil Pareek Date: Tue, 10 Nov 2026 16:57:35 -0800 Subject: [PATCH 1/4] feat(python): add opt-in attachment core and auto plumbing Add deny-wins audio admission, immutable correlation handles, bounded provider-owned transfer workers, explicit owned-file leases and session-binding entry points. Keep unqualified retrieval and recording streams fail-closed. Co-Authored-By: Claude Code --- .../workflows/attachments-python-tests.yml | 41 + .../attachments/__init__.py | 20 + .../attachments/_protocol_schema.json | 739 ++++++++++++++++++ .../fi_instrumentation/attachments/manager.py | 435 +++++++++++ .../fi_instrumentation/attachments/policy.py | 160 ++++ .../attachments/protocol.py | 282 +++++++ .../fi_instrumentation/attachments/sources.py | 128 +++ .../fi_instrumentation/attachments/types.py | 130 +++ python/fi_instrumentation/otel.py | 22 +- python/tests/attachments/conftest.py | 71 ++ .../tests/attachments/test_http_contract.py | 179 +++++ .../tests/attachments/test_policy_runtime.py | 290 +++++++ python/tests/attachments/test_sources.py | 92 +++ python/traceai/__init__.py | 152 +++- python/traceai/tests/conftest.py | 11 + python/traceai/tests/test_attachments.py | 57 ++ 16 files changed, 2778 insertions(+), 31 deletions(-) create mode 100644 .github/workflows/attachments-python-tests.yml create mode 100644 python/fi_instrumentation/attachments/__init__.py create mode 100644 python/fi_instrumentation/attachments/_protocol_schema.json create mode 100644 python/fi_instrumentation/attachments/manager.py create mode 100644 python/fi_instrumentation/attachments/policy.py create mode 100644 python/fi_instrumentation/attachments/protocol.py create mode 100644 python/fi_instrumentation/attachments/sources.py create mode 100644 python/fi_instrumentation/attachments/types.py create mode 100644 python/tests/attachments/conftest.py create mode 100644 python/tests/attachments/test_http_contract.py create mode 100644 python/tests/attachments/test_policy_runtime.py create mode 100644 python/tests/attachments/test_sources.py create mode 100644 python/traceai/tests/conftest.py create mode 100644 python/traceai/tests/test_attachments.py diff --git a/.github/workflows/attachments-python-tests.yml b/.github/workflows/attachments-python-tests.yml new file mode 100644 index 000000000..8cb9128c3 --- /dev/null +++ b/.github/workflows/attachments-python-tests.yml @@ -0,0 +1,41 @@ +name: Python attachments + +on: + pull_request: + paths: + - 'python/fi_instrumentation/**' + - 'python/traceai/**' + - 'python/tests/attachments/**' + - '.github/workflows/attachments-python-tests.yml' + push: + branches: [dev] + paths: + - 'python/fi_instrumentation/**' + - 'python/traceai/**' + - 'python/tests/attachments/**' + - '.github/workflows/attachments-python-tests.yml' + +permissions: + contents: read + +jobs: + component: + runs-on: ubuntu-latest + timeout-minutes: 10 + strategy: + fail-fast: false + matrix: + python: ['3.10', '3.11', '3.12', '3.13'] + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '${{ matrix.python }}' + - name: Install component dependencies + run: python -m pip install -e python pytest==8.3.5 pytest-asyncio==0.26.0 pytest-mock==3.14.0 responses==0.25.7 + - name: Run synthetic attachment and auto tests + env: + PYTHONPATH: python + FI_BASE_URL: http://127.0.0.1:9 + FI_GRPC_URL: http://127.0.0.1:9 + run: python -m pytest -q python/tests/attachments python/traceai/tests diff --git a/python/fi_instrumentation/attachments/__init__.py b/python/fi_instrumentation/attachments/__init__.py new file mode 100644 index 000000000..b22845c9f --- /dev/null +++ b/python/fi_instrumentation/attachments/__init__.py @@ -0,0 +1,20 @@ +"""Opt-in, provider-owned audio attachments. + +Capture OFF and recording OFF by default. Importing an existing owned recording +never starts a recorder. RemoteUrl/ProviderFile/LocalFile are typed but fail closed +until their separately qualified retrieval adapters exist. +""" + +from .manager import AttachmentManager, AttachmentSpanProcessor +from .policy import AttachmentConfig, AttachmentPolicy, CapturePolicy, ServerPolicy +from .sources import OwnedRecordingFile, RecordingFileScope +from .types import ( + AttachmentHandle, Bytes, Completion, CorrelationHandle, FlushResult, + LocalFile, ProviderFile, RemoteUrl, +) + +__all__ = [ + "AttachmentConfig", "AttachmentManager", "AttachmentPolicy", "AttachmentSpanProcessor", + "AttachmentHandle", "Bytes", "CapturePolicy", "Completion", "CorrelationHandle", "FlushResult", + "LocalFile", "OwnedRecordingFile", "ProviderFile", "RecordingFileScope", "RemoteUrl", "ServerPolicy", +] diff --git a/python/fi_instrumentation/attachments/_protocol_schema.json b/python/fi_instrumentation/attachments/_protocol_schema.json new file mode 100644 index 000000000..a531510ca --- /dev/null +++ b/python/fi_instrumentation/attachments/_protocol_schema.json @@ -0,0 +1,739 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$comment": "Generated protocol-only subset of spec/attachments/v1/contract.schema.json; no runtime support claim.", + "$defs": { + "Association": { + "type": "object", + "additionalProperties": false, + "required": [ + "capture_session_id", + "correlation_nonce", + "parent" + ], + "properties": { + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "correlation_nonce": { + "$ref": "#/$defs/UUID" + }, + "parent": { + "$ref": "#/$defs/Parent" + } + } + }, + "BootstrapRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_versions", + "project_name", + "project_type", + "capture_session_id", + "correlation_nonce" + ], + "properties": { + "schema_versions": { + "type": "array", + "minItems": 1, + "maxItems": 8, + "uniqueItems": true, + "items": { + "type": "integer", + "minimum": 1, + "maximum": 65535 + } + }, + "project_name": { + "type": "string", + "minLength": 1, + "maxLength": 255 + }, + "project_type": { + "type": "string", + "minLength": 1, + "maxLength": 64 + }, + "workspace_id": { + "$ref": "#/$defs/UUID" + }, + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "correlation_nonce": { + "$ref": "#/$defs/UUID" + } + } + }, + "BootstrapResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "scope", + "capture_session_id", + "policy", + "limits", + "expires_at", + "transfer_modes" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "scope": { + "$ref": "#/$defs/Scope" + }, + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "policy": { + "$ref": "#/$defs/Policy" + }, + "limits": { + "$ref": "#/$defs/Limits" + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "transfer_modes": { + "const": [ + "authenticated_stream" + ] + } + } + }, + "CompleteRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "policy_version", + "deletion_generation" + ], + "properties": { + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + } + } + }, + "Direction": { + "enum": [ + "input", + "output", + "mixed" + ] + }, + "Limits": { + "type": "object", + "additionalProperties": false, + "required": [ + "max_upload_bytes", + "segment_bytes", + "segment_duration_ms", + "recording_bytes", + "recording_duration_ms", + "active_transfers", + "active_recordings", + "reserved_bytes", + "validation_jobs", + "initializations_per_minute", + "links_per_minute", + "upload_bytes_per_second", + "playback_bytes_per_second", + "transfer_timeout_seconds", + "grant_ttl_seconds", + "revocation_check_seconds" + ], + "properties": { + "max_upload_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "segment_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 8388608 + }, + "segment_duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 30000 + }, + "recording_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "recording_duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + }, + "active_transfers": { + "type": "integer", + "minimum": 1, + "maximum": 16 + }, + "active_recordings": { + "type": "integer", + "minimum": 1, + "maximum": 4 + }, + "reserved_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "validation_jobs": { + "type": "integer", + "minimum": 1, + "maximum": 1024 + }, + "initializations_per_minute": { + "type": "integer", + "minimum": 1, + "maximum": 120 + }, + "links_per_minute": { + "type": "integer", + "minimum": 1, + "maximum": 1000 + }, + "upload_bytes_per_second": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "playback_bytes_per_second": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "transfer_timeout_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 600 + }, + "grant_ttl_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 300 + }, + "revocation_check_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 5 + } + } + }, + "MIME": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16", + "image/png", + "image/jpeg", + "image/webp", + "video/mp4", + "video/webm", + "application/pdf", + "application/octet-stream" + ] + }, + "Modality": { + "enum": [ + "audio", + "image", + "video", + "document", + "file" + ] + }, + "Parent": { + "type": "object", + "additionalProperties": false, + "required": [ + "trace_id", + "span_id" + ], + "properties": { + "trace_id": { + "$ref": "#/$defs/TraceInput" + }, + "span_id": { + "$ref": "#/$defs/SpanID" + } + } + }, + "Policy": { + "type": "object", + "additionalProperties": false, + "required": [ + "version", + "enabled", + "allowed_sources", + "allowed_modalities", + "require_media_redaction", + "require_metadata_removal", + "allow_unredacted_media_with_text_pii", + "record_audio", + "record_video" + ], + "properties": { + "version": { + "$ref": "#/$defs/Token" + }, + "enabled": { + "type": "boolean" + }, + "allowed_sources": { + "type": "array", + "uniqueItems": true, + "maxItems": 6, + "items": { + "$ref": "#/$defs/SourceKind" + } + }, + "allowed_modalities": { + "type": "array", + "uniqueItems": true, + "maxItems": 5, + "items": { + "$ref": "#/$defs/Modality" + } + }, + "require_media_redaction": { + "type": "boolean" + }, + "require_metadata_removal": { + "type": "boolean" + }, + "allow_unredacted_media_with_text_pii": { + "type": "boolean" + }, + "record_audio": { + "type": "boolean" + }, + "record_video": { + "type": "boolean" + } + } + }, + "Purpose": { + "enum": [ + "conversation_recording", + "turn_recording", + "model_input", + "model_output", + "tool_result", + "computer_screenshot", + "diagnostic", + "document" + ] + }, + "Reason": { + "enum": [ + "queued", + "disabled", + "bootstrap_pending", + "policy_denied", + "credential_scope_unsupported", + "source_unavailable", + "unsampled", + "too_large", + "queue_full", + "unsupported_version", + "endpoint_unconfigured", + "scope_unresolved", + "correlation_unavailable", + "redaction_unavailable", + "recording_disabled", + "binding_pending", + "not_found", + "conflict", + "throttled", + "validation_failed", + "expired", + "deleted", + "incomplete", + "ready" + ] + }, + "SafeInteger": { + "type": "integer", + "minimum": 0, + "maximum": 9007199254740991 + }, + "Scope": { + "type": "object", + "additionalProperties": false, + "required": [ + "organization_id", + "workspace_id", + "project_id" + ], + "properties": { + "organization_id": { + "$ref": "#/$defs/UUID" + }, + "workspace_id": { + "$ref": "#/$defs/UUID" + }, + "project_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "SourceKind": { + "enum": [ + "Bytes", + "Blob", + "RemoteUrl", + "LocalFile", + "OwnedRecordingFile", + "ProviderFile" + ] + }, + "SpanID": { + "type": "string", + "pattern": "^(?!0{16}$)[0-9a-f]{16}$", + "maxLength": 16 + }, + "Status": { + "enum": [ + "pending_upload", + "importing", + "validating", + "ready", + "failed", + "rejected", + "expired", + "deleted" + ] + }, + "StatusResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload_id", + "state", + "reason" + ], + "properties": { + "upload_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "$ref": "#/$defs/Status" + }, + "reason": { + "$ref": "#/$defs/Reason" + } + } + }, + "Timestamp": { + "type": "string", + "format": "date-time", + "maxLength": 40 + }, + "Token": { + "type": "string", + "pattern": "^[a-zA-Z0-9_-]{1,128}$", + "maxLength": 128 + }, + "TraceInput": { + "type": "string", + "oneOf": [ + { + "pattern": "^(?!0{32}$)[0-9a-f]{32}$", + "maxLength": 32 + }, + { + "$ref": "#/$defs/UUID" + } + ] + }, + "UUID": { + "type": "string", + "pattern": "^(?!00000000-0000-0000-0000-000000000000$)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", + "maxLength": 36 + }, + "UploadRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "attachment_id", + "occurrence_id", + "association", + "policy_version", + "deletion_generation", + "mime_type", + "modality", + "direction", + "source_kind", + "declared_bytes" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "association": { + "$ref": "#/$defs/Association" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "mime_type": { + "$ref": "#/$defs/MIME" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "source_kind": { + "$ref": "#/$defs/SourceKind" + }, + "purpose": { + "$ref": "#/$defs/Purpose" + }, + "declared_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "message_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "part_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "segment_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "conversation_id": { + "$ref": "#/$defs/Token" + }, + "turn_id": { + "$ref": "#/$defs/Token" + }, + "tool_call_id": { + "$ref": "#/$defs/Token" + } + }, + "dependentRequired": { + "recording_id": [ + "segment_index" + ], + "segment_index": [ + "recording_id" + ] + }, + "allOf": [ + { + "if": { + "properties": { + "modality": { + "const": "audio" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "image/png", + "image/jpeg", + "image/webp" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "video" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "video/mp4", + "video/webm" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "document" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/pdf" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "file" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/octet-stream" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "declared_bytes": { + "maximum": 20971520 + } + } + } + }, + { + "if": { + "required": [ + "recording_id" + ] + }, + "then": { + "properties": { + "declared_bytes": { + "maximum": 8388608 + } + } + } + } + ] + }, + "UploadResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload_id", + "attachment_id", + "occurrence_id", + "state", + "reserved_bytes", + "expires_at", + "transfer_mode", + "write_capability" + ], + "properties": { + "upload_id": { + "$ref": "#/$defs/UUID" + }, + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "const": "pending_upload" + }, + "reserved_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "transfer_mode": { + "const": "authenticated_stream" + }, + "write_capability": { + "type": "string", + "minLength": 16, + "maxLength": 4096, + "pattern": "^[a-zA-Z0-9_.-]+$", + "description": "Secret broker-issued capability for this exact upload/occurrence; never log/export/cache this private response or reuse it for another job." + } + } + } + } +} diff --git a/python/fi_instrumentation/attachments/manager.py b/python/fi_instrumentation/attachments/manager.py new file mode 100644 index 000000000..1e6734030 --- /dev/null +++ b/python/fi_instrumentation/attachments/manager.py @@ -0,0 +1,435 @@ +"""Provider-owned, bounded, best-effort background audio transfer runtime.""" + +import asyncio +import json +import os +import random +import re +import threading +import time +import uuid +import weakref +from collections import deque +from dataclasses import dataclass, field +from typing import Mapping, Optional, Union + +from opentelemetry import trace +from opentelemetry.context import _SUPPRESS_INSTRUMENTATION_KEY, get_value +from opentelemetry.sdk.trace import SpanProcessor +from opentelemetry.trace import Span, SpanContext + +from fi_instrumentation.instrumentation.config import TraceConfig + +from .policy import AttachmentConfig, AttachmentPolicy, CapturePolicy, ServerPolicy +from .protocol import HTTPTransport, Session, TransferError, Upload +from .types import AttachmentHandle, Bytes, CorrelationHandle, FlushResult, LocalFile, ProviderFile, RemoteUrl +from .sources import OwnedRecordingFile + + +@dataclass(eq=False) +class _Job: + handle: AttachmentHandle + payload: object = field(repr=False) + request: dict + capture: CapturePolicy + epoch: int + budget: int + cancelled: bool = False + upload: Optional[Upload] = None + + +class AttachmentManager: + """One runtime per provider. No network, source reads, or threads when OFF. + + A transport double can implement bootstrap/initialize/transfer/complete/abort + for component qualification. It must honor the supplied cancellation check + before every bounded I/O chunk. This is not a durable spool. + """ + + def __init__(self, *, config: Optional[AttachmentConfig] = None, trace_config: Optional[TraceConfig] = None, + project_name: str = "", project_type: str = "observe", headers: Optional[Mapping[str, str]] = None, + transport=None): + self.config = config or AttachmentConfig() + self.policy = AttachmentPolicy(self.config, trace_config) + self._project_name, self._project_type = project_name, project_type + self._transport = transport + self._initial_status = "disabled" + if self.config.enabled: + if not project_name: + self._initial_status = "scope_unresolved" + elif transport is None: + try: + self._transport = HTTPTransport(self.config.endpoint or "", headers or {}, + timeout=self.config.request_timeout) + self._initial_status = "bootstrap_pending" + except Exception as error: + self._initial_status = error.reason if isinstance(error, TransferError) else "endpoint_unconfigured" + else: + self._initial_status = "bootstrap_pending" + self._reset() + if hasattr(os, "register_at_fork"): + ref = weakref.ref(self) + def child_reset(): + manager = ref() + if manager is not None: + manager._reset() + os.register_at_fork(after_in_child=child_reset) + self._start() + + def _reset(self) -> None: + # Never acquire inherited thread locks after fork. Child captures get a + # fresh session/nonce; parent descriptors and payloads are not replayed. + self._condition = threading.Condition() + self._queue = deque() + self._jobs = {} + self._bytes = 0 + self._dropped = 0 + self._epoch = 0 + self._stopped = False + self._threads = [] + self._session: Optional[Session] = None + self._ready = threading.Event() + self._status = self._initial_status + self.capture_session_id = str(uuid.uuid4()) + self.correlation_nonce = str(uuid.uuid4()) + + def _start(self) -> None: + with self._condition: + if self._threads or self._stopped or self._status != "bootstrap_pending": + return + for target in [self._bootstrap] + [self._worker] * self.config.workers: + worker = threading.Thread(target=target, daemon=True, name="fi-attachment") + self._threads.append(worker) + worker.start() + + def _bootstrap(self) -> None: + try: + session = self._retry(lambda: self._transport.bootstrap( + self._project_name, self._project_type, self.capture_session_id, self.correlation_nonce + )) + with self._condition: + if self._stopped: + return + self._session = session + self._status = "ready" + except Exception as error: + with self._condition: + self._status = error.reason if isinstance(error, TransferError) else "source_unavailable" + finally: + self._ready.set() + + def ready(self, timeout: float = 5) -> bool: + self._start() + if self._status == "bootstrap_pending": + self._ready.wait(max(0, min(timeout, 30))) + return self._status == "ready" and self._session is not None and self._session.expires_at > time.time() + + async def ready_async(self, timeout: float = 5) -> bool: + return await asyncio.to_thread(self.ready, timeout) + + @property + def status(self) -> str: + if self._session is not None and self._session.expires_at <= time.time(): + return "expired" + return self._status + + @property + def owned_bytes(self) -> int: + with self._condition: + return self._bytes + + def attach(self, span_or_context: Optional[Union[Span, SpanContext, CorrelationHandle]], + source: Union[Bytes, OwnedRecordingFile, LocalFile, ProviderFile, RemoteUrl], + *, mime_type: str, direction: str, purpose: Optional[str] = None, + conversation_id: Optional[str] = None, turn_id: Optional[str] = None, + tool_call_id: Optional[str] = None, message_index: Optional[int] = None, + part_index: Optional[int] = None, role: Optional[str] = None, channel: Optional[int] = None, + capture_policy: Optional[CapturePolicy] = None) -> AttachmentHandle: + """Try admission without I/O. Rejections never retain or inspect bytes.""" + try: + return self._attach(span_or_context, source, mime_type=mime_type, direction=direction, + purpose=purpose, conversation_id=conversation_id, turn_id=turn_id, + tool_call_id=tool_call_id, message_index=message_index, + part_index=part_index, role=role, channel=channel, + capture_policy=capture_policy or CapturePolicy()) + except Exception: + # Caller objects, malformed contexts, and instrumentation errors must + # not fail inference or reach a logger with their repr/exception. + return AttachmentHandle("source_unavailable") + + def _attach(self, span_or_context, source, **options) -> AttachmentHandle: + if self._status == "bootstrap_pending": + self._start() + capture = options.pop("capture_policy") + kind = type(source).__name__ + reason = self.policy.evaluate(self._session.policy if self._session else None, capture, + direction=options["direction"], mime_type=options["mime_type"], source_kind=kind) + if reason: + if reason == "bootstrap_pending" and self._status != "bootstrap_pending": + reason = self._status + return AttachmentHandle(reason) + if get_value(_SUPPRESS_INSTRUMENTATION_KEY): + return AttachmentHandle("policy_denied") + if self._stopped: + return AttachmentHandle("incomplete") + if self._session.expires_at <= time.time(): + return AttachmentHandle("expired") + # Unqualified sources cannot trigger even stat(), DNS, or a client call. + if type(source) not in (Bytes, OwnedRecordingFile): + return AttachmentHandle("source_unavailable") + span = trace.get_current_span() if span_or_context is None else span_or_context + try: + correlation = CorrelationHandle.from_span(span) + except Exception: + return AttachmentHandle("correlation_unavailable") + if not correlation.sampled: + return AttachmentHandle("unsampled") + metadata = self._metadata(options) + owned_file = type(source) is OwnedRecordingFile + data = source if owned_file else source.data + if not owned_file and type(data) not in (bytes, bytearray, memoryview): + return AttachmentHandle("source_unavailable") + # Export the mutable buffer only after policy admission. A memoryview + # pins its size, preventing a concurrent resize between budget and copy. + if type(data) is bytearray: + data = memoryview(data) + length = source.size if owned_file else (data.nbytes if type(data) is memoryview else len(data)) + if type(length) is not int or length <= 0 or length > min(self.config.max_attachment_bytes, self._session.max_upload_bytes): + return AttachmentHandle("too_large") + # A mutable buffer may only be copied in bounded callback-sized chunks. + if not owned_file and type(data) is not bytes and length > self.config.chunk_bytes: + return AttachmentHandle("too_large") + budget = self.config.chunk_bytes if owned_file else length + self._condition.acquire() + try: + if self._stopped: + return AttachmentHandle("incomplete") + reason = self.policy.evaluate(self._session.policy, capture, direction=options["direction"], + mime_type=options["mime_type"], source_kind=kind) + if reason: + return AttachmentHandle(reason) + if len(self._jobs) >= self.config.max_descriptors or self._bytes + budget > self.config.max_owned_bytes: + return AttachmentHandle("queue_full") + handle = AttachmentHandle("queued") + request = { + "schema_version": 1, "attachment_id": handle.attachment_id, + "occurrence_id": handle.occurrence_id, + "association": {"capture_session_id": self.capture_session_id, + "correlation_nonce": self.correlation_nonce, + "parent": {"trace_id": correlation.trace_uuid, "span_id": correlation.span_id}}, + "policy_version": self._session.policy.version, + "deletion_generation": self._session.policy.deletion_generation, + "source_kind": kind, "modality": "audio", "declared_bytes": length, + **{k: v for k, v in metadata.items() if k not in ("role", "channel")}, + } + payload = data if owned_file or type(data) is bytes else bytes(data) + job = _Job(handle, payload, request, capture, self._epoch, budget) + self._bytes += budget + self._jobs[handle.occurrence_id] = job + self._queue.append(job) + self._project_reference(span, handle, metadata) + self._condition.notify_all() + return handle + finally: + self._condition.release() + + @staticmethod + def _metadata(options: dict) -> dict: + result = {"mime_type": options["mime_type"], "direction": options["direction"]} + enums = {"purpose": ("conversation_recording", "turn_recording", "model_input", "model_output", "tool_result", "diagnostic"), + "role": ("user", "assistant", "tool", "system", "unknown")} + for key, allowed in enums.items(): + if options[key] is not None: + if options[key] not in allowed: + raise ValueError("invalid attachment classification") + result[key] = options[key] + for key in ("message_index", "part_index", "channel"): + value = options[key] + if value is not None: + if type(value) is not int or not 0 <= value <= (31 if key == "channel" else 65535): + raise ValueError("invalid attachment index") + result[key] = value + for key in ("conversation_id", "turn_id", "tool_call_id"): + value = options[key] + if value is not None: + if not isinstance(value, str) or not re.fullmatch(r"[a-zA-Z0-9_-]{1,128}", value): + raise ValueError("invalid opaque correlation") + result[key] = value + return result + + def _project_reference(self, span, handle, metadata) -> None: + # Only live spans are projected. Authoritative occurrence binding is out + # of band; upload completion must never mutate an ended span. + try: + if not span.is_recording(): + return + attrs = getattr(span, "attributes", None) or {} + raw = attrs.get("fi.attachment.refs", "[]") + if not isinstance(raw, str) or len(raw) > 16384: + return + references = json.loads(raw) + if not isinstance(references, list) or len(references) >= 64: + return + ref = {k: v for k, v in metadata.items() if k not in ("conversation_id", "turn_id", "tool_call_id")} + ref.update(attachment_id=handle.attachment_id, occurrence_id=handle.occurrence_id, modality="audio") + encoded = json.dumps([*references, ref], separators=(",", ":")) + if len(encoded.encode()) <= 16384: + span.set_attribute("fi.attachment.schema_version", 1) + span.set_attribute("fi.attachment.capture_session_id", self.capture_session_id) + span.set_attribute("fi.attachment.correlation_nonce", self.correlation_nonce) + span.set_attribute("fi.attachment.refs", encoded) + except Exception: + pass + + def _check(self, job: _Job) -> None: + if self._stopped or job.cancelled: + raise TransferError("incomplete") + if job.epoch != self._epoch: + raise TransferError("policy_denied") + session = self._session + if session is None or session.expires_at <= time.time() or job.upload is not None and job.upload.expires_at <= time.time(): + raise TransferError("expired") + reason = self.policy.evaluate(session.policy, job.capture, direction=job.request["direction"], + mime_type=job.request["mime_type"], source_kind=job.request["source_kind"]) + if reason: + raise TransferError(reason) + + def _retry(self, operation, check=lambda: None): + for attempt in range(3): + check() + try: + return operation() + except TransferError as error: + if not error.retryable or attempt == 2: + raise + delay = max(error.retry_after, random.uniform(0.02, 0.08) * (2 ** attempt)) + with self._condition: + if self._stopped: + raise TransferError("incomplete") from None + self._condition.wait(timeout=delay) + + def _worker(self) -> None: + while True: + with self._condition: + while not self._queue and not self._stopped: + self._condition.wait() + if self._stopped: + return + job = self._queue.popleft() + status = "incomplete" + lease = None + try: + check = lambda: self._check(job) + check() + session = self._session + payload = job.payload + if type(payload) is OwnedRecordingFile: + lease = payload._open() + payload = lease + check() + job.upload = self._retry(lambda: self._transport.initialize(session, job.request, check), check) + self._retry(lambda: self._transport.transfer(session, job.upload, payload, check, self.config.chunk_bytes), check) + if lease is not None: + lease.check() + self._retry(lambda: self._transport.complete(session, job.upload, check), check) + status = "validating" + except Exception as error: + status = error.reason if isinstance(error, TransferError) else "incomplete" + if job.upload is not None: + try: + self._transport.abort(self._session, job.upload) + except Exception: + pass + finally: + payload = None + if lease is not None: + lease.close() + with self._condition: + self._release(job, status) + self._condition.notify_all() + + def _release(self, job: _Job, status: str) -> None: + if self._jobs.pop(job.handle.occurrence_id, None) is not None: + self._bytes -= job.budget + job.payload = b"" + job.request = {} + job.upload = None + if status != "validating": + self._dropped += 1 + job.handle._finish(status) + + def update_policy(self, server: ServerPolicy) -> None: + """Invalidate all admitted work, including an active transfer/retry. + + Only the control-plane owner should call this with a negotiated policy. + No queued data survives re-enablement. In-flight I/O checks before the + next bounded chunk; already sent bytes cannot be recalled locally. + """ + with self._condition: + self._epoch += 1 + if self._session is not None: + old = self._session + self._session = Session(old.project_id, old.capture_session_id, server, old.expires_at, old.max_upload_bytes) + while self._queue: + self._release(self._queue.popleft(), "policy_denied") + self._condition.notify_all() + + def cancel(self, handle: AttachmentHandle) -> None: + with self._condition: + job = self._jobs.get(handle.occurrence_id) + if job: + job.cancelled = True + if job in self._queue: + self._queue.remove(job) + self._release(job, "incomplete") + self._condition.notify_all() + + def flush(self, timeout: float = 5) -> FlushResult: + deadline = time.monotonic() + max(0, min(timeout, 30)) + with self._condition: + while self._jobs and time.monotonic() < deadline: + self._condition.wait(timeout=deadline - time.monotonic()) + return FlushResult(len(self._jobs), self._dropped) + + async def flush_async(self, timeout: float = 5) -> FlushResult: + return await asyncio.to_thread(self.flush, timeout) + + def shutdown(self, timeout: Optional[float] = None) -> FlushResult: + with self._condition: + if self._stopped: + return FlushResult(len(self._jobs), self._dropped) + deadline = time.monotonic() + (self.config.shutdown_timeout if timeout is None else max(0, min(timeout, 30))) + self.flush(max(0, deadline - time.monotonic())) + with self._condition: + self._stopped = True + self._status = "incomplete" + while self._queue: + self._release(self._queue.popleft(), "incomplete") + self._condition.notify_all() + for worker in self._threads: + if worker is not threading.current_thread(): + worker.join(max(0, deadline - time.monotonic())) + with self._condition: + return FlushResult(len(self._jobs), self._dropped) + + +class AttachmentSpanProcessor(SpanProcessor): + """Publish the non-secret writer correlation carrier before span export.""" + + def __init__(self, manager: AttachmentManager): + self.manager = manager + + def on_start(self, span, parent_context=None): + if self.manager.config.enabled and span.is_recording(): + span.set_attribute("fi.attachment.capture_session_id", self.manager.capture_session_id) + span.set_attribute("fi.attachment.correlation_nonce", self.manager.correlation_nonce) + + def on_end(self, span): + pass + + def force_flush(self, timeout_millis: int = 5000) -> bool: + return self.manager.flush(min(timeout_millis / 1000, 5)).unfinished == 0 + + def shutdown(self): + # The FI provider already gave force_flush its 5-second deadline. + self.manager.shutdown(0) diff --git a/python/fi_instrumentation/attachments/policy.py b/python/fi_instrumentation/attachments/policy.py new file mode 100644 index 000000000..75fa30539 --- /dev/null +++ b/python/fi_instrumentation/attachments/policy.py @@ -0,0 +1,160 @@ +"""Attachment admission is independent of span masking and always deny-wins. + +This module never inspects a source. In particular, text PII redaction does not +claim to sanitize audio. Server-side validation is not pre-egress redaction. +""" + +import os +from dataclasses import dataclass, field +from typing import Optional + +from fi_instrumentation.instrumentation.config import TraceConfig + + +def _flag(name: str, default: bool = False) -> bool: + value = os.getenv(name) + if value is None: + return default + return value.strip().lower() in ("true", "1", "yes") + + +def _restriction(name: str) -> bool: + # Invalid hide/PII configuration is a restriction, never permission. + value = os.getenv(name) + return value is not None and value.strip().lower() not in ("false", "0", "no") + + +@dataclass(frozen=True) +class AttachmentConfig: + enabled: Optional[bool] = None + record_audio: Optional[bool] = None + record_video: Optional[bool] = None + allow_unredacted_media_with_text_pii: Optional[bool] = None + endpoint: Optional[str] = field(default=None, repr=False) + max_descriptors: int = 128 + max_owned_bytes: int = 32 * 1024 * 1024 + max_attachment_bytes: int = 8 * 1024 * 1024 + workers: int = 2 + chunk_bytes: int = 256 * 1024 + request_timeout: float = 2.0 + shutdown_timeout: float = 5.0 + + def __post_init__(self) -> None: + for name in ("enabled", "record_audio", "record_video", "allow_unredacted_media_with_text_pii"): + value = getattr(self, name) + if value is None: + object.__setattr__(self, name, _flag("FI_ATTACHMENTS_" + name.upper())) + elif type(value) is not bool: + raise ValueError("attachment flags must be booleans") + if self.endpoint is None: + object.__setattr__(self, "endpoint", os.getenv("FI_ATTACHMENTS_ENDPOINT")) + for name, ceiling in (("max_descriptors", 128), ("max_owned_bytes", 32 * 1024 * 1024), + ("max_attachment_bytes", 8 * 1024 * 1024), ("workers", 2), + ("chunk_bytes", 256 * 1024)): + value = getattr(self, name) + if type(value) is not int or not 0 < value <= ceiling: + raise ValueError("invalid attachment resource bound") + for value in (self.request_timeout, self.shutdown_timeout): + if not isinstance(value, (int, float)) or not 0 < value <= 30: + raise ValueError("invalid attachment deadline") + + +@dataclass(frozen=True) +class ServerPolicy: + """Negotiated policy; unknown policy is never permissive.""" + + enabled: bool = False + credential_write: bool = False + allowed_sources: frozenset[str] = frozenset() + allowed_directions: frozenset[str] = frozenset() + require_media_redaction: bool = True + require_metadata_removal: bool = True + allow_unredacted_media_with_text_pii: bool = False + record_audio: bool = False + version: str = "" + deletion_generation: int = 0 + + +@dataclass(frozen=True) +class CapturePolicy: + """Adapter provenance, intersected with every other policy layer. + + Adapters must preserve model-input ancestry even for tool outputs. Unknown + direction is treated as mixed; a caller cannot relabel a mixed recording. + No qualified local audio sanitizer is installed by this runtime. + """ + + capture_content: bool = True + record_inputs: bool = True + record_outputs: bool = True + muted: bool = False + temporary_chat: bool = False + requested: bool = True + model_input: bool = False + contains_input: bool = False + contains_output: bool = False + error_detail: bool = False + new_recording: bool = False + + + def __post_init__(self) -> None: + if any(type(value) is not bool for value in vars(self).values()): + raise ValueError("capture policy facts must be booleans") + + +class AttachmentPolicy: + def __init__(self, config: AttachmentConfig, trace_config: Optional[TraceConfig] = None): + self.config = config + self.trace_config = trace_config or TraceConfig() + + def evaluate(self, server: Optional[ServerPolicy], capture: CapturePolicy, *, + direction: str, mime_type: str, source_kind: str) -> Optional[str]: + if not self.config.enabled: + return "disabled" + # An explicit environment disable cannot be overridden by a call/config. + if os.getenv("FI_ATTACHMENTS_ENABLED") is not None and not _flag("FI_ATTACHMENTS_ENABLED"): + return "disabled" + if server is None: + return "bootstrap_pending" + if not server.enabled: + return "policy_denied" + if not server.credential_write: + return "credential_scope_unsupported" + if not capture.capture_content or capture.muted or capture.temporary_chat or not capture.requested: + return "policy_denied" + inputs = direction in ("input", "mixed") or capture.contains_input or capture.model_input + outputs = direction in ("output", "mixed") or capture.contains_output + if direction not in ("input", "output", "mixed"): + return "policy_denied" + if inputs and not capture.record_inputs or outputs and not capture.record_outputs: + return "policy_denied" + + def hidden(name: str) -> bool: + return bool(getattr(self.trace_config, name)) or _restriction("FI_" + name.upper()) + + if inputs and any(hidden(n) for n in ("hide_inputs", "hide_input_messages", "hide_input_text")): + return "policy_denied" + if outputs and any(hidden(n) for n in ("hide_outputs", "hide_output_messages", "hide_output_text")): + return "policy_denied" + if inputs and mime_type.startswith("image/") and hidden("hide_input_images"): + return "policy_denied" + if capture.error_detail and hidden("hide_error_details"): + return "policy_denied" + if server.require_media_redaction or server.require_metadata_removal: + return "redaction_unavailable" + if hidden("pii_redaction") and not ( + self.config.allow_unredacted_media_with_text_pii + and server.allow_unredacted_media_with_text_pii + ): + return "redaction_unavailable" + if direction not in server.allowed_directions or source_kind not in server.allowed_sources: + return "policy_denied" + record_audio = self.config.record_audio and server.record_audio + if os.getenv("FI_ATTACHMENTS_RECORD_AUDIO") is not None: + record_audio = record_audio and _flag("FI_ATTACHMENTS_RECORD_AUDIO") + if capture.new_recording and not record_audio: + return "recording_disabled" + # Wave A is audio only. Other modalities remain explicitly unsupported. + if mime_type not in ("audio/wav", "audio/L16", "audio/flac", "audio/mpeg", "audio/ogg", "audio/mp4", "audio/webm"): + return "source_unavailable" + return None diff --git a/python/fi_instrumentation/attachments/protocol.py b/python/fi_instrumentation/attachments/protocol.py new file mode 100644 index 000000000..02f7c720f --- /dev/null +++ b/python/fi_instrumentation/attachments/protocol.py @@ -0,0 +1,282 @@ +"""Versioned fi.attachments.v1 adapter. No storage/source URLs are followed. + +Only a separately configured HTTPS control origin is used. This adapter uses no +ambient proxies, cookies, netrc, redirects, or instrumentation. Server validation +and occurrence binding remain prerequisites for playback; a completed transfer +is only `validating`. +""" + +import http.client +import json +import re +import ssl +import time +import uuid +from functools import lru_cache +from pathlib import Path + +from jsonschema import Draft202012Validator, FormatChecker +from dataclasses import dataclass, field +from datetime import datetime +from typing import Callable, Mapping, Optional +from urllib.parse import urlsplit + +from fi_instrumentation.instrumentation.config import suppress_tracing + +from .policy import ServerPolicy + + +class TransferError(Exception): + def __init__(self, reason: str, retryable: bool = False, retry_after: float = 0): + # Never preserve a server body, URL, token, or originating exception. + safe_reasons = {"disabled", "bootstrap_pending", "policy_denied", "credential_scope_unsupported", + "source_unavailable", "unsupported_version", "endpoint_unconfigured", "scope_unresolved", + "redaction_unavailable", "recording_disabled", "expired", "deleted", "incomplete", + "too_large", "throttled", "conflict", "validation_failed"} + reason = reason if reason in safe_reasons else "incomplete" + super().__init__(reason) + self.reason = reason + self.retryable = retryable + self.retry_after = min(max(retry_after, 0), 2) + + +@dataclass(frozen=True) +class Session: + project_id: str + capture_session_id: str + policy: ServerPolicy + expires_at: float + max_upload_bytes: int + + +@dataclass(frozen=True) +class Upload: + upload_id: str + expires_at: float + capability: str = field(default="", repr=False) + + +def _uuid(value) -> str: + if not isinstance(value, str) or not re.fullmatch(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", value) or not uuid.UUID(value).int: + raise TransferError("unsupported_version") + return value + + +def _expiry(value) -> float: + if not isinstance(value, str) or len(value) > 40: + raise TransferError("unsupported_version") + try: + date = datetime.fromisoformat(value.replace("Z", "+00:00")) + if date.tzinfo is None: + raise ValueError() + timestamp = date.timestamp() + except (ValueError, OverflowError): + raise TransferError("unsupported_version") from None + if timestamp <= time.time(): + raise TransferError("expired") + return timestamp + + +@lru_cache(maxsize=6) +def _validator(name: str): + schema = json.loads(Path(__file__).with_name("_protocol_schema.json").read_text()) + return Draft202012Validator({**schema, "$ref": "#/$defs/" + name}, format_checker=FormatChecker()) + + +def _validate(name: str, value: dict) -> None: + if not _validator(name).is_valid(value): + raise TransferError("unsupported_version") + + +def _object(pairs): + result = {} + for key, value in pairs: + if key in result: + raise TransferError("unsupported_version") + result[key] = value + return result + + +class HTTPTransport: + """Trusted control-plane transport, not a generic media fetch client.""" + + def __init__(self, endpoint: str, headers: Mapping[str, str], *, timeout: float = 2, + ssl_context: Optional[ssl.SSLContext] = None): + parsed = urlsplit(endpoint) + if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.path not in ("", "/"): + raise TransferError("endpoint_unconfigured") + self._host, self._port = parsed.hostname, parsed.port or 443 + self._timeout, self._ssl_context = timeout, ssl_context + self._headers = {k.lower(): v for k, v in headers.items() + if k.lower() in ("authorization", "x-api-key", "x-secret-key")} + if not self._headers: + raise TransferError("credential_scope_unsupported") + + def _request(self, method: str, path: str, *, body=None, payload=None, + capability: str = "", check: Callable[[], None] = lambda: None, + chunk_bytes: int = 256 * 1024): + check() + connection = http.client.HTTPSConnection(self._host, self._port, + timeout=self._timeout, context=self._ssl_context) + headers = dict(self._headers) + if capability: + headers = {"authorization": "Bearer " + capability} + data = json.dumps(body, separators=(",", ":")).encode() if body is not None else b"" + headers["Content-Type"] = "application/json" if payload is None else "application/octet-stream" + headers["Content-Length"] = str(len(data) if payload is None else len(payload)) + deadline = time.monotonic() + self._timeout + try: + with suppress_tracing(): + connection.putrequest(method, path) + for key, value in headers.items(): + connection.putheader(key, value) + connection.endheaders() + # FileLease has an independent bounded pread reader; it never + # advances the application's file position or materializes a file. + source = data if payload is None else payload + for offset in range(0, len(source), chunk_bytes): + check() + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete", True) + if connection.sock: + connection.sock.settimeout(min(remaining, self._timeout)) + if isinstance(source, bytes): + chunk = memoryview(source)[offset:offset + chunk_bytes] + else: + chunk = source.read(offset, min(chunk_bytes, len(source) - offset)) + if len(chunk) != min(chunk_bytes, len(source) - offset): + raise TransferError("source_unavailable") + check() + connection.send(chunk) + del chunk + if not isinstance(source, bytes): + source.check() + check() + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete", True) + if connection.sock: + connection.sock.settimeout(remaining) + response = connection.getresponse() + if response.status not in (200, 201, 202, 204): + retry = response.status in (408, 429, 500, 502, 503, 504) + reason = {401: "credential_scope_unsupported", 403: "policy_denied", + 404: "source_unavailable", 409: "conflict", 410: "expired", + 413: "too_large", 429: "throttled"}.get(response.status, "incomplete") + retry_after = response.getheader("Retry-After", "0") + try: + retry_after = float(retry_after) + except ValueError: + retry_after = 0 + raise TransferError(reason, retry, retry_after) + # Bound responses and wall time even for a trickling server. + parts, size = [], 0 + while True: + check() + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete", True) + if connection.sock: + connection.sock.settimeout(remaining) + part = response.read1(min(4096, 65537 - size)) + if not part: + break + parts.append(part) + size += len(part) + if size > 65536: + raise TransferError("unsupported_version") + value = json.loads(b"".join(parts), object_pairs_hook=_object) if size else {} + if not isinstance(value, dict): + raise TransferError("unsupported_version") + return value + except TransferError: + raise + except (OSError, http.client.HTTPException): + raise TransferError("incomplete", True) from None + except Exception: + raise TransferError("unsupported_version") from None + finally: + connection.close() + + def bootstrap(self, project_name: str, project_type: str, capture_session_id: str, + correlation_nonce: str) -> Session: + result = self._request("POST", "/tracer/v1/attachment-sessions", body={ + "schema_versions": [1], "project_name": project_name, "project_type": project_type, + "capture_session_id": capture_session_id, "correlation_nonce": correlation_nonce, + }) + _validate("BootstrapResponse", result) + try: + if result["schema_version"] != 1 or result["transfer_modes"] != ["authenticated_stream"] or result["capture_session_id"] != capture_session_id: + raise TransferError("unsupported_version") + scope, policy, limits = result["scope"], result["policy"], result["limits"] + for name in ("organization_id", "workspace_id", "project_id"): + _uuid(scope[name]) + for name in ("enabled", "require_media_redaction", "require_metadata_removal", + "allow_unredacted_media_with_text_pii", "record_audio", "record_video"): + if type(policy[name]) is not bool: + raise TransferError("unsupported_version") + if not re.fullmatch(r"[a-zA-Z0-9_-]{1,128}", policy["version"]): + raise TransferError("unsupported_version") + for name in ("allowed_sources", "allowed_modalities"): + if not isinstance(policy[name], list) or len(policy[name]) > 6 or not all(isinstance(v, str) for v in policy[name]): + raise TransferError("unsupported_version") + for name, value in limits.items(): + if type(value) is not int or not 0 < value <= 1073741824: + raise TransferError("unsupported_version") + maximum = limits["max_upload_bytes"] + if maximum > 50 * 1024 * 1024: + raise TransferError("unsupported_version") + server = ServerPolicy( + enabled=policy["enabled"] and "audio" in policy["allowed_modalities"], + credential_write=True, allowed_sources=frozenset(policy["allowed_sources"]), + allowed_directions=frozenset(("input", "output", "mixed")), + require_media_redaction=policy["require_media_redaction"], + require_metadata_removal=policy["require_metadata_removal"], + allow_unredacted_media_with_text_pii=policy["allow_unredacted_media_with_text_pii"], + record_audio=policy["record_audio"], version=policy["version"], + ) + return Session(scope["project_id"], capture_session_id, server, + _expiry(result["expires_at"]), maximum) + except TransferError: + raise + except Exception: + raise TransferError("unsupported_version") from None + + @staticmethod + def _base(session: Session) -> str: + return "/tracer/v1/projects/" + _uuid(session.project_id) + "/attachments/uploads" + + def initialize(self, session: Session, request: dict, check: Callable[[], None]) -> Upload: + _validate("UploadRequest", request) + result = self._request("POST", self._base(session), body=request, check=check) + _validate("UploadResponse", result) + try: + if (result["attachment_id"] != request["attachment_id"] or + result["occurrence_id"] != request["occurrence_id"] or + result["reserved_bytes"] != request["declared_bytes"] or + result["state"] != "pending_upload" or result["transfer_mode"] != "authenticated_stream"): + raise TransferError("unsupported_version") + return Upload(_uuid(result["upload_id"]), _expiry(result["expires_at"]), result["write_capability"]) + except TransferError: + raise + except Exception: + raise TransferError("unsupported_version") from None + + def transfer(self, session: Session, upload: Upload, payload: bytes, + check: Callable[[], None], chunk_bytes: int) -> None: + self._request("PUT", self._base(session) + "/" + upload.upload_id + "/content", + payload=payload, capability=upload.capability, check=check, chunk_bytes=chunk_bytes) + + def complete(self, session: Session, upload: Upload, check: Callable[[], None]) -> None: + result = self._request("POST", self._base(session) + "/" + upload.upload_id + "/complete", + body={"policy_version": session.policy.version, + "deletion_generation": session.policy.deletion_generation}, + capability=upload.capability, check=check) + _validate("StatusResponse", result) + if result.get("state") not in ("validating", "ready") or result.get("upload_id") != upload.upload_id: + raise TransferError("unsupported_version") + + def abort(self, session: Session, upload: Upload) -> None: + self._request("POST", self._base(session) + "/" + upload.upload_id + "/abort", + body={}, capability=upload.capability) diff --git a/python/fi_instrumentation/attachments/sources.py b/python/fi_instrumentation/attachments/sources.py new file mode 100644 index 000000000..52be71254 --- /dev/null +++ b/python/fi_instrumentation/attachments/sources.py @@ -0,0 +1,128 @@ +"""Explicit session-owned file leases. Arbitrary LocalFile remains disabled. + +Bind a trusted session root during application setup/finalization, not an audio +callback. Report paths are never authority. All traversal uses no-follow directory +FDs, regular files only, and an expected identity supplied by the owning session. +""" + +import os +import stat +import threading +from dataclasses import dataclass, field + +from .protocol import TransferError + + +class RecordingFileScope: + """An explicit read permission for files owned by one bound SDK session. + + The binding adapter owns closing this scope, after its transfer/finalization + deadline. Creating this permission does not start a recorder. + """ + + def __init__(self, root: str, *, enabled: bool = False): + self._fd = -1 + self._pid = os.getpid() + self._lock = threading.Lock() + if not enabled: + raise ValueError("owned recording files require explicit permission") + if not os.path.isabs(root) or not hasattr(os, "O_NOFOLLOW"): + raise ValueError("unsupported recording root") + fd = os.open("/", os.O_RDONLY | os.O_DIRECTORY) + try: + for part in root.split("/"): + if not part: + continue + if part in (".", ".."): + raise ValueError("invalid recording root") + next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd) + os.close(fd) + fd = next_fd + self._fd = fd + except Exception: + os.close(fd) + raise ValueError("recording root unavailable") from None + + def source(self, relative_path: str, *, device: int, inode: int, size: int) -> "OwnedRecordingFile": + # No file operations here. The adapter must obtain identity from the + # actual owned file, not trust an arbitrary report/tool-supplied path. + if not isinstance(relative_path, str) or len(relative_path) > 4096: + raise ValueError("invalid owned recording path") + parts = relative_path.split("/") + if not parts or any(part in ("", ".", "..") for part in parts) or len(parts) > 32: + raise ValueError("invalid owned recording path") + if any(type(v) is not int or v < 0 for v in (device, inode, size)): + raise ValueError("invalid owned recording identity") + return OwnedRecordingFile(self, tuple(parts), device, inode, size) + + def _open(self, source: "OwnedRecordingFile") -> "FileLease": + if os.getpid() != self._pid: + raise TransferError("source_unavailable") + with self._lock: + if self._fd < 0: + raise TransferError("source_unavailable") + fd = os.dup(self._fd) + try: + for part in source._parts[:-1]: + next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd) + os.close(fd) + fd = next_fd + file_fd = os.open(source._parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=fd) + try: + info = os.fstat(file_fd) + if not stat.S_ISREG(info.st_mode) or (info.st_dev, info.st_ino, info.st_size) != (source.device, source.inode, source.size): + raise TransferError("source_unavailable") + return FileLease(file_fd, info) + except Exception: + os.close(file_fd) + raise + except Exception: + raise TransferError("source_unavailable") from None + finally: + os.close(fd) + + def close(self) -> None: + if os.getpid() != self._pid: + if self._fd >= 0: + os.close(self._fd) + self._fd = -1 + return + with self._lock: + if self._fd >= 0: + os.close(self._fd) + self._fd = -1 + + +@dataclass(frozen=True) +class OwnedRecordingFile: + _scope: RecordingFileScope = field(repr=False) + _parts: tuple = field(repr=False) + device: int = field(repr=False) + inode: int = field(repr=False) + size: int = field(repr=False) + + def _open(self) -> "FileLease": + return self._scope._open(self) + + +class FileLease: + def __init__(self, fd: int, info): + self._fd, self._info = fd, info + + def __len__(self): + return self._info.st_size + + def read(self, offset: int, size: int) -> bytes: + self.check() + return os.pread(self._fd, size, offset) + + def check(self) -> None: + info = os.fstat(self._fd) + original = self._info + if (info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns, info.st_ctime_ns) != ( + original.st_dev, original.st_ino, original.st_size, original.st_mtime_ns, original.st_ctime_ns + ): + raise TransferError("source_unavailable") + + def close(self) -> None: + os.close(self._fd) diff --git a/python/fi_instrumentation/attachments/types.py b/python/fi_instrumentation/attachments/types.py new file mode 100644 index 000000000..4f045eee7 --- /dev/null +++ b/python/fi_instrumentation/attachments/types.py @@ -0,0 +1,130 @@ +"""Content-free handles and typed attachment sources (no implicit reads).""" + +import asyncio +import re +import threading +import uuid +from dataclasses import dataclass, field +from typing import Optional, Union + +from opentelemetry import trace +from opentelemetry.trace import SpanContext + + +@dataclass(frozen=True) +class Bytes: + data: Union[bytes, bytearray, memoryview] = field(repr=False) + + +@dataclass(frozen=True) +class RemoteUrl: + url: str = field(repr=False) + + +@dataclass(frozen=True) +class LocalFile: + path: str = field(repr=False) + + +@dataclass(frozen=True) +class ProviderFile: + provider: str + file_id: str = field(repr=False) + + +@dataclass(frozen=True) +class CorrelationHandle: + """Snapshot of an actual emitted identity, usable after the span ends. + + Capture this while the span is recording. No subsequent ambient span lookup + occurs. A sampled SpanContext is also accepted; the server still has to bind + the association to this writer before anything becomes readable. + """ + + trace_id: str + span_id: str + sampled: bool + + def __post_init__(self) -> None: + value = self.trace_id + if not isinstance(value, str) or not re.fullmatch( + r"[0-9a-f]{32}|[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", value + ): + raise ValueError("invalid trace identity") + canonical = uuid.UUID(value) + if not canonical.int or not isinstance(self.span_id, str) or not re.fullmatch(r"[0-9a-f]{16}", self.span_id) or not int(self.span_id, 16): + raise ValueError("invalid correlation identity") + if type(self.sampled) is not bool: + raise ValueError("invalid sampling decision") + object.__setattr__(self, "trace_id", canonical.hex) + + @property + def trace_uuid(self) -> str: + return str(uuid.UUID(self.trace_id)) + + @classmethod + def from_span(cls, span_or_context=None) -> "CorrelationHandle": + if isinstance(span_or_context, cls): + return span_or_context + span = trace.get_current_span() if span_or_context is None else span_or_context + if isinstance(span, SpanContext): + context, recording = span, True + else: + context, recording = span.get_span_context(), span.is_recording() + if not context.is_valid: + raise ValueError("correlation unavailable") + return cls(format(context.trace_id, "032x"), format(context.span_id, "016x"), + bool(context.trace_flags.sampled and recording)) + + +@dataclass(frozen=True) +class Completion: + status: str + # "validating" is transfer completion, not a storage/readiness claim. + + +class AttachmentHandle: + """Stable public IDs, local admission, and non-throwing completion. + + Neither source nor exception is stored here. Denied IDs are not resolvable + references and must not be projected onto spans or diagnostics. + """ + + def __init__(self, admission: str): + self._attachment_id = str(uuid.uuid4()) + self._occurrence_id = str(uuid.uuid4()) + self._admission = admission + self._event = threading.Event() + self._completion: Optional[Completion] = None + if admission != "queued": + self._finish(admission) + + @property + def attachment_id(self) -> str: + return self._attachment_id + + @property + def occurrence_id(self) -> str: + return self._occurrence_id + + @property + def admission(self) -> str: + return self._admission + + def _finish(self, status: str) -> None: + if not self._event.is_set(): + self._completion = Completion(status) + self._event.set() + + def result(self, timeout: float = 0) -> Completion: + self._event.wait(max(0, min(timeout, 30))) + return self._completion or Completion("unfinished") + + async def wait(self, timeout: float = 5) -> Completion: + return await asyncio.to_thread(self.result, timeout) + + +@dataclass(frozen=True) +class FlushResult: + unfinished: int + dropped: int diff --git a/python/fi_instrumentation/otel.py b/python/fi_instrumentation/otel.py index 7e4f5b2b3..a768ea5e0 100644 --- a/python/fi_instrumentation/otel.py +++ b/python/fi_instrumentation/otel.py @@ -8,9 +8,13 @@ import uuid import warnings from enum import Enum -from typing import Any, Dict, List, Mapping, Optional, Tuple, Type, Union +from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Tuple, Type, Union from urllib.parse import ParseResult, urlparse +if TYPE_CHECKING: + from fi_instrumentation.attachments import AttachmentConfig + from fi_instrumentation.instrumentation.config import TraceConfig + import requests from fi_instrumentation.fi_types import ( EvalName, @@ -113,6 +117,8 @@ def register( timeout: Optional[float] = None, sampler: Optional[Sampler] = None, span_limits: Optional[SpanLimits] = None, + attachment_config: Optional["AttachmentConfig"] = None, + trace_config: Optional["TraceConfig"] = None, ) -> _TracerProvider: """Configure and return a Future AGI `TracerProvider`. @@ -248,6 +254,20 @@ def register( # default: a later add_span_processor() call adds next to it, as in upstream OpenTelemetry. tracer_provider.add_span_processor(span_processor) + # Attachment control-plane configuration is independent of OTLP. OFF does + # not construct a transport, start workers, or make any bootstrap request. + from fi_instrumentation.attachments import AttachmentManager, AttachmentSpanProcessor + from fi_instrumentation.instrumentation.config import TraceConfig + + tracer_provider.trace_config = trace_config or TraceConfig() + tracer_provider.attachment_manager = AttachmentManager( + config=attachment_config, trace_config=tracer_provider.trace_config, + project_name=project_name, project_type=project_type.value, + headers=_with_fi_auth_headers(headers), + ) + if tracer_provider.attachment_manager.config.enabled: + tracer_provider.add_span_processor(AttachmentSpanProcessor(tracer_provider.attachment_manager)) + if set_global_tracer_provider: trace_api.set_tracer_provider(tracer_provider) global_provider_msg = ( diff --git a/python/tests/attachments/conftest.py b/python/tests/attachments/conftest.py new file mode 100644 index 000000000..2b4b12c5f --- /dev/null +++ b/python/tests/attachments/conftest.py @@ -0,0 +1,71 @@ +import os +import threading +import time +import uuid +from dataclasses import replace + +import pytest +from fi_instrumentation.attachments import AttachmentConfig, AttachmentManager, ServerPolicy +from fi_instrumentation.attachments.protocol import Session, Upload + + +@pytest.fixture(autouse=True) +def clean_attachment_env(monkeypatch): + for key in list(os.environ): + if key.startswith(("FI_ATTACHMENTS_", "FI_HIDE_")) or key == "FI_PII_REDACTION": + monkeypatch.delenv(key, raising=False) + + +class TransportDouble: + def __init__(self, policy=None): + self.policy = policy or ServerPolicy( + enabled=True, credential_write=True, allowed_sources=frozenset(("Bytes", "OwnedRecordingFile")), + allowed_directions=frozenset(("input", "output", "mixed")), require_media_redaction=False, + require_metadata_removal=False, version="v1") + self.requests, self.payloads, self.aborts = [], [], [] + self.entered = threading.Event() + self.release = threading.Event() + self.release.set() + self.failures = [] + self.calls = 0 + self.bootstraps = 0 + + def bootstrap(self, project_name, project_type, session_id, nonce): + self.bootstraps += 1 + return Session(str(uuid.uuid4()), session_id, self.policy, time.time() + 60, 8 * 1024 * 1024) + + def initialize(self, session, request, check): + check() + self.requests.append(dict(request)) + return Upload(str(uuid.uuid4()), time.time() + 60) + + def transfer(self, session, upload, payload, check, chunk_bytes): + self.calls += 1 + self.entered.set() + assert self.release.wait(5) + check() + if self.failures: + raise self.failures.pop(0) + if not isinstance(payload, bytes): + payload = payload.read(0, len(payload)) + self.payloads.append(payload) + + def complete(self, session, upload, check): + check() + + def abort(self, session, upload): + self.aborts.append(upload.upload_id) + + +@pytest.fixture +def transport(): + return TransportDouble() + + +@pytest.fixture +def manager(transport): + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + assert manager.ready(2) + yield manager + transport.release.set() + manager.shutdown(2) diff --git a/python/tests/attachments/test_http_contract.py b/python/tests/attachments/test_http_contract.py new file mode 100644 index 000000000..d5c7ab778 --- /dev/null +++ b/python/tests/attachments/test_http_contract.py @@ -0,0 +1,179 @@ +"""Actual TLS loopback transfers; only synthetic credentials and audio.""" + +import io +import json +import ssl +import subprocess +import threading +import uuid +import wave +from datetime import datetime, timedelta, timezone +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer +from unittest.mock import patch + +import pytest +from opentelemetry.context import _SUPPRESS_INSTRUMENTATION_KEY, get_value + +from fi_instrumentation.attachments import AttachmentConfig, AttachmentManager, Bytes +from fi_instrumentation.attachments.protocol import HTTPTransport, TransferError +from test_policy_runtime import CONTEXT + + +def expiry(seconds=60): + return (datetime.now(timezone.utc) + timedelta(seconds=seconds)).isoformat() + + +@pytest.fixture +def server(tmp_path): + key, cert = tmp_path / "synthetic.key", tmp_path / "synthetic.crt" + subprocess.run(["openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", str(key), "-out", str(cert), "-days", "1", "-subj", "/CN=localhost", "-addext", "subjectAltName=DNS:localhost"], check=True, capture_output=True) + state = {"requests": [], "payloads": [], "fail": None, "policy": {}, "expires": 60} + scope = {k: str(uuid.uuid4()) for k in ("organization_id", "workspace_id", "project_id")} + + class Handler(BaseHTTPRequestHandler): + def log_message(self, *args): + pass + + def respond(self, status, body, headers=None): + data = json.dumps(body).encode() + self.send_response(status) + for key, value in (headers or {}).items(): + self.send_header(key, value) + self.send_header("Content-Length", str(len(data))) + self.end_headers() + self.wfile.write(data) + + def do_POST(self): + body = json.loads(self.rfile.read(int(self.headers["Content-Length"]))) + state["requests"].append((self.path, body, dict(self.headers))) + if self.path.endswith("attachment-sessions"): + self.respond(200, {"schema_version": 1, "scope": scope, + "capture_session_id": body["capture_session_id"], "expires_at": expiry(state["expires"]), + "transfer_modes": ["authenticated_stream"], + "policy": {"version": "v1", "enabled": True, "allowed_sources": ["Bytes", "OwnedRecordingFile"], + "allowed_modalities": ["audio"], "require_media_redaction": False, + "require_metadata_removal": False, "allow_unredacted_media_with_text_pii": False, + "record_audio": False, "record_video": False, **state["policy"]}, + "limits": {"max_upload_bytes": 8388608, "segment_bytes": 8388608, + "segment_duration_ms": 30000, "recording_bytes": 1073741824, + "recording_duration_ms": 7200000, "active_transfers": 16, + "active_recordings": 4, "reserved_bytes": 1073741824, + "validation_jobs": 1024, "initializations_per_minute": 120, + "links_per_minute": 1000, "upload_bytes_per_second": 1048576, + "playback_bytes_per_second": 1048576, "transfer_timeout_seconds": 30, + "grant_ttl_seconds": 60, "revocation_check_seconds": 5}}) + elif self.path.endswith("/uploads"): + upload_id = str(uuid.uuid4()) + state["upload_id"] = upload_id + self.respond(201, {"upload_id": upload_id, "attachment_id": body["attachment_id"], + "occurrence_id": body["occurrence_id"], "state": "pending_upload", "reserved_bytes": body["declared_bytes"], + "expires_at": expiry(), "transfer_mode": "authenticated_stream", + "write_capability": "SYNTHETIC_UPLOAD_ONLY"}) + elif self.path.endswith("/complete"): + self.respond(202, {"upload_id": state["upload_id"], "state": "validating", "reason": "binding_pending"}) + elif self.path.endswith("/abort"): + self.respond(200, {}) + else: + self.respond(404, {}) + + def do_PUT(self): + payload = self.rfile.read(int(self.headers["Content-Length"])) + state["requests"].append((self.path, None, dict(self.headers))) + if state["fail"]: + self.respond(state["fail"], {"error": "CANARY_BODY_SIGNED_URL"}, {"Location": "https://never-follow.invalid/secret"}) + return + state["payloads"].append(payload) + self.respond(200, {}) + + server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) + context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + context.load_cert_chain(certfile=str(cert), keyfile=str(key)) + server.socket = context.wrap_socket(server.socket, server_side=True) + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + client_context = ssl.create_default_context(cafile=str(cert)) + transport = HTTPTransport("https://localhost:" + str(server.server_port), + {"X-API-Key": "SYNTHETIC_KEY", "X-Secret-Key": "SYNTHETIC_SECRET"}, ssl_context=client_context) + yield transport, state + server.shutdown() + server.server_close() + thread.join(2) + + +def new_manager(transport): + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + assert manager.ready(2) + return manager + + +def test_real_wav_transfer_and_only_safe_projection(server, monkeypatch): + transport, state = server + monkeypatch.setenv("HTTPS_PROXY", "http://127.0.0.1:9") + monkeypatch.setenv("NETRC", "/not-used") + import http.client + original = http.client.HTTPConnection.endheaders + def suppressed(connection, *args, **kwargs): + assert get_value(_SUPPRESS_INSTRUMENTATION_KEY) + return original(connection, *args, **kwargs) + with patch.object(http.client.HTTPConnection, "endheaders", suppressed): + manager = new_manager(transport) + buffer = io.BytesIO() + with wave.open(buffer, "wb") as wav: + wav.setnchannels(1) + wav.setsampwidth(2) + wav.setframerate(8000) + wav.writeframes(b"\x00\x00" * 800) + raw = buffer.getvalue() + handle = manager.attach(CONTEXT, Bytes(raw), mime_type="audio/wav", direction="mixed", conversation_id="session_1", turn_id="turn_1") + assert handle.result(2).status == "validating" + assert state["payloads"] == [raw] + with wave.open(io.BytesIO(state["payloads"][0]), "rb") as decoded: + assert decoded.getnframes() == 800 and decoded.getframerate() == 8000 + puts = [request for request in state["requests"] if request[0].endswith("/content")] + assert puts[0][2]["authorization"] == "Bearer SYNTHETIC_UPLOAD_ONLY" + assert "x-api-key" not in puts[0][2] + init = state["requests"][1][1] + assert init["association"]["parent"]["trace_id"] == CONTEXT.trace_uuid + assert init["conversation_id"] == "session_1" + assert len(json.dumps(init)) < 2048 + manager.shutdown(1) + + +@pytest.mark.parametrize("flag", ["enabled", "require_media_redaction", "require_metadata_removal"]) +def test_server_denial_has_no_upload_network(server, flag): + transport, state = server + state["policy"][flag] = flag != "enabled" + manager = new_manager(transport) + result = manager.attach(CONTEXT, Bytes(b"secret"), mime_type="audio/wav", direction="mixed") + assert result.admission in ("policy_denied", "redaction_unavailable") + assert len(state["requests"]) == 1 and not state["payloads"] + manager.shutdown(1) + + +@pytest.mark.parametrize("status", [302, 401, 403, 409, 410, 413, 422]) +def test_no_redirect_or_security_retry_or_body_leak(server, status, caplog): + transport, state = server + state["fail"] = status + manager = new_manager(transport) + result = manager.attach(CONTEXT, Bytes(b"secret"), mime_type="audio/wav", direction="mixed") + assert result.result(2).status != "validating" + assert len([request for request in state["requests"] if request[0].endswith("/content")]) == 1 + assert "CANARY" not in caplog.text + repr(vars(result)) + manager.shutdown(1) + + +def test_expired_bootstrap_has_no_capture(server): + transport, state = server + state["expires"] = -1 + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + assert not manager.ready(2) + assert manager.status == "expired" + assert manager.attach(CONTEXT, Bytes(b"secret"), mime_type="audio/wav", direction="mixed").admission == "expired" + assert len(state["requests"]) == 1 + manager.shutdown(1) + + +@pytest.mark.parametrize("endpoint", ["http://localhost", "https://user:pass@example.test", "https://example.test/path", "https://example.test/?secret=canary", "file:///tmp/private"]) +def test_control_endpoint_rejects_unsafe_shapes(endpoint): + with pytest.raises(TransferError): + HTTPTransport(endpoint, {"authorization": "synthetic"}) diff --git a/python/tests/attachments/test_policy_runtime.py b/python/tests/attachments/test_policy_runtime.py new file mode 100644 index 000000000..22b0e19f7 --- /dev/null +++ b/python/tests/attachments/test_policy_runtime.py @@ -0,0 +1,290 @@ +import asyncio +import json +import os +import signal +import threading +import time +from dataclasses import replace +from unittest.mock import Mock + +import pytest +from opentelemetry.sdk.trace import TracerProvider +from opentelemetry.trace import SpanContext, TraceFlags + +from fi_instrumentation.attachments import ( + AttachmentConfig, AttachmentManager, AttachmentPolicy, Bytes, CapturePolicy, + CorrelationHandle, LocalFile, ProviderFile, RemoteUrl, ServerPolicy, +) +from fi_instrumentation.attachments.protocol import TransferError +from fi_instrumentation.instrumentation.config import TraceConfig, suppress_tracing + +CONTEXT = CorrelationHandle("1234567890abcdef1234567890abcdef", "1234567890abcdef", True) + + +def attach(manager, data=b"synthetic-audio", **kwargs): + return manager.attach(CONTEXT, Bytes(data), mime_type="audio/wav", direction="mixed", **kwargs) + + +def test_default_no_workers_no_network(monkeypatch): + constructor = Mock(side_effect=AssertionError("network")) + monkeypatch.setattr("fi_instrumentation.attachments.manager.HTTPTransport", constructor) + manager = AttachmentManager(project_name="synthetic") + assert attach(manager).admission == "disabled" + assert manager.owned_bytes == 0 + assert not manager._threads + constructor.assert_not_called() + assert manager.shutdown(0).unfinished == 0 + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_outputs", "hide_input_messages", "hide_output_messages", "hide_input_text", "hide_output_text", "pii_redaction"]) +def test_denial_before_even_payload_access(manager, transport, flag): + # A hostile byte wrapper proves denial occurs before source.data is read, + # not merely before sending a mock HTTP request. + class Forbidden: + @property + def data(self): + raise AssertionError("source was read") + manager.policy = AttachmentPolicy(manager.config, TraceConfig(**{flag: True})) + result = manager.attach(CONTEXT, Forbidden(), mime_type="audio/wav", direction="mixed") + assert result.admission in ("policy_denied", "redaction_unavailable") + assert not transport.requests and not transport.payloads + assert manager.owned_bytes == 0 + assert not manager._jobs + assert not hasattr(result, "source") + + +@pytest.mark.parametrize("direction", ["input", "output", "mixed"]) +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_outputs", "hide_input_messages", "hide_output_messages", "hide_input_text", "hide_output_text"]) +def test_directional_lattice(manager, transport, direction, flag): + manager.policy = AttachmentPolicy(manager.config, TraceConfig(**{flag: True})) + denied = direction == "mixed" or direction in flag + result = manager.attach(CONTEXT, Bytes(b"isolated"), mime_type="audio/wav", direction=direction) + assert (result.admission == "policy_denied") == denied + if not denied: + assert result.result(2).status == "validating" + assert transport.payloads == [b"isolated"] + else: + assert not transport.requests + + +@pytest.mark.parametrize("field", ["capture_content", "record_inputs", "record_outputs", "requested"]) +def test_integration_denials(manager, transport, field): + assert attach(manager, capture_policy=CapturePolicy(**{field: False})).admission == "policy_denied" + assert not transport.requests + + +@pytest.mark.parametrize("field", ["muted", "temporary_chat"]) +def test_session_denials(manager, transport, field): + assert attach(manager, capture_policy=CapturePolicy(**{field: True})).admission == "policy_denied" + assert not transport.requests + + +def test_error_and_semantic_ancestry(manager, transport): + manager.policy = AttachmentPolicy(manager.config, TraceConfig(hide_error_details=True, hide_inputs=True)) + assert attach(manager, capture_policy=CapturePolicy(error_detail=True)).admission == "policy_denied" + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="output", + capture_policy=CapturePolicy(contains_input=True)).admission == "policy_denied" + assert not transport.requests + + +@pytest.mark.parametrize("client", [False, True]) +@pytest.mark.parametrize("server", [False, True]) +@pytest.mark.parametrize("mandatory", [False, True]) +def test_pii_exception_intersection(manager, client, server, mandatory): + manager.policy = AttachmentPolicy(AttachmentConfig(enabled=True, allow_unredacted_media_with_text_pii=client), TraceConfig(pii_redaction=True)) + manager.update_policy(replace(manager._session.policy, allow_unredacted_media_with_text_pii=server, require_media_redaction=mandatory)) + result = attach(manager) + assert (result.admission == "queued") == (client and server and not mandatory) + + +def test_metadata_removal_requirement(manager, transport): + manager.update_policy(replace(manager._session.policy, require_metadata_removal=True)) + assert attach(manager).admission == "redaction_unavailable" + assert not transport.requests + + +def test_recording_is_not_import_permission(manager, transport): + assert attach(manager, capture_policy=CapturePolicy(new_recording=True)).admission in ("policy_denied", "recording_disabled") + assert attach(manager).result(2).status == "validating" + assert transport.payloads == [b"synthetic-audio"] + + +@pytest.mark.parametrize("value", ["false", "0", "invalid"]) +def test_env_disable_wins_explicit_enable(manager, transport, monkeypatch, value): + monkeypatch.setenv("FI_ATTACHMENTS_ENABLED", value) + assert attach(manager).admission == "disabled" + assert not transport.requests + + +def test_live_hide_env_rechecked_before_transfer(manager, transport, monkeypatch): + transport.release.clear() + handle = attach(manager) + assert transport.entered.wait(2) + monkeypatch.setenv("FI_HIDE_INPUT_TEXT", "true") + transport.release.set() + assert handle.result(2).status == "policy_denied" + assert not transport.payloads + assert manager.owned_bytes == 0 + + +def test_mutable_buffer_is_owned_only_after_admission(manager, transport): + transport.release.clear() + data = bytearray(b"before") + handle = attach(manager, data) + assert transport.entered.wait(2) + data[:] = b"after!" + transport.release.set() + assert handle.result(2).status == "validating" + assert transport.payloads == [b"before"] + + +def test_unknown_bootstrap_drops_without_retaining(transport): + gate = threading.Event() + original = transport.bootstrap + transport.bootstrap = lambda *args: (gate.wait(2), original(*args))[1] + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + assert attach(manager).admission == "bootstrap_pending" + assert manager.owned_bytes == 0 and not manager._jobs + gate.set() + assert manager.ready(2) + assert not transport.requests + manager.shutdown(0) + + +@pytest.mark.parametrize("source", [RemoteUrl("https://127.0.0.1/private?secret=canary"), RemoteUrl("https://169.254.169.254/"), RemoteUrl("https://[::1]/"), LocalFile("/never-read"), ProviderFile("livekit", "opaque-id"), "not-a-source"]) +def test_unqualified_sources_never_retrieve(manager, transport, monkeypatch, source): + manager.update_policy(replace(manager._session.policy, allowed_sources=frozenset((type(source).__name__,)))) + monkeypatch.setattr("socket.getaddrinfo", Mock(side_effect=AssertionError("DNS"))) + monkeypatch.setattr("builtins.open", Mock(side_effect=AssertionError("file read"))) + result = manager.attach(CONTEXT, source, mime_type="audio/wav", direction="mixed") + assert result.admission == "source_unavailable" + assert not transport.requests and not manager._jobs + + +def test_trace_identity_and_ended_span(manager, transport): + provider = TracerProvider(shutdown_on_exit=False) + span = provider.get_tracer("test").start_span("synthetic") + correlation = CorrelationHandle.from_span(span) + first = manager.attach(span, Bytes(b"one"), mime_type="audio/wav", direction="mixed", channel=1) + refs = json.loads(span.attributes["fi.attachment.refs"]) + assert refs[0]["occurrence_id"] == first.occurrence_id + span.end() + attributes = dict(span.attributes) + late = manager.attach(correlation, Bytes(b"late"), mime_type="audio/wav", direction="mixed") + assert late.result(2).status == "validating" + assert dict(span.attributes) == attributes + assert manager.attach(span, Bytes(b"no"), mime_type="audio/wav", direction="mixed").admission == "unsampled" + assert all(req["association"]["parent"]["trace_id"] == correlation.trace_uuid for req in transport.requests) + provider.shutdown() + + +@pytest.mark.parametrize("value", ["0" * 32, "ABCDEF1234567890abcdef1234567890", "123", "g" * 32]) +def test_invalid_id_rejected(value): + with pytest.raises(ValueError): + CorrelationHandle(value, "1234567890abcdef", True) + + +def test_uuid_conversion_preserves_all_bits(): + context = CorrelationHandle("ffffffffffffffffffffffffffffffff", "ffffffffffffffff", True) + assert context.trace_uuid == "ffffffff-ffff-ffff-ffff-ffffffffffff" + assert CorrelationHandle(context.trace_uuid, context.span_id, True) == context + + +def test_queue_and_memory_include_active(manager, transport): + manager.config = replace(manager.config, max_descriptors=1, max_owned_bytes=8) + transport.release.clear() + first = attach(manager, b"12345678") + assert transport.entered.wait(2) + assert manager.owned_bytes == 8 + assert attach(manager, b"x").admission == "queue_full" + transport.release.set() + assert first.result(2).status == "validating" + assert manager.owned_bytes == 0 + + +def test_oversize_callback_rejected(manager, transport): + assert attach(manager, bytearray(manager.config.chunk_bytes + 1)).admission == "too_large" + assert attach(manager, b"x" * (manager.config.max_attachment_bytes + 1)).admission == "too_large" + assert not transport.requests + + +def test_policy_tightening_discards_queue_and_does_not_resurrect(manager, transport): + transport.release.clear() + first = attach(manager) + assert transport.entered.wait(2) + handles = [attach(manager) for _ in range(5)] + old = manager._session.policy + manager.update_policy(replace(old, enabled=False)) + manager.update_policy(old) + transport.release.set() + assert first.result(2).status == "policy_denied" + assert all(handle.result(2).status == "policy_denied" for handle in handles) + assert not transport.payloads and manager.owned_bytes == 0 + + +def test_retries_keep_upload_identity_and_are_bounded(manager, transport): + transport.failures = [TransferError("incomplete", True), TransferError("throttled", True)] + assert attach(manager).result(2).status == "validating" + assert transport.calls == 3 and len(transport.requests) == 1 + + +@pytest.mark.parametrize("reason", ["policy_denied", "credential_scope_unsupported", "expired", "validation_failed"]) +def test_security_failures_never_retry(manager, transport, reason): + transport.failures = [TransferError(reason)] + assert attach(manager).result(2).status == reason + assert transport.calls == 1 + + +def test_shutdown_deadline_cancel_and_signal_handlers(manager, transport): + transport.release.clear() + handler = signal.getsignal(signal.SIGTERM) + handle = attach(manager) + assert transport.entered.wait(2) + start = time.monotonic() + result = manager.shutdown(0.02) + assert time.monotonic() - start < 0.2 and result.unfinished == 1 + assert signal.getsignal(signal.SIGTERM) == handler + transport.release.set() + assert handle.result(2).status == "incomplete" + assert manager.shutdown(0).unfinished == 0 + + +def test_async_completion_and_flush(manager): + async def run(): + handle = attach(manager) + assert (await handle.wait(2)).status == "validating" + assert (await manager.flush_async(2)).unfinished == 0 + asyncio.run(run()) + + +def test_uploader_exception_body_not_retained(manager, transport, caplog): + transport.failures = [RuntimeError("CANARY_SIGNED_PATH_SECRET")] + handle = attach(manager) + assert handle.result(2).status == "incomplete" + assert "CANARY" not in repr(vars(handle)) + caplog.text + assert manager.owned_bytes == 0 + + +def test_suppressed_capture_has_no_recursion(manager, transport): + with suppress_tracing(): + assert attach(manager).admission == "policy_denied" + assert not transport.requests + + +def test_after_fork_resets_workers_without_parent_replay(manager, transport): + read_fd, write_fd = os.pipe() + pid = os.fork() + if pid == 0: + try: + os.close(read_fd) + ok = manager.owned_bytes == 0 and manager.ready(2) + ok = ok and attach(manager).result(2).status == "validating" + os.write(write_fd, b"ok" if ok else b"failed") + finally: + os._exit(0) + os.close(write_fd) + assert os.read(read_fd, 20) == b"ok" + os.close(read_fd) + _, status = os.waitpid(pid, 0) + assert status == 0 + assert not transport.requests diff --git a/python/tests/attachments/test_sources.py b/python/tests/attachments/test_sources.py new file mode 100644 index 000000000..076c65761 --- /dev/null +++ b/python/tests/attachments/test_sources.py @@ -0,0 +1,92 @@ +import os +from dataclasses import replace + +import pytest +from fi_instrumentation.attachments import RecordingFileScope +from fi_instrumentation.attachments.protocol import TransferError +from test_policy_runtime import CONTEXT + + +def make_source(tmp_path, payload=b"synthetic-recording"): + path = tmp_path / "recording.wav" + path.write_bytes(payload) + info = path.stat() + scope = RecordingFileScope(str(tmp_path), enabled=True) + source = scope.source(path.name, device=info.st_dev, inode=info.st_ino, size=info.st_size) + return scope, source, path + + +def test_independent_lease_does_not_advance_app_file(manager, transport, tmp_path): + scope, source, path = make_source(tmp_path) + try: + with path.open("rb") as application: + application.read(3) + handle = manager.attach(CONTEXT, source, mime_type="audio/wav", direction="mixed") + assert handle.result(2).status == "validating" + assert application.tell() == 3 + assert transport.payloads == [b"synthetic-recording"] + finally: + scope.close() + + +def test_no_lease_under_policy_denial(manager, transport, tmp_path, monkeypatch): + scope, source, _ = make_source(tmp_path) + manager.update_policy(replace(manager._session.policy, enabled=False)) + monkeypatch.setattr(scope, "_open", lambda source: pytest.fail("denied file opened")) + assert manager.attach(CONTEXT, source, mime_type="audio/wav", direction="mixed").admission == "policy_denied" + assert not transport.requests + scope.close() + + +@pytest.mark.parametrize("kind", ["symlink", "replaced", "fifo", "directory", "missing"]) +def test_file_identity_and_type_races_fail_closed(manager, transport, tmp_path, kind): + scope, source, path = make_source(tmp_path) + alternate = tmp_path / "alternate" + alternate.write_bytes(b"secret") + path.unlink() + if kind == "symlink": + path.symlink_to(alternate) + elif kind == "replaced": + path.write_bytes(b"different") + elif kind == "fifo": + os.mkfifo(path) + elif kind == "directory": + path.mkdir() + try: + assert manager.attach(CONTEXT, source, mime_type="audio/wav", direction="mixed").result(2).status == "source_unavailable" + assert not transport.requests and not transport.payloads + finally: + scope.close() + + +def test_content_changed_after_lease_is_not_completed(tmp_path): + scope, source, path = make_source(tmp_path) + lease = source._open() + try: + path.write_bytes(b"changed") + with pytest.raises(TransferError): + lease.check() + finally: + lease.close() + scope.close() + + +@pytest.mark.parametrize("relative", ["../private", "/private", "a/../private", "a//private", "./private"]) +def test_traversal_not_authorized(tmp_path, relative): + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + with pytest.raises(ValueError): + scope.source(relative, device=1, inode=1, size=1) + finally: + scope.close() + + +def test_directory_symlink_and_implicit_permission_rejected(tmp_path): + target = tmp_path / "target" + target.mkdir() + link = tmp_path / "link" + link.symlink_to(target, target_is_directory=True) + with pytest.raises(ValueError): + RecordingFileScope(str(link), enabled=True) + with pytest.raises(ValueError): + RecordingFileScope(str(target)) diff --git a/python/traceai/__init__.py b/python/traceai/__init__.py index b7ba07619..d4596a4ba 100644 --- a/python/traceai/__init__.py +++ b/python/traceai/__init__.py @@ -12,6 +12,7 @@ """ import importlib +import threading from typing import Any, Dict, List, Optional from fi_instrumentation import ( @@ -21,6 +22,8 @@ register, ) from fi_instrumentation.fi_types import ProjectType +from fi_instrumentation.attachments import AttachmentConfig +from fi_instrumentation.instrumentation.config import TraceConfig # Registry of available instrumentors _INSTRUMENTOR_REGISTRY: Dict[str, str] = { @@ -55,9 +58,31 @@ "instructor": "traceai_instructor", "guardrails": "traceai_guardrails", "mcp": "traceai_mcp", + "pipecat": "traceai_pipecat", + "livekit": "traceai_livekit", +} + +# Explicit entry points: never choose the first imported *Instrumentor class. +_ENTRY_POINTS = { + "traceai_openai": "OpenAIInstrumentor", "traceai_anthropic": "AnthropicInstrumentor", + "traceai_litellm": "LiteLLMInstrumentor", "traceai_groq": "GroqInstrumentor", + "traceai_mistralai": "MistralAIInstrumentor", "traceai_cohere": "CohereInstrumentor", + "traceai_bedrock": "BedrockInstrumentor", "traceai_vertexai": "VertexAIInstrumentor", + "traceai_together": "TogetherInstrumentor", "traceai_cerebras": "CerebrasInstrumentor", + "traceai_deepseek": "DeepSeekInstrumentor", "traceai_fireworks": "FireworksInstrumentor", + "traceai_xai": "XAIInstrumentor", "traceai_ollama": "OllamaInstrumentor", + "traceai_google_genai": "GoogleGenAIInstrumentor", "traceai_langchain": "LangChainInstrumentor", + "traceai_llamaindex": "LlamaIndexInstrumentor", "traceai_crewai": "CrewAIInstrumentor", + "traceai_autogen": "AutogenInstrumentor", "traceai_dspy": "DSPyInstrumentor", + "traceai_haystack": "HaystackInstrumentor", "traceai_instructor": "InstructorInstrumentor", + "traceai_guardrails": "GuardrailsInstrumentor", "traceai_mcp": "MCPInstrumentor", } _tracer_provider: Optional[TracerProvider] = None +_init_options = None +_init_lock = threading.RLock() +_instrumented = set() +_adapter_status = {} def init( @@ -71,6 +96,8 @@ def init( batch: bool = False, verbose: bool = True, set_global_tracer_provider: bool = True, + attachment_config: Optional[AttachmentConfig] = None, + trace_config: Optional[TraceConfig] = None, ) -> TracerProvider: """ Initialize TraceAI with a simple one-liner. @@ -120,7 +147,7 @@ def init( verbose=False, ) """ - global _tracer_provider + global _tracer_provider, _init_options # Convert string enums to enum types project_type_enum = ( @@ -130,17 +157,30 @@ def init( semantic_convention_enum = SemanticConvention(semantic_convention.lower()) transport_enum = Transport(transport.lower()) - # Register the tracer provider - _tracer_provider = register( - project_name=project_name, - project_type=project_type_enum, - project_version_name=project_version_name, - batch=batch, - set_global_tracer_provider=set_global_tracer_provider, - verbose=verbose, - transport=transport_enum, - semantic_convention=semantic_convention_enum, - ) + options = (project_name, project_type, project_version_name, semantic_convention, + transport, batch, set_global_tracer_provider, attachment_config, trace_config) + with _init_lock: + if _tracer_provider is not None and _init_options != options: + raise ValueError("traceai is already initialized with different configuration") + if _tracer_provider is not None and _init_options == options: + provider = _tracer_provider + else: + provider = register( + project_name=project_name, + project_type=project_type_enum, + project_version_name=project_version_name, + batch=batch, + set_global_tracer_provider=set_global_tracer_provider, + verbose=verbose, + transport=transport_enum, + semantic_convention=semantic_convention_enum, + attachment_config=attachment_config, + trace_config=trace_config, + ) + _tracer_provider = provider + _init_options = options + _instrumented.clear() + _adapter_status.clear() # Auto-instrument specified libraries if auto_instrument: @@ -174,34 +214,41 @@ def _instrument_library(lib_name: str, verbose: bool = True) -> bool: # Import the instrumentor package module = importlib.import_module(instrumentor_module) - # Look for the Instrumentor class - instrumentor_class = None - for attr_name in dir(module): - if attr_name.endswith("Instrumentor") and attr_name != "BaseInstrumentor": - instrumentor_class = getattr(module, attr_name) - break - - if instrumentor_class is None: - if verbose: - print(f"Warning: Could not find Instrumentor class in {instrumentor_module}") - return False - - # Create and instrument - instrumentor = instrumentor_class() - instrumentor.instrument() + if lib_name_lower in ("pipecat", "livekit"): + # These use native/session integrations, not an Instrumentor. Auto + # cannot insert a pipeline processor or guess a live job/session. + _adapter_status[lib_name_lower] = "registered" + return True + with _init_lock: + if instrumentor_module in _instrumented: + return True + instrumentor_class = getattr(module, _ENTRY_POINTS[instrumentor_module]) + instrumentor = instrumentor_class() + provider = _tracer_provider + manager = getattr(provider, "attachment_manager", None) + instrumentor.instrument( + tracer_provider=provider, + config=getattr(provider, "trace_config", None), + attachment_manager=manager, + attachment_policy=getattr(manager, "policy", None), + ) + _instrumented.add(instrumentor_module) + _adapter_status[lib_name_lower] = "registered" if verbose: print(f"| Auto-instrumented: {lib_name}") return True - except ImportError as e: + except ImportError: + _adapter_status[lib_name_lower] = "dependency_unavailable" if verbose: print(f"Warning: Could not import {instrumentor_module}. Install it with: pip install {instrumentor_module}") return False - except Exception as e: + except Exception: + _adapter_status[lib_name_lower] = "unsupported_version" if verbose: - print(f"Warning: Failed to instrument {lib_name}: {e}") + print(f"Warning: Failed to instrument {lib_name}") return False @@ -227,8 +274,53 @@ def instrument(*libraries: str, verbose: bool = True) -> None: _instrument_library(lib_name, verbose=verbose) +def attachment_status() -> dict: + """Content-free setup status, never an integrated recording-ready claim.""" + manager = getattr(_tracer_provider, "attachment_manager", None) + return {"runtime": manager.status if manager is not None else "uninitialized", + "adapters": dict(_adapter_status)} + + +def _bind(library: str, entry_point: str, *args, **kwargs): + manager = getattr(_tracer_provider, "attachment_manager", None) + if manager is None: + raise RuntimeError("initialize traceai before binding a session") + try: + module = importlib.import_module(_INSTRUMENTOR_REGISTRY[library]) + binder = getattr(module, entry_point) + except (ImportError, AttributeError): + _adapter_status[library] = "unsupported_version" + return None + try: + binding = binder(*args, manager=manager, **kwargs) + except Exception: + _adapter_status[library] = "source_unavailable" + return None + # A binding alone is not proof of recorded media. The adapter owns reporting + # when a real source becomes available; Q02 qualifies end-to-end playback. + _adapter_status[library] = "session_bound" if binding is not None else "source_unavailable" + return binding + + +def bind_pipecat_audio_processor(processor, session_context): + """Observe an existing processor; never start a new recording implicitly.""" + return _bind("pipecat", "bind_audio_processor", processor, session_context) + + +def bind_livekit_session(session, job_context, *, owned_recording_files=False, + finalization_timeout=30): + """Bind the actual LiveKit session; local-file access is separately opt-in.""" + return _bind("livekit", "bind_session", session, job_context, + owned_recording_files=owned_recording_files, + finalization_timeout=finalization_timeout) + + __all__ = [ "init", + "AttachmentConfig", + "attachment_status", + "bind_pipecat_audio_processor", + "bind_livekit_session", "instrument", "get_tracer_provider", "SemanticConvention", diff --git a/python/traceai/tests/conftest.py b/python/traceai/tests/conftest.py new file mode 100644 index 000000000..b53fd44e1 --- /dev/null +++ b/python/traceai/tests/conftest.py @@ -0,0 +1,11 @@ +"""Each auto test owns its provider/registry lifecycle.""" +import pytest +import traceai + + +@pytest.fixture(autouse=True) +def isolated_auto_state(monkeypatch): + monkeypatch.setattr(traceai, "_tracer_provider", None) + monkeypatch.setattr(traceai, "_init_options", None) + monkeypatch.setattr(traceai, "_instrumented", set()) + monkeypatch.setattr(traceai, "_adapter_status", {}) diff --git a/python/traceai/tests/test_attachments.py b/python/traceai/tests/test_attachments.py new file mode 100644 index 000000000..4211f3f74 --- /dev/null +++ b/python/traceai/tests/test_attachments.py @@ -0,0 +1,57 @@ +from types import SimpleNamespace +from unittest.mock import Mock + +import traceai +from fi_instrumentation.attachments import AttachmentConfig +from fi_instrumentation.instrumentation.config import TraceConfig + + +def test_provider_policy_manager_propagation_and_idempotence(monkeypatch): + manager = SimpleNamespace(policy=object(), status="disabled") + config = TraceConfig(hide_inputs=True) + provider = SimpleNamespace(attachment_manager=manager, trace_config=config) + register = Mock(return_value=provider) + constructor = Mock() + module = SimpleNamespace(OpenAIInstrumentor=constructor, + AWrongInstrumentor=Mock(side_effect=AssertionError("guessed class"))) + monkeypatch.setattr(traceai, "register", register) + monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=module)) + attachments = AttachmentConfig(enabled=False) + args = dict(project_name="synthetic", attachment_config=attachments, trace_config=config, auto_instrument=["openai"], verbose=False) + assert traceai.init(**args) is provider + assert traceai.init(**args) is provider + register.assert_called_once() + constructor.assert_called_once() + constructor.return_value.instrument.assert_called_once_with( + tracer_provider=provider, config=config, attachment_manager=manager, attachment_policy=manager.policy) + assert register.call_args.kwargs["attachment_config"] is attachments + + +def test_voice_registration_does_not_claim_recording_or_mutate_global_provider(monkeypatch): + module = SimpleNamespace(enable_fi_attribute_mapping=Mock(side_effect=AssertionError("global mapping"))) + monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=module)) + assert traceai._instrument_library("pipecat", verbose=False) + assert traceai.attachment_status()["adapters"]["pipecat"] == "registered" + + +def test_explicit_session_binding_uses_shared_manager_without_recording_permission(monkeypatch): + manager = SimpleNamespace(status="ready") + monkeypatch.setattr(traceai, "_tracer_provider", SimpleNamespace(attachment_manager=manager)) + binder = Mock(return_value=object()) + monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=SimpleNamespace(bind_session=binder))) + session, job = object(), object() + result = traceai.bind_livekit_session(session, job) + assert result is binder.return_value + binder.assert_called_once_with(session, job, manager=manager, owned_recording_files=False, finalization_timeout=30) + assert traceai.attachment_status()["adapters"]["livekit"] == "session_bound" + assert "recording_source_ready" not in str(traceai.attachment_status()) + + +def test_old_optional_adapter_reports_unsupported_without_exception_body(monkeypatch, capsys): + monkeypatch.setattr(traceai, "_tracer_provider", SimpleNamespace(attachment_manager=SimpleNamespace(status="ready"))) + monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=SimpleNamespace())) + assert traceai.bind_pipecat_audio_processor(object(), object()) is None + assert traceai.attachment_status()["adapters"]["pipecat"] == "unsupported_version" + monkeypatch.setattr(traceai.importlib, "import_module", Mock(side_effect=RuntimeError("SYNTHETIC_SECRET"))) + assert not traceai._instrument_library("openai") + assert "SYNTHETIC_SECRET" not in capsys.readouterr().out From c3cd7a62d8441f291d670cc04957cf990612629a Mon Sep 17 00:00:00 2001 From: Nikhil Pareek Date: Tue, 10 Nov 2026 22:24:37 -0800 Subject: [PATCH 2/4] fix(python): bound attachment lifecycle and implement the streaming design The latest-OTel compatibility jobs hung because a test forked the multi-threaded pytest process: OpenTelemetry SDK 1.45's at-fork handler (TracerProvider._handle_fork) deadlocks the child on an inherited ThreadPoolExecutor lock. Fork coverage now runs in separate-interpreter exit probes, so no test forks the runner. Lifecycle (design section 8): a DisabledAttachmentManager null object when attachments are off (no thread, timer, fork hook, wire adapter or schema load), one fork hook per process, lazy daemon workers, bounded waits, and an idempotent shutdown that returns within its timeout. Implements the shared SDK streaming design against F01 f3b0923c62: preflight tickets evaluated with the F01 privacy table, multi-modal MIME mapping and per-kind caps, segmented PCM recordings with prefix-monotonic manifests, session and capability renewal, owned-file tiers with WAV range segmentation, the completed-recording import seam, consumed single-object streams, idempotency keys, the status-to-reason table and a pacer. Co-Authored-By: Claude Opus 5.5 --- .../workflows/attachments-python-tests.yml | 21 +- .../attachments/__init__.py | 37 +- .../attachments/_disabled.py | 129 + .../attachments/_privacy_table.json | 1352 ++++ .../attachments/_protocol_schema.json | 2578 ++++++-- .../attachments/admission.py | 144 + .../fi_instrumentation/attachments/errors.py | 15 + .../fi_instrumentation/attachments/imports.py | 99 + .../fi_instrumentation/attachments/manager.py | 1809 +++++- .../fi_instrumentation/attachments/policy.py | 243 +- .../attachments/protocol.py | 678 +- .../attachments/recording.py | 721 +++ .../fi_instrumentation/attachments/sources.py | 211 +- .../fi_instrumentation/attachments/stream.py | 136 + .../fi_instrumentation/attachments/types.py | 69 +- python/fi_instrumentation/otel.py | 13 +- python/tests/attachments/conftest.py | 161 +- python/tests/attachments/exit_probe.py | 179 + python/tests/attachments/f01/README.txt | 4 + .../attachments/f01/lifecycle-fixtures.json | 180 + .../attachments/f01/privacy-fixtures.json | 5758 +++++++++++++++++ .../f01/recording-import-fixtures.json | 2885 +++++++++ .../tests/attachments/f01/wire-fixtures.json | 4166 ++++++++++++ .../tests/attachments/test_http_contract.py | 88 +- python/tests/attachments/test_imports.py | 132 + python/tests/attachments/test_lifecycle.py | 163 + .../tests/attachments/test_policy_runtime.py | 52 +- python/tests/attachments/test_preflight.py | 237 + python/tests/attachments/test_recording.py | 407 ++ python/tests/attachments/test_renewal.py | 140 + python/tests/attachments/test_sources.py | 190 + python/tests/attachments/test_streams.py | 123 + .../tests/attachments/test_wire_fixtures.py | 116 + python/traceai/__init__.py | 2 +- python/traceai/tests/test_attachments.py | 22 +- 35 files changed, 22046 insertions(+), 1214 deletions(-) create mode 100644 python/fi_instrumentation/attachments/_disabled.py create mode 100644 python/fi_instrumentation/attachments/_privacy_table.json create mode 100644 python/fi_instrumentation/attachments/admission.py create mode 100644 python/fi_instrumentation/attachments/errors.py create mode 100644 python/fi_instrumentation/attachments/imports.py create mode 100644 python/fi_instrumentation/attachments/recording.py create mode 100644 python/fi_instrumentation/attachments/stream.py create mode 100644 python/tests/attachments/exit_probe.py create mode 100644 python/tests/attachments/f01/README.txt create mode 100644 python/tests/attachments/f01/lifecycle-fixtures.json create mode 100644 python/tests/attachments/f01/privacy-fixtures.json create mode 100644 python/tests/attachments/f01/recording-import-fixtures.json create mode 100644 python/tests/attachments/f01/wire-fixtures.json create mode 100644 python/tests/attachments/test_imports.py create mode 100644 python/tests/attachments/test_lifecycle.py create mode 100644 python/tests/attachments/test_preflight.py create mode 100644 python/tests/attachments/test_recording.py create mode 100644 python/tests/attachments/test_renewal.py create mode 100644 python/tests/attachments/test_streams.py create mode 100644 python/tests/attachments/test_wire_fixtures.py diff --git a/.github/workflows/attachments-python-tests.yml b/.github/workflows/attachments-python-tests.yml index 8cb9128c3..67ec912ab 100644 --- a/.github/workflows/attachments-python-tests.yml +++ b/.github/workflows/attachments-python-tests.yml @@ -20,22 +20,27 @@ permissions: jobs: component: - runs-on: ubuntu-latest - timeout-minutes: 10 + name: Attachments Python ${{ matrix.python }} + runs-on: ubuntu-24.04 + timeout-minutes: 15 strategy: fail-fast: false matrix: - python: ['3.10', '3.11', '3.12', '3.13'] + python: ['3.10', '3.11', '3.12', '3.13', '3.14'] steps: - - uses: actions/checkout@v4 - - uses: actions/setup-python@v5 + - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2 + with: + persist-credentials: false + - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0 with: python-version: '${{ matrix.python }}' - name: Install component dependencies - run: python -m pip install -e python pytest==8.3.5 pytest-asyncio==0.26.0 pytest-mock==3.14.0 responses==0.25.7 - - name: Run synthetic attachment and auto tests + run: python -m pip install -e python 'pytest>=7,<8' 'pytest-asyncio>=0.21,<0.22' pytest-mock responses + - name: Run synthetic attachment, lifecycle exit-probe and auto tests env: PYTHONPATH: python FI_BASE_URL: http://127.0.0.1:9 FI_GRPC_URL: http://127.0.0.1:9 - run: python -m pytest -q python/tests/attachments python/traceai/tests + # faulthandler dumps every thread's stack if a test stalls, so a hang + # is diagnosable from the log instead of only timing out the job. + run: python -m pytest -q -p no:cacheprovider -o faulthandler_timeout=120 python/tests/attachments python/traceai/tests diff --git a/python/fi_instrumentation/attachments/__init__.py b/python/fi_instrumentation/attachments/__init__.py index b22845c9f..fb03031a6 100644 --- a/python/fi_instrumentation/attachments/__init__.py +++ b/python/fi_instrumentation/attachments/__init__.py @@ -1,20 +1,37 @@ -"""Opt-in, provider-owned audio attachments. +"""Opt-in, provider-owned attachments (audio, images, documents, files). -Capture OFF and recording OFF by default. Importing an existing owned recording -never starts a recorder. RemoteUrl/ProviderFile/LocalFile are typed but fail closed -until their separately qualified retrieval adapters exist. +Capture is OFF by default and creating new recordings is separately OFF. +``create_attachment_manager`` returns a strict no-op null object when OFF: it +starts no thread or timer, registers no fork hook and imports neither the wire +adapter (``protocol``) nor ``jsonschema``. Importing an existing owned +recording never starts a recorder. RemoteUrl/ProviderFile/LocalFile are typed +but fail closed outside the completed-recording import seam. """ -from .manager import AttachmentManager, AttachmentSpanProcessor +from ._disabled import DisabledAttachmentManager, OwnedRecordingHandle +from .admission import AdmissionTicket +from .errors import TransferError +from .imports import ( + CompletedRecordingRequest, CompletedRecordingResolver, EgressOutputRegistry, EnvelopeSource, ImportHandle, + ProviderFileSource, ResolvedCompletedRecording, UnavailableResolver, +) +from .manager import AttachmentManager, AttachmentSpanProcessor, create_attachment_manager from .policy import AttachmentConfig, AttachmentPolicy, CapturePolicy, ServerPolicy -from .sources import OwnedRecordingFile, RecordingFileScope +from .recording import PcmFormat, RecordingOptions, RecordingResult, RecordingStatus, RecordingWriter, TrackSpec +from .sources import FileIdentity, OwnedRecordingFile, RecordingFileScope +from .stream import AttachmentStream, StreamOptions from .types import ( - AttachmentHandle, Bytes, Completion, CorrelationHandle, FlushResult, + AttachmentHandle, AttachmentStatus, Bytes, Completion, CorrelationHandle, FlushResult, LocalFile, ProviderFile, RemoteUrl, ) __all__ = [ - "AttachmentConfig", "AttachmentManager", "AttachmentPolicy", "AttachmentSpanProcessor", - "AttachmentHandle", "Bytes", "CapturePolicy", "Completion", "CorrelationHandle", "FlushResult", - "LocalFile", "OwnedRecordingFile", "ProviderFile", "RecordingFileScope", "RemoteUrl", "ServerPolicy", + "AdmissionTicket", "AttachmentConfig", "AttachmentHandle", "AttachmentManager", "AttachmentPolicy", + "AttachmentSpanProcessor", "AttachmentStatus", "AttachmentStream", "Bytes", "CapturePolicy", "Completion", + "CompletedRecordingRequest", "CompletedRecordingResolver", "CorrelationHandle", "DisabledAttachmentManager", + "EgressOutputRegistry", "EnvelopeSource", "FileIdentity", "FlushResult", "ImportHandle", "LocalFile", + "OwnedRecordingFile", "OwnedRecordingHandle", "PcmFormat", "ProviderFile", "ProviderFileSource", + "RecordingFileScope", "RecordingOptions", "RecordingResult", "RecordingStatus", "RecordingWriter", "RemoteUrl", + "ResolvedCompletedRecording", "ServerPolicy", "StreamOptions", "TrackSpec", "TransferError", + "UnavailableResolver", "create_attachment_manager", ] diff --git a/python/fi_instrumentation/attachments/_disabled.py b/python/fi_instrumentation/attachments/_disabled.py new file mode 100644 index 000000000..93971c71a --- /dev/null +++ b/python/fi_instrumentation/attachments/_disabled.py @@ -0,0 +1,129 @@ +"""The disabled null object (design 8.1) and shared light handle types. + +When attachments are OFF nothing here starts a thread or timer, registers a +fork/atexit hook, imports the wire adapter or ``jsonschema``, re-reads the +environment, or writes span attributes. Every call returns immediately. +""" + +import asyncio +import threading +from typing import Optional + +from .admission import AdmissionTicket +from .imports import ImportHandle +from .policy import AttachmentConfig, AttachmentPolicy +from .recording import RecordingWriter +from .stream import AttachmentStream +from .types import AttachmentHandle, AttachmentStatus, Completion, FlushResult + + +class OwnedRecordingHandle: + """Result of ``attach_owned_recording``: tier ``single``, ``wav_recording`` or ``denied``.""" + + def __init__(self, tier: str, reason: str, *, handle: Optional[AttachmentHandle] = None, + recording_id: Optional[str] = None, manager=None): + self.tier = tier + self.reason = reason + self.recording_id = recording_id if tier == "wav_recording" else None + self._handle = handle + self._manager = manager + self._job = None + self._event = threading.Event() + self._completion: Optional[Completion] = None + if tier == "denied" or (handle is None and reason != "queued"): + self._finish(reason) + + def _finish(self, status: str) -> None: + if not self._event.is_set(): + self._completion = Completion(status) + self._event.set() + + def result(self, timeout: float = 0) -> Completion: + if self._handle is not None: + return self._handle.result(timeout) + if timeout and timeout > 0: + self._event.wait(min(timeout, 30)) + return self._completion or Completion("unfinished") + + async def wait(self, timeout: float = 30.0) -> Completion: + if self._handle is not None: + return await self._handle.wait(timeout) + if self._event.is_set(): + return self._completion + return await asyncio.to_thread(self.result, timeout) + + def cancel(self) -> None: + if self._manager is None: + return + if self._handle is not None: + self._manager.cancel(self._handle) + elif self._job is not None: + self._job.cancelled = True + self._manager.cancel(self) + + def __repr__(self) -> str: + return "OwnedRecordingHandle(tier=%r, reason=%r)" % (self.tier, self.reason) + + +_EMPTY = FlushResult(0, 0) + + +class DisabledAttachmentManager: + """Full public surface; every call is inert and returns ``disabled``.""" + + capture_session_id = None + correlation_nonce = None + + def __init__(self, *, config: Optional[AttachmentConfig] = None, trace_config=None): + self.config = config or AttachmentConfig(enabled=False) + self.policy = AttachmentPolicy(self.config, trace_config) + + def status(self) -> AttachmentStatus: + return AttachmentStatus("disabled") + + @property + def owned_bytes(self) -> int: + return 0 + + def ready(self, timeout: float = 5) -> bool: + return False + + async def ready_async(self, timeout: float = 5) -> bool: + return False + + def preflight(self, target=None, **_options) -> AdmissionTicket: + return AdmissionTicket(None, "disabled") + + def attach(self, span_or_context=None, source=None, **_options) -> AttachmentHandle: + return AttachmentHandle("disabled") + + def start_attachment_stream(self, target=None, options=None) -> AttachmentStream: + return AttachmentStream.denied("disabled") + + def start_recording(self, target=None, options=None) -> RecordingWriter: + return RecordingWriter(reason="disabled") + + def attach_owned_recording(self, target=None, source=None, **_options) -> OwnedRecordingHandle: + return OwnedRecordingHandle("denied", "disabled") + + async def import_completed_recording(self, target=None, request=None, **_options) -> ImportHandle: + # The resolver is never called. + return ImportHandle("disabled") + + def update_policy(self, server) -> None: + return None + + def cancel(self, handle) -> None: + return None + + def flush(self, timeout: float = 5) -> FlushResult: + return _EMPTY + + async def flush_async(self, timeout: float = 5) -> FlushResult: + return _EMPTY + + def shutdown(self, timeout: Optional[float] = None) -> FlushResult: + return _EMPTY + + def __repr__(self) -> str: + return "DisabledAttachmentManager()" diff --git a/python/fi_instrumentation/attachments/_privacy_table.json b/python/fi_instrumentation/attachments/_privacy_table.json new file mode 100644 index 000000000..95c3ca347 --- /dev/null +++ b/python/fi_instrumentation/attachments/_privacy_table.json @@ -0,0 +1,1352 @@ +{ + "schema_version": 1, + "evaluation": "Validate context; invalid/unknown/missing facts deny. Evaluate every matching rule; any denial wins. The first matching rule supplies the safe reason. No allow rule overrides a denial. Re-evaluate before read/copy/hash/upload/retry/serve. On tightening discard owned bytes and revoke capability; never wait for re-enable.", + "context_schema": { + "$schema": "https://json-schema.org/draft/2020-12/schema", + "type": "object", + "additionalProperties": false, + "required": [ + "enabled", + "endpoint_configured", + "policy_known", + "server_allowed", + "credential_allowed", + "integration_capture_content", + "integration_record_inputs", + "integration_record_outputs", + "muted", + "temporary_chat", + "hide_inputs", + "hide_outputs", + "hide_input_messages", + "hide_output_messages", + "hide_input_images", + "hide_input_text", + "hide_output_text", + "hide_error_details", + "pii_redaction", + "server_require_media_redaction", + "qualified_client_sanitizer", + "allow_unredacted_media_with_text_pii", + "server_allow_unredacted_media_with_text_pii", + "require_metadata_removal", + "qualified_client_metadata_removal", + "modality_allowed", + "source_authorized", + "call_requested", + "sampled", + "correlation_available", + "generation_current", + "source_available", + "budget_available", + "queue_available", + "direction", + "semantic_input", + "semantic_output", + "model_bound_image", + "opaque_text_possible", + "error_diagnostic", + "modality", + "source_kind", + "operation", + "record_audio", + "record_video", + "server_record_audio", + "server_record_video", + "browser_remote_fetch", + "remote_destination_approved", + "all_addresses_public", + "tls_ip_pinned", + "redirects_revalidated", + "ambient_credentials_absent", + "owned_session_bound", + "owned_file_lease_valid", + "provider_connection_authorized", + "provider_output_completed", + "explicit_partial_allowed" + ], + "properties": { + "enabled": { + "type": "boolean" + }, + "endpoint_configured": { + "type": "boolean" + }, + "policy_known": { + "type": "boolean" + }, + "server_allowed": { + "type": "boolean" + }, + "credential_allowed": { + "type": "boolean" + }, + "integration_capture_content": { + "type": "boolean" + }, + "integration_record_inputs": { + "type": "boolean" + }, + "integration_record_outputs": { + "type": "boolean" + }, + "muted": { + "type": "boolean" + }, + "temporary_chat": { + "type": "boolean" + }, + "hide_inputs": { + "type": "boolean" + }, + "hide_outputs": { + "type": "boolean" + }, + "hide_input_messages": { + "type": "boolean" + }, + "hide_output_messages": { + "type": "boolean" + }, + "hide_input_images": { + "type": "boolean" + }, + "hide_input_text": { + "type": "boolean" + }, + "hide_output_text": { + "type": "boolean" + }, + "hide_error_details": { + "type": "boolean" + }, + "pii_redaction": { + "type": "boolean" + }, + "server_require_media_redaction": { + "type": "boolean" + }, + "qualified_client_sanitizer": { + "type": "boolean" + }, + "allow_unredacted_media_with_text_pii": { + "type": "boolean" + }, + "server_allow_unredacted_media_with_text_pii": { + "type": "boolean" + }, + "require_metadata_removal": { + "type": "boolean" + }, + "qualified_client_metadata_removal": { + "type": "boolean" + }, + "modality_allowed": { + "type": "boolean" + }, + "source_authorized": { + "type": "boolean" + }, + "call_requested": { + "type": "boolean" + }, + "sampled": { + "type": "boolean" + }, + "correlation_available": { + "type": "boolean" + }, + "generation_current": { + "type": "boolean" + }, + "source_available": { + "type": "boolean" + }, + "budget_available": { + "type": "boolean" + }, + "queue_available": { + "type": "boolean" + }, + "semantic_input": { + "type": "boolean" + }, + "semantic_output": { + "type": "boolean" + }, + "model_bound_image": { + "type": "boolean" + }, + "opaque_text_possible": { + "type": "boolean" + }, + "error_diagnostic": { + "type": "boolean" + }, + "record_audio": { + "type": "boolean" + }, + "record_video": { + "type": "boolean" + }, + "server_record_audio": { + "type": "boolean" + }, + "server_record_video": { + "type": "boolean" + }, + "browser_remote_fetch": { + "type": "boolean" + }, + "remote_destination_approved": { + "type": "boolean" + }, + "all_addresses_public": { + "type": "boolean" + }, + "tls_ip_pinned": { + "type": "boolean" + }, + "redirects_revalidated": { + "type": "boolean" + }, + "ambient_credentials_absent": { + "type": "boolean" + }, + "owned_session_bound": { + "type": "boolean" + }, + "owned_file_lease_valid": { + "type": "boolean" + }, + "provider_connection_authorized": { + "type": "boolean" + }, + "provider_output_completed": { + "type": "boolean" + }, + "explicit_partial_allowed": { + "type": "boolean" + }, + "direction": { + "enum": [ + "input", + "output", + "mixed" + ] + }, + "modality": { + "enum": [ + "audio", + "image", + "video", + "document", + "file" + ] + }, + "source_kind": { + "enum": [ + "Bytes", + "Blob", + "RemoteUrl", + "LocalFile", + "OwnedRecordingFile", + "ProviderFile" + ] + }, + "operation": { + "enum": [ + "import_existing", + "observe_consumed", + "create_recording" + ] + } + } + }, + "rules": [ + { + "id": "disabled", + "reason": "disabled", + "deny_if": { + "required": [ + "enabled" + ], + "properties": { + "enabled": { + "const": false + } + } + } + }, + { + "id": "endpoint", + "reason": "endpoint_unconfigured", + "deny_if": { + "required": [ + "endpoint_configured" + ], + "properties": { + "endpoint_configured": { + "const": false + } + } + } + }, + { + "id": "bootstrap", + "reason": "bootstrap_pending", + "deny_if": { + "required": [ + "policy_known" + ], + "properties": { + "policy_known": { + "const": false + } + } + } + }, + { + "id": "server", + "reason": "policy_denied", + "deny_if": { + "required": [ + "server_allowed" + ], + "properties": { + "server_allowed": { + "const": false + } + } + } + }, + { + "id": "credential", + "reason": "credential_scope_unsupported", + "deny_if": { + "required": [ + "credential_allowed" + ], + "properties": { + "credential_allowed": { + "const": false + } + } + } + }, + { + "id": "capture-content", + "reason": "policy_denied", + "deny_if": { + "required": [ + "integration_capture_content" + ], + "properties": { + "integration_capture_content": { + "const": false + } + } + } + }, + { + "id": "muted", + "reason": "policy_denied", + "deny_if": { + "anyOf": [ + { + "required": [ + "muted" + ], + "properties": { + "muted": { + "const": true + } + } + }, + { + "required": [ + "temporary_chat" + ], + "properties": { + "temporary_chat": { + "const": true + } + } + } + ] + } + }, + { + "id": "input", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "anyOf": [ + { + "required": [ + "semantic_input" + ], + "properties": { + "semantic_input": { + "const": true + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "input" + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "mixed" + } + } + }, + { + "required": [ + "model_bound_image" + ], + "properties": { + "model_bound_image": { + "const": true + } + } + } + ] + }, + { + "anyOf": [ + { + "required": [ + "integration_record_inputs" + ], + "properties": { + "integration_record_inputs": { + "const": false + } + } + }, + { + "required": [ + "hide_inputs" + ], + "properties": { + "hide_inputs": { + "const": true + } + } + }, + { + "required": [ + "hide_input_messages" + ], + "properties": { + "hide_input_messages": { + "const": true + } + } + } + ] + } + ] + } + }, + { + "id": "output", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "anyOf": [ + { + "required": [ + "semantic_output" + ], + "properties": { + "semantic_output": { + "const": true + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "output" + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "mixed" + } + } + } + ] + }, + { + "anyOf": [ + { + "required": [ + "integration_record_outputs" + ], + "properties": { + "integration_record_outputs": { + "const": false + } + } + }, + { + "required": [ + "hide_outputs" + ], + "properties": { + "hide_outputs": { + "const": true + } + } + }, + { + "required": [ + "hide_output_messages" + ], + "properties": { + "hide_output_messages": { + "const": true + } + } + } + ] + } + ] + } + }, + { + "id": "input-image-ancestry", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "anyOf": [ + { + "required": [ + "model_bound_image" + ], + "properties": { + "model_bound_image": { + "const": true + } + } + }, + { + "allOf": [ + { + "required": [ + "modality" + ], + "properties": { + "modality": { + "const": "image" + } + } + }, + { + "anyOf": [ + { + "required": [ + "semantic_input" + ], + "properties": { + "semantic_input": { + "const": true + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "input" + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "mixed" + } + } + }, + { + "required": [ + "model_bound_image" + ], + "properties": { + "model_bound_image": { + "const": true + } + } + } + ] + } + ] + } + ] + }, + { + "required": [ + "hide_input_images" + ], + "properties": { + "hide_input_images": { + "const": true + } + } + } + ] + } + }, + { + "id": "hidden-input-text", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "anyOf": [ + { + "required": [ + "semantic_input" + ], + "properties": { + "semantic_input": { + "const": true + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "input" + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "mixed" + } + } + }, + { + "required": [ + "model_bound_image" + ], + "properties": { + "model_bound_image": { + "const": true + } + } + } + ] + }, + { + "required": [ + "opaque_text_possible" + ], + "properties": { + "opaque_text_possible": { + "const": true + } + } + }, + { + "required": [ + "hide_input_text" + ], + "properties": { + "hide_input_text": { + "const": true + } + } + } + ] + } + }, + { + "id": "hidden-output-text", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "anyOf": [ + { + "required": [ + "semantic_output" + ], + "properties": { + "semantic_output": { + "const": true + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "output" + } + } + }, + { + "required": [ + "direction" + ], + "properties": { + "direction": { + "const": "mixed" + } + } + } + ] + }, + { + "required": [ + "opaque_text_possible" + ], + "properties": { + "opaque_text_possible": { + "const": true + } + } + }, + { + "required": [ + "hide_output_text" + ], + "properties": { + "hide_output_text": { + "const": true + } + } + } + ] + } + }, + { + "id": "error-details", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "required": [ + "error_diagnostic" + ], + "properties": { + "error_diagnostic": { + "const": true + } + } + }, + { + "required": [ + "hide_error_details" + ], + "properties": { + "hide_error_details": { + "const": true + } + } + } + ] + } + }, + { + "id": "server-media-redaction", + "reason": "redaction_unavailable", + "deny_if": { + "allOf": [ + { + "required": [ + "server_require_media_redaction" + ], + "properties": { + "server_require_media_redaction": { + "const": true + } + } + }, + { + "required": [ + "qualified_client_sanitizer" + ], + "properties": { + "qualified_client_sanitizer": { + "const": false + } + } + } + ] + } + }, + { + "id": "pii-intersection", + "reason": "redaction_unavailable", + "deny_if": { + "allOf": [ + { + "required": [ + "pii_redaction" + ], + "properties": { + "pii_redaction": { + "const": true + } + } + }, + { + "required": [ + "qualified_client_sanitizer" + ], + "properties": { + "qualified_client_sanitizer": { + "const": false + } + } + }, + { + "not": { + "allOf": [ + { + "required": [ + "allow_unredacted_media_with_text_pii" + ], + "properties": { + "allow_unredacted_media_with_text_pii": { + "const": true + } + } + }, + { + "required": [ + "server_allow_unredacted_media_with_text_pii" + ], + "properties": { + "server_allow_unredacted_media_with_text_pii": { + "const": true + } + } + } + ] + } + } + ] + } + }, + { + "id": "metadata-before-egress", + "reason": "redaction_unavailable", + "deny_if": { + "allOf": [ + { + "required": [ + "require_metadata_removal" + ], + "properties": { + "require_metadata_removal": { + "const": true + } + } + }, + { + "required": [ + "qualified_client_metadata_removal" + ], + "properties": { + "qualified_client_metadata_removal": { + "const": false + } + } + } + ] + } + }, + { + "id": "modality", + "reason": "policy_denied", + "deny_if": { + "required": [ + "modality_allowed" + ], + "properties": { + "modality_allowed": { + "const": false + } + } + } + }, + { + "id": "source", + "reason": "policy_denied", + "deny_if": { + "required": [ + "source_authorized" + ], + "properties": { + "source_authorized": { + "const": false + } + } + } + }, + { + "id": "browser-remote", + "reason": "policy_denied", + "deny_if": { + "required": [ + "browser_remote_fetch" + ], + "properties": { + "browser_remote_fetch": { + "const": true + } + } + } + }, + { + "id": "remote-destination", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "required": [ + "source_kind" + ], + "properties": { + "source_kind": { + "const": "RemoteUrl" + } + } + }, + { + "anyOf": [ + { + "required": [ + "remote_destination_approved" + ], + "properties": { + "remote_destination_approved": { + "const": false + } + } + }, + { + "required": [ + "all_addresses_public" + ], + "properties": { + "all_addresses_public": { + "const": false + } + } + }, + { + "required": [ + "tls_ip_pinned" + ], + "properties": { + "tls_ip_pinned": { + "const": false + } + } + }, + { + "required": [ + "redirects_revalidated" + ], + "properties": { + "redirects_revalidated": { + "const": false + } + } + }, + { + "required": [ + "ambient_credentials_absent" + ], + "properties": { + "ambient_credentials_absent": { + "const": false + } + } + } + ] + } + ] + } + }, + { + "id": "owned-recording", + "reason": "policy_denied", + "deny_if": { + "allOf": [ + { + "required": [ + "source_kind" + ], + "properties": { + "source_kind": { + "const": "OwnedRecordingFile" + } + } + }, + { + "anyOf": [ + { + "required": [ + "owned_session_bound" + ], + "properties": { + "owned_session_bound": { + "const": false + } + } + }, + { + "required": [ + "owned_file_lease_valid" + ], + "properties": { + "owned_file_lease_valid": { + "const": false + } + } + } + ] + } + ] + } + }, + { + "id": "provider-connection", + "reason": "credential_scope_unsupported", + "deny_if": { + "allOf": [ + { + "required": [ + "source_kind" + ], + "properties": { + "source_kind": { + "const": "ProviderFile" + } + } + }, + { + "required": [ + "provider_connection_authorized" + ], + "properties": { + "provider_connection_authorized": { + "const": false + } + } + } + ] + } + }, + { + "id": "provider-not-complete", + "reason": "source_unavailable", + "deny_if": { + "allOf": [ + { + "required": [ + "source_kind" + ], + "properties": { + "source_kind": { + "const": "ProviderFile" + } + } + }, + { + "required": [ + "provider_output_completed" + ], + "properties": { + "provider_output_completed": { + "const": false + } + } + }, + { + "required": [ + "explicit_partial_allowed" + ], + "properties": { + "explicit_partial_allowed": { + "const": false + } + } + } + ] + } + }, + { + "id": "new-audio", + "reason": "recording_disabled", + "deny_if": { + "allOf": [ + { + "required": [ + "operation" + ], + "properties": { + "operation": { + "const": "create_recording" + } + } + }, + { + "required": [ + "modality" + ], + "properties": { + "modality": { + "const": "audio" + } + } + }, + { + "anyOf": [ + { + "required": [ + "record_audio" + ], + "properties": { + "record_audio": { + "const": false + } + } + }, + { + "required": [ + "server_record_audio" + ], + "properties": { + "server_record_audio": { + "const": false + } + } + } + ] + } + ] + } + }, + { + "id": "new-video", + "reason": "recording_disabled", + "deny_if": { + "allOf": [ + { + "required": [ + "operation" + ], + "properties": { + "operation": { + "const": "create_recording" + } + } + }, + { + "required": [ + "modality" + ], + "properties": { + "modality": { + "const": "video" + } + } + }, + { + "anyOf": [ + { + "required": [ + "record_video" + ], + "properties": { + "record_video": { + "const": false + } + } + }, + { + "required": [ + "server_record_video" + ], + "properties": { + "server_record_video": { + "const": false + } + } + } + ] + } + ] + } + }, + { + "id": "per-call", + "reason": "policy_denied", + "deny_if": { + "required": [ + "call_requested" + ], + "properties": { + "call_requested": { + "const": false + } + } + } + }, + { + "id": "sampled", + "reason": "unsampled", + "deny_if": { + "required": [ + "sampled" + ], + "properties": { + "sampled": { + "const": false + } + } + } + }, + { + "id": "correlation", + "reason": "correlation_unavailable", + "deny_if": { + "required": [ + "correlation_available" + ], + "properties": { + "correlation_available": { + "const": false + } + } + } + }, + { + "id": "deletion-generation", + "reason": "deleted", + "deny_if": { + "required": [ + "generation_current" + ], + "properties": { + "generation_current": { + "const": false + } + } + } + }, + { + "id": "source-available", + "reason": "source_unavailable", + "deny_if": { + "required": [ + "source_available" + ], + "properties": { + "source_available": { + "const": false + } + } + } + }, + { + "id": "budget", + "reason": "too_large", + "deny_if": { + "required": [ + "budget_available" + ], + "properties": { + "budget_available": { + "const": false + } + } + } + }, + { + "id": "queue", + "reason": "queue_full", + "deny_if": { + "required": [ + "queue_available" + ], + "properties": { + "queue_available": { + "const": false + } + } + } + } + ], + "allow": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + }, + "deny_effects": [], + "defaults": { + "FI_ATTACHMENTS_ENABLED": false, + "FI_ATTACHMENTS_RECORD_AUDIO": false, + "FI_ATTACHMENTS_RECORD_VIDEO": false, + "inline_base64_image_bytes": 0, + "LocalFile": false, + "RemoteUrl": false, + "disk_spool": false, + "public_link_media": false, + "evaluation_reuse": false, + "backfill": false + } +} diff --git a/python/fi_instrumentation/attachments/_protocol_schema.json b/python/fi_instrumentation/attachments/_protocol_schema.json index a531510ca..7287fbc44 100644 --- a/python/fi_instrumentation/attachments/_protocol_schema.json +++ b/python/fi_instrumentation/attachments/_protocol_schema.json @@ -1,497 +1,2104 @@ { "$schema": "https://json-schema.org/draft/2020-12/schema", - "$comment": "Generated protocol-only subset of spec/attachments/v1/contract.schema.json; no runtime support claim.", + "$id": "https://raw.githubusercontent.com/future-agi/traceAI/dev/spec/attachments/v1/contract.schema.json", + "title": "fi.attachments.v1", + "description": "Normative closed wire shapes. Cross-field authorization and byte limits also require the conformance tables. This is not an implementation or support declaration.", "$defs": { + "UUID": { + "type": "string", + "pattern": "^(?!00000000-0000-0000-0000-000000000000$)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", + "maxLength": 36 + }, + "TraceInput": { + "type": "string", + "oneOf": [ + { + "pattern": "^(?!0{32}$)[0-9a-f]{32}$", + "maxLength": 32 + }, + { + "$ref": "#/$defs/UUID" + } + ] + }, + "SpanID": { + "type": "string", + "pattern": "^(?!0{16}$)[0-9a-f]{16}$", + "maxLength": 16 + }, + "Token": { + "type": "string", + "pattern": "^[a-zA-Z0-9_-]{1,128}$", + "maxLength": 128 + }, + "SafeInteger": { + "type": "integer", + "minimum": 0, + "maximum": 9007199254740991 + }, + "Timestamp": { + "type": "string", + "format": "date-time", + "maxLength": 40 + }, + "Direction": { + "enum": [ + "input", + "output", + "mixed" + ] + }, + "Modality": { + "enum": [ + "audio", + "image", + "video", + "document", + "file" + ] + }, + "MIME": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16", + "image/png", + "image/jpeg", + "image/webp", + "video/mp4", + "video/webm", + "application/pdf", + "application/octet-stream" + ] + }, + "Purpose": { + "enum": [ + "conversation_recording", + "turn_recording", + "model_input", + "model_output", + "tool_result", + "computer_screenshot", + "diagnostic", + "document" + ] + }, + "SourceKind": { + "enum": [ + "Bytes", + "Blob", + "RemoteUrl", + "LocalFile", + "OwnedRecordingFile", + "ProviderFile" + ] + }, + "Status": { + "enum": [ + "pending_upload", + "importing", + "validating", + "ready", + "failed", + "rejected", + "expired", + "deleted" + ] + }, + "Reason": { + "enum": [ + "queued", + "disabled", + "bootstrap_pending", + "policy_denied", + "credential_scope_unsupported", + "source_unavailable", + "unsampled", + "too_large", + "queue_full", + "unsupported_version", + "endpoint_unconfigured", + "scope_unresolved", + "correlation_unavailable", + "redaction_unavailable", + "recording_disabled", + "binding_pending", + "not_found", + "conflict", + "throttled", + "validation_failed", + "expired", + "deleted", + "incomplete", + "ready" + ] + }, + "Scope": { + "type": "object", + "additionalProperties": false, + "required": [ + "organization_id", + "workspace_id", + "project_id" + ], + "properties": { + "organization_id": { + "$ref": "#/$defs/UUID" + }, + "workspace_id": { + "$ref": "#/$defs/UUID" + }, + "project_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "Parent": { + "type": "object", + "additionalProperties": false, + "required": [ + "trace_id", + "span_id" + ], + "properties": { + "trace_id": { + "$ref": "#/$defs/TraceInput" + }, + "span_id": { + "$ref": "#/$defs/SpanID" + } + } + }, "Association": { "type": "object", "additionalProperties": false, "required": [ - "capture_session_id", - "correlation_nonce", - "parent" + "capture_session_id", + "correlation_nonce", + "parent" + ], + "properties": { + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "correlation_nonce": { + "$ref": "#/$defs/UUID" + }, + "parent": { + "$ref": "#/$defs/Parent" + } + } + }, + "Reference": { + "type": "object", + "additionalProperties": false, + "required": [ + "attachment_id", + "occurrence_id", + "direction", + "modality", + "mime_type" + ], + "properties": { + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "mime_type": { + "$ref": "#/$defs/MIME" + }, + "purpose": { + "$ref": "#/$defs/Purpose" + }, + "message_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "part_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "role": { + "enum": [ + "user", + "assistant", + "tool", + "system", + "unknown" + ] + }, + "channel": { + "type": "integer", + "minimum": 0, + "maximum": 31 + }, + "conversation_id": { + "$ref": "#/$defs/Token" + }, + "turn_id": { + "$ref": "#/$defs/Token" + }, + "tool_call_id": { + "$ref": "#/$defs/Token" + } + }, + "allOf": [ + { + "if": { + "properties": { + "modality": { + "const": "audio" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "image/png", + "image/jpeg", + "image/webp" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "video" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "video/mp4", + "video/webm" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "document" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/pdf" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "file" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/octet-stream" + ] + } + } + } + } + ] + }, + "References": { + "type": "array", + "maxItems": 64, + "items": { + "$ref": "#/$defs/Reference" + }, + "uniqueItems": true + }, + "SpanAttributes": { + "type": "object", + "additionalProperties": false, + "required": [ + "fi.attachment.schema_version", + "fi.attachment.refs" + ], + "properties": { + "fi.attachment.schema_version": { + "const": 1 + }, + "fi.attachment.refs": { + "type": "string", + "maxLength": 16384, + "contentMediaType": "application/json", + "contentSchema": { + "$ref": "#/$defs/References" + } + }, + "fi.attachment.capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "fi.attachment.correlation_nonce": { + "$ref": "#/$defs/UUID" + } + }, + "dependentRequired": { + "fi.attachment.capture_session_id": [ + "fi.attachment.correlation_nonce" + ], + "fi.attachment.correlation_nonce": [ + "fi.attachment.capture_session_id" + ] + } + }, + "MessageURI": { + "type": "object", + "additionalProperties": false, + "required": [ + "type", + "modality", + "mime_type", + "uri" + ], + "properties": { + "type": { + "const": "uri" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "mime_type": { + "$ref": "#/$defs/MIME" + }, + "uri": { + "type": "string", + "pattern": "^fi-attachment:(?!00000000-0000-0000-0000-000000000000$)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", + "maxLength": 50 + } + }, + "allOf": [ + { + "if": { + "properties": { + "modality": { + "const": "audio" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "image/png", + "image/jpeg", + "image/webp" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "video" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "video/mp4", + "video/webm" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "document" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/pdf" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "file" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/octet-stream" + ] + } + } + } + } + ] + }, + "BootstrapRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_versions", + "project_name", + "project_type", + "capture_session_id", + "correlation_nonce" + ], + "properties": { + "schema_versions": { + "type": "array", + "minItems": 1, + "maxItems": 8, + "uniqueItems": true, + "items": { + "type": "integer", + "minimum": 1, + "maximum": 65535 + } + }, + "project_name": { + "type": "string", + "minLength": 1, + "maxLength": 255 + }, + "project_type": { + "type": "string", + "minLength": 1, + "maxLength": 64 + }, + "workspace_id": { + "$ref": "#/$defs/UUID" + }, + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "correlation_nonce": { + "$ref": "#/$defs/UUID" + } + } + }, + "Policy": { + "type": "object", + "additionalProperties": false, + "required": [ + "version", + "enabled", + "allowed_sources", + "allowed_modalities", + "require_media_redaction", + "require_metadata_removal", + "allow_unredacted_media_with_text_pii", + "record_audio", + "record_video" + ], + "properties": { + "version": { + "$ref": "#/$defs/Token" + }, + "enabled": { + "type": "boolean" + }, + "allowed_sources": { + "type": "array", + "uniqueItems": true, + "maxItems": 6, + "items": { + "$ref": "#/$defs/SourceKind" + } + }, + "allowed_modalities": { + "type": "array", + "uniqueItems": true, + "maxItems": 5, + "items": { + "$ref": "#/$defs/Modality" + } + }, + "require_media_redaction": { + "type": "boolean" + }, + "require_metadata_removal": { + "type": "boolean" + }, + "allow_unredacted_media_with_text_pii": { + "type": "boolean" + }, + "record_audio": { + "type": "boolean" + }, + "record_video": { + "type": "boolean" + } + } + }, + "Limits": { + "type": "object", + "additionalProperties": false, + "required": [ + "max_upload_bytes", + "segment_bytes", + "segment_duration_ms", + "recording_bytes", + "recording_duration_ms", + "active_transfers", + "active_recordings", + "reserved_bytes", + "validation_jobs", + "initializations_per_minute", + "links_per_minute", + "upload_bytes_per_second", + "playback_bytes_per_second", + "transfer_timeout_seconds", + "grant_ttl_seconds", + "revocation_check_seconds" + ], + "properties": { + "max_upload_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "segment_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 8388608 + }, + "segment_duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 30000 + }, + "recording_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "recording_duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + }, + "active_transfers": { + "type": "integer", + "minimum": 1, + "maximum": 16 + }, + "active_recordings": { + "type": "integer", + "minimum": 1, + "maximum": 4 + }, + "reserved_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "validation_jobs": { + "type": "integer", + "minimum": 1, + "maximum": 1024 + }, + "initializations_per_minute": { + "type": "integer", + "minimum": 1, + "maximum": 120 + }, + "links_per_minute": { + "type": "integer", + "minimum": 1, + "maximum": 1000 + }, + "upload_bytes_per_second": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "playback_bytes_per_second": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "transfer_timeout_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 600 + }, + "grant_ttl_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 300 + }, + "revocation_check_seconds": { + "type": "integer", + "minimum": 1, + "maximum": 5 + } + } + }, + "BootstrapResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "scope", + "capture_session_id", + "policy", + "limits", + "expires_at", + "transfer_modes" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "scope": { + "$ref": "#/$defs/Scope" + }, + "capture_session_id": { + "$ref": "#/$defs/UUID" + }, + "policy": { + "$ref": "#/$defs/Policy" + }, + "limits": { + "$ref": "#/$defs/Limits" + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "transfer_modes": { + "const": [ + "authenticated_stream" + ] + } + } + }, + "UploadRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "attachment_id", + "occurrence_id", + "association", + "policy_version", + "deletion_generation", + "mime_type", + "modality", + "direction", + "source_kind", + "declared_bytes" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "association": { + "$ref": "#/$defs/Association" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "mime_type": { + "$ref": "#/$defs/MIME" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "source_kind": { + "$ref": "#/$defs/SourceKind" + }, + "purpose": { + "$ref": "#/$defs/Purpose" + }, + "declared_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "message_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "part_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "segment_index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "conversation_id": { + "$ref": "#/$defs/Token" + }, + "turn_id": { + "$ref": "#/$defs/Token" + }, + "tool_call_id": { + "$ref": "#/$defs/Token" + } + }, + "dependentRequired": { + "recording_id": [ + "segment_index" + ], + "segment_index": [ + "recording_id" + ] + }, + "allOf": [ + { + "if": { + "properties": { + "modality": { + "const": "audio" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "image/png", + "image/jpeg", + "image/webp" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "video" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "video/mp4", + "video/webm" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "document" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/pdf" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "file" + } + } + }, + "then": { + "properties": { + "mime_type": { + "enum": [ + "application/octet-stream" + ] + } + } + } + }, + { + "if": { + "properties": { + "modality": { + "const": "image" + } + } + }, + "then": { + "properties": { + "declared_bytes": { + "maximum": 20971520 + } + } + } + }, + { + "if": { + "required": [ + "recording_id" + ] + }, + "then": { + "properties": { + "declared_bytes": { + "maximum": 8388608 + } + } + } + } + ] + }, + "UploadResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload_id", + "attachment_id", + "occurrence_id", + "state", + "reserved_bytes", + "expires_at", + "transfer_mode", + "write_capability" + ], + "properties": { + "upload_id": { + "$ref": "#/$defs/UUID" + }, + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "const": "pending_upload" + }, + "reserved_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "transfer_mode": { + "const": "authenticated_stream" + }, + "write_capability": { + "type": "string", + "minLength": 16, + "maxLength": 4096, + "pattern": "^[a-zA-Z0-9_.-]+$", + "description": "Secret broker-issued capability for this exact upload/occurrence; never log/export/cache this private response or reuse it for another job." + } + } + }, + "CompleteRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "policy_version", + "deletion_generation" + ], + "properties": { + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + } + } + }, + "StatusResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload_id", + "state", + "reason" + ], + "properties": { + "upload_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "$ref": "#/$defs/Status" + }, + "reason": { + "$ref": "#/$defs/Reason" + } + } + }, + "ImportSource": { + "oneOf": [ + { + "type": "object", + "additionalProperties": false, + "required": [ + "kind", + "envelope_id" + ], + "properties": { + "kind": { + "const": "RemoteUrlEnvelope" + }, + "envelope_id": { + "$ref": "#/$defs/UUID" + } + } + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "kind", + "connection_id", + "registered_output_id" + ], + "properties": { + "kind": { + "const": "ProviderFile" + }, + "connection_id": { + "$ref": "#/$defs/UUID" + }, + "registered_output_id": { + "$ref": "#/$defs/UUID" + } + } + } + ] + }, + "ImportRequest": { + "oneOf": [ + { + "$ref": "#/$defs/SingleAttachmentImportRequest" + }, + { + "$ref": "#/$defs/RecordingImportRequest" + } + ] + }, + "ImportResponse": { + "oneOf": [ + { + "$ref": "#/$defs/SingleAttachmentImportResponse" + }, + { + "$ref": "#/$defs/RecordingImportResponse" + } + ] + }, + "LinkRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "source_occurrence_id", + "source_parent", + "target_parent", + "occurrence_id", + "policy_version", + "deletion_generation" + ], + "properties": { + "source_occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "source_parent": { + "$ref": "#/$defs/Parent" + }, + "target_parent": { + "$ref": "#/$defs/Parent" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + } + } + }, + "Occurrence": { + "type": "object", + "additionalProperties": false, + "required": [ + "reference", + "scope", + "parent", + "state", + "binding", + "capture_complete", + "policy_version", + "deletion_generation", + "expires_at" + ], + "properties": { + "reference": { + "$ref": "#/$defs/Reference" + }, + "scope": { + "$ref": "#/$defs/Scope" + }, + "parent": { + "$ref": "#/$defs/CanonicalParent" + }, + "state": { + "$ref": "#/$defs/Status" + }, + "binding": { + "enum": [ + "pending", + "bound" + ] + }, + "capture_complete": { + "type": "boolean" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "recording_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "OccurrencePage": { + "type": "object", + "additionalProperties": false, + "required": [ + "items", + "next_cursor" + ], + "properties": { + "items": { + "type": "array", + "maxItems": 100, + "items": { + "$ref": "#/$defs/Occurrence" + } + }, + "next_cursor": { + "oneOf": [ + { + "type": "null" + }, + { + "$ref": "#/$defs/Token" + } + ] + } + } + }, + "ResolveItem": { + "type": "object", + "additionalProperties": false, + "required": [ + "occurrence_id", + "parent", + "representation" + ], + "properties": { + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "parent": { + "$ref": "#/$defs/Parent" + }, + "representation": { + "enum": [ + "original", + "playable", + "channel", + "peaks", + "thumbnail" + ] + }, + "channel": { + "type": "integer", + "minimum": 0, + "maximum": 31 + } + }, + "allOf": [ + { + "if": { + "properties": { + "representation": { + "const": "channel" + } + } + }, + "then": { + "required": [ + "channel" + ] + }, + "else": { + "not": { + "required": [ + "channel" + ] + } + } + } + ] + }, + "ResolveRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "items" + ], + "properties": { + "items": { + "type": "array", + "minItems": 1, + "maxItems": 64, + "items": { + "$ref": "#/$defs/ResolveItem" + } + } + } + }, + "ResolveResult": { + "oneOf": [ + { + "type": "object", + "additionalProperties": false, + "required": [ + "occurrence_id", + "status", + "gateway_path", + "expires_at" + ], + "properties": { + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "status": { + "const": "ready" + }, + "gateway_path": { + "type": "string", + "pattern": "^/tracer/v1/attachment-media/(?!00000000-0000-0000-0000-000000000000/)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/[a-zA-Z0-9_-]{1,128}$", + "maxLength": 194 + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + } + } + }, + { + "type": "object", + "additionalProperties": false, + "required": [ + "occurrence_id", + "status" + ], + "properties": { + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "status": { + "enum": [ + "not_found", + "pending", + "failed", + "expired", + "deleted" + ] + } + } + } + ] + }, + "ResolveResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "items" + ], + "properties": { + "items": { + "type": "array", + "maxItems": 64, + "items": { + "$ref": "#/$defs/ResolveResult" + } + } + } + }, + "WriteCapabilityClaims": { + "type": "object", + "additionalProperties": false, + "required": [ + "audience", + "actor_id", + "scope", + "association", + "upload_id", + "attachment_id", + "occurrence_id", + "policy_version", + "deletion_generation", + "reserved_bytes", + "operations", + "expires_at" + ], + "properties": { + "audience": { + "const": "fi-attachment-write" + }, + "actor_id": { + "$ref": "#/$defs/UUID" + }, + "scope": { + "$ref": "#/$defs/Scope" + }, + "association": { + "$ref": "#/$defs/CanonicalAssociation" + }, + "upload_id": { + "$ref": "#/$defs/UUID" + }, + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "reserved_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 52428800 + }, + "operations": { + "type": "array", + "minItems": 1, + "maxItems": 5, + "uniqueItems": true, + "items": { + "enum": [ + "create", + "upload", + "complete", + "abort", + "status" + ] + } + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + }, + "recording_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "PlaybackGrantClaims": { + "type": "object", + "additionalProperties": false, + "required": [ + "audience", + "viewer_id", + "application_session_id", + "media_session_id", + "scope", + "occurrence_id", + "parent", + "representation", + "methods", + "policy_version", + "deletion_generation", + "expires_at" + ], + "properties": { + "audience": { + "const": "fi-attachment-playback" + }, + "viewer_id": { + "$ref": "#/$defs/UUID" + }, + "application_session_id": { + "$ref": "#/$defs/UUID" + }, + "media_session_id": { + "$ref": "#/$defs/UUID" + }, + "scope": { + "$ref": "#/$defs/Scope" + }, + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "parent": { + "$ref": "#/$defs/CanonicalParent" + }, + "representation": { + "enum": [ + "original", + "playable", + "channel", + "peaks", + "thumbnail" + ] + }, + "channel": { + "type": "integer", + "minimum": 0, + "maximum": 31 + }, + "methods": { + "const": [ + "GET", + "HEAD" + ] + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "expires_at": { + "$ref": "#/$defs/Timestamp" + } + }, + "allOf": [ + { + "if": { + "properties": { + "representation": { + "const": "channel" + } + } + }, + "then": { + "required": [ + "channel" + ] + }, + "else": { + "not": { + "required": [ + "channel" + ] + } + } + } + ] + }, + "Track": { + "type": "object", + "additionalProperties": false, + "required": [ + "track_id", + "channels", + "direction", + "role" ], "properties": { - "capture_session_id": { + "track_id": { "$ref": "#/$defs/UUID" }, - "correlation_nonce": { - "$ref": "#/$defs/UUID" + "channels": { + "type": "array", + "minItems": 1, + "maxItems": 32, + "uniqueItems": true, + "items": { + "type": "integer", + "minimum": 0, + "maximum": 31 + } }, - "parent": { - "$ref": "#/$defs/Parent" + "direction": { + "$ref": "#/$defs/Direction" + }, + "role": { + "enum": [ + "user", + "assistant", + "mixed", + "unknown" + ] } } }, - "BootstrapRequest": { + "Segment": { "type": "object", "additionalProperties": false, "required": [ - "schema_versions", - "project_name", - "project_type", - "capture_session_id", - "correlation_nonce" + "occurrence_id", + "index", + "start_ms", + "duration_ms" ], "properties": { - "schema_versions": { - "type": "array", - "minItems": 1, - "maxItems": 8, - "uniqueItems": true, - "items": { - "type": "integer", - "minimum": 1, - "maximum": 65535 - } - }, - "project_name": { - "type": "string", - "minLength": 1, - "maxLength": 255 + "occurrence_id": { + "$ref": "#/$defs/UUID" }, - "project_type": { - "type": "string", - "minLength": 1, - "maxLength": 64 + "index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 }, - "workspace_id": { - "$ref": "#/$defs/UUID" + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 }, - "capture_session_id": { - "$ref": "#/$defs/UUID" + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 30000 }, - "correlation_nonce": { + "track_id": { "$ref": "#/$defs/UUID" } } }, - "BootstrapResponse": { + "Gap": { "type": "object", "additionalProperties": false, "required": [ - "schema_version", - "scope", - "capture_session_id", - "policy", - "limits", - "expires_at", - "transfer_modes" + "start_ms", + "duration_ms", + "reason" ], "properties": { - "schema_version": { - "const": 1 - }, - "scope": { - "$ref": "#/$defs/Scope" - }, - "capture_session_id": { - "$ref": "#/$defs/UUID" - }, - "policy": { - "$ref": "#/$defs/Policy" - }, - "limits": { - "$ref": "#/$defs/Limits" + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 }, - "expires_at": { - "$ref": "#/$defs/Timestamp" + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 }, - "transfer_modes": { - "const": [ - "authenticated_stream" + "reason": { + "enum": [ + "queue_full", + "bootstrap_pending", + "source_unavailable", + "policy_denied", + "truncated", + "incomplete" ] + }, + "track_id": { + "$ref": "#/$defs/UUID" } } }, - "CompleteRequest": { + "PlayoutInterval": { "type": "object", "additionalProperties": false, "required": [ - "policy_version", - "deletion_generation" + "start_ms", + "duration_ms", + "evidence" ], "properties": { - "policy_version": { - "$ref": "#/$defs/Token" + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 }, - "deletion_generation": { - "$ref": "#/$defs/SafeInteger" + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + }, + "evidence": { + "enum": [ + "generated", + "played", + "unknown", + "truncated" + ] } } }, - "Direction": { - "enum": [ - "input", - "output", - "mixed" - ] - }, - "Limits": { + "RecordingManifest": { "type": "object", "additionalProperties": false, "required": [ - "max_upload_bytes", - "segment_bytes", - "segment_duration_ms", - "recording_bytes", - "recording_duration_ms", - "active_transfers", - "active_recordings", - "reserved_bytes", - "validation_jobs", - "initializations_per_minute", - "links_per_minute", - "upload_bytes_per_second", - "playback_bytes_per_second", - "transfer_timeout_seconds", - "grant_ttl_seconds", - "revocation_check_seconds" + "schema_version", + "recording_id", + "timebase", + "sample_format", + "sample_rate_hz", + "channels", + "codec", + "container", + "layout", + "tracks", + "segments", + "gaps", + "playout", + "capture_complete", + "duration_ms" ], "properties": { - "max_upload_bytes": { - "type": "integer", - "minimum": 1, - "maximum": 52428800 + "schema_version": { + "const": 1 }, - "segment_bytes": { - "type": "integer", - "minimum": 1, - "maximum": 8388608 + "recording_id": { + "$ref": "#/$defs/UUID" }, - "segment_duration_ms": { + "timebase": { + "const": "session_relative_ms" + }, + "sample_format": { + "enum": [ + "s16le", + "s24le", + "s32le", + "f32le", + "encoded" + ] + }, + "sample_rate_hz": { "type": "integer", - "minimum": 1, - "maximum": 30000 + "minimum": 8000, + "maximum": 192000 }, - "recording_bytes": { + "channels": { "type": "integer", "minimum": 1, - "maximum": 1073741824 + "maximum": 32 + }, + "codec": { + "enum": [ + "pcm", + "opus", + "mp3", + "aac", + "flac" + ] }, - "recording_duration_ms": { + "container": { + "enum": [ + "wav", + "ogg", + "mp3", + "mp4", + "webm", + "flac", + "raw" + ] + }, + "layout": { + "enum": [ + "mixed", + "stereo", + "separate_tracks" + ] + }, + "tracks": { + "type": "array", + "minItems": 1, + "maxItems": 32, + "items": { + "$ref": "#/$defs/Track" + } + }, + "segments": { + "type": "array", + "maxItems": 65536, + "items": { + "$ref": "#/$defs/Segment" + } + }, + "gaps": { + "type": "array", + "maxItems": 65536, + "items": { + "$ref": "#/$defs/Gap" + } + }, + "playout": { + "type": "array", + "maxItems": 65536, + "items": { + "$ref": "#/$defs/PlayoutInterval" + } + }, + "capture_complete": { + "type": "boolean" + }, + "duration_ms": { "type": "integer", - "minimum": 1, + "minimum": 0, "maximum": 7200000 + } + } + }, + "OperationRegistryEntry": { + "type": "object", + "additionalProperties": false, + "required": [ + "package", + "language", + "operation", + "upstream_version", + "source_kind", + "direction", + "modality", + "lifecycle", + "span_capability", + "attachment_capability", + "policy_requirements", + "component_test_state", + "integrated_gate" + ], + "properties": { + "package": { + "type": "string", + "pattern": "^[a-z0-9@_./-]{1,128}$", + "maxLength": 128 }, - "active_transfers": { - "type": "integer", - "minimum": 1, - "maximum": 16 + "language": { + "enum": [ + "python", + "typescript" + ] }, - "active_recordings": { - "type": "integer", - "minimum": 1, - "maximum": 4 + "operation": { + "$ref": "#/$defs/Token" }, - "reserved_bytes": { - "type": "integer", - "minimum": 1, - "maximum": 1073741824 + "upstream_version": { + "oneOf": [ + { + "type": "null" + }, + { + "type": "string", + "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+([.-][a-zA-Z0-9.]+)?$", + "maxLength": 64 + } + ] }, - "validation_jobs": { - "type": "integer", - "minimum": 1, - "maximum": 1024 + "source_kind": { + "$ref": "#/$defs/SourceKind" }, - "initializations_per_minute": { - "type": "integer", - "minimum": 1, - "maximum": 120 + "direction": { + "$ref": "#/$defs/Direction" }, - "links_per_minute": { - "type": "integer", - "minimum": 1, - "maximum": 1000 + "modality": { + "$ref": "#/$defs/Modality" }, - "upload_bytes_per_second": { - "type": "integer", - "minimum": 1, - "maximum": 1073741824 + "lifecycle": { + "enum": [ + "application_consumed", + "explicit_session_binding", + "completed_provider_output" + ] }, - "playback_bytes_per_second": { - "type": "integer", - "minimum": 1, - "maximum": 1073741824 + "span_capability": { + "enum": [ + "native", + "instrumented", + "unsupported", + "unqualified" + ] }, - "transfer_timeout_seconds": { - "type": "integer", - "minimum": 1, - "maximum": 600 + "attachment_capability": { + "enum": [ + "capture", + "reference_only", + "unsupported", + "unqualified" + ] + }, + "policy_requirements": { + "type": "array", + "uniqueItems": true, + "maxItems": 8, + "items": { + "enum": [ + "enabled", + "source_authorized", + "pii_intersection", + "metadata_policy", + "record_audio", + "record_video", + "provider_connection", + "owned_file_lease" + ] + } }, - "grant_ttl_seconds": { - "type": "integer", - "minimum": 1, - "maximum": 300 + "component_test_state": { + "enum": [ + "not_run", + "passed", + "failed", + "blocked" + ] }, - "revocation_check_seconds": { - "type": "integer", - "minimum": 1, - "maximum": 5 + "integrated_gate": { + "enum": [ + "integrated_not_run", + "Q01", + "Q02", + "Q03", + "Q04", + "blocked" + ] + }, + "evidence_digest": { + "type": "string", + "pattern": "^[0-9a-f]{64}$", + "maxLength": 64 + } + }, + "allOf": [ + { + "if": { + "properties": { + "attachment_capability": { + "const": "capture" + } + } + }, + "then": { + "required": [ + "evidence_digest" + ], + "properties": { + "upstream_version": { + "type": "string" + }, + "component_test_state": { + "const": "passed" + }, + "integrated_gate": { + "enum": [ + "Q02", + "Q03", + "Q04" + ] + } + } + } } - } - }, - "MIME": { - "enum": [ - "audio/wav", - "audio/ogg", - "audio/mpeg", - "audio/mp4", - "audio/webm", - "audio/flac", - "audio/L16", - "image/png", - "image/jpeg", - "image/webp", - "video/mp4", - "video/webm", - "application/pdf", - "application/octet-stream" - ] - }, - "Modality": { - "enum": [ - "audio", - "image", - "video", - "document", - "file" ] }, - "Parent": { + "Error": { "type": "object", "additionalProperties": false, "required": [ - "trace_id", - "span_id" + "code", + "request_id" ], "properties": { - "trace_id": { - "$ref": "#/$defs/TraceInput" + "code": { + "$ref": "#/$defs/Reason" }, - "span_id": { - "$ref": "#/$defs/SpanID" + "request_id": { + "$ref": "#/$defs/UUID" } } }, - "Policy": { + "AttachmentMetadata": { "type": "object", "additionalProperties": false, "required": [ - "version", - "enabled", - "allowed_sources", - "allowed_modalities", - "require_media_redaction", - "require_metadata_removal", - "allow_unredacted_media_with_text_pii", - "record_audio", - "record_video" + "attachment_id", + "modality", + "source_kind", + "provider", + "purpose", + "policy_version", + "state", + "created_at" ], "properties": { - "version": { - "$ref": "#/$defs/Token" + "attachment_id": { + "$ref": "#/$defs/UUID" }, - "enabled": { - "type": "boolean" + "modality": { + "$ref": "#/$defs/Modality" }, - "allowed_sources": { - "type": "array", - "uniqueItems": true, - "maxItems": 6, - "items": { - "$ref": "#/$defs/SourceKind" - } + "source_kind": { + "$ref": "#/$defs/SourceKind" }, - "allowed_modalities": { - "type": "array", - "uniqueItems": true, - "maxItems": 5, - "items": { - "$ref": "#/$defs/Modality" - } + "provider": { + "enum": [ + "pipecat", + "livekit", + "unknown" + ] }, - "require_media_redaction": { - "type": "boolean" + "purpose": { + "$ref": "#/$defs/Purpose" }, - "require_metadata_removal": { - "type": "boolean" + "policy_version": { + "$ref": "#/$defs/Token" }, - "allow_unredacted_media_with_text_pii": { - "type": "boolean" + "state": { + "$ref": "#/$defs/Status" }, - "record_audio": { - "type": "boolean" + "created_at": { + "$ref": "#/$defs/Timestamp" }, - "record_video": { - "type": "boolean" + "completed_at": { + "$ref": "#/$defs/Timestamp" } } }, - "Purpose": { - "enum": [ - "conversation_recording", - "turn_recording", - "model_input", - "model_output", - "tool_result", - "computer_screenshot", - "diagnostic", - "document" - ] - }, - "Reason": { - "enum": [ - "queued", - "disabled", - "bootstrap_pending", - "policy_denied", - "credential_scope_unsupported", - "source_unavailable", - "unsampled", - "too_large", - "queue_full", - "unsupported_version", - "endpoint_unconfigured", - "scope_unresolved", - "correlation_unavailable", - "redaction_unavailable", - "recording_disabled", - "binding_pending", - "not_found", - "conflict", - "throttled", - "validation_failed", - "expired", - "deleted", - "incomplete", - "ready" - ] - }, - "SafeInteger": { - "type": "integer", - "minimum": 0, - "maximum": 9007199254740991 - }, - "Scope": { + "CanonicalParent": { "type": "object", "additionalProperties": false, "required": [ - "organization_id", - "workspace_id", - "project_id" + "trace_id", + "span_id" ], "properties": { - "organization_id": { - "$ref": "#/$defs/UUID" - }, - "workspace_id": { + "trace_id": { "$ref": "#/$defs/UUID" }, - "project_id": { - "$ref": "#/$defs/UUID" + "span_id": { + "$ref": "#/$defs/SpanID" } } }, - "SourceKind": { - "enum": [ - "Bytes", - "Blob", - "RemoteUrl", - "LocalFile", - "OwnedRecordingFile", - "ProviderFile" - ] - }, - "SpanID": { - "type": "string", - "pattern": "^(?!0{16}$)[0-9a-f]{16}$", - "maxLength": 16 - }, - "Status": { - "enum": [ - "pending_upload", - "importing", - "validating", - "ready", - "failed", - "rejected", - "expired", - "deleted" - ] - }, - "StatusResponse": { + "CanonicalAssociation": { "type": "object", "additionalProperties": false, "required": [ - "upload_id", - "state", - "reason" + "capture_session_id", + "correlation_nonce", + "parent" ], "properties": { - "upload_id": { + "capture_session_id": { "$ref": "#/$defs/UUID" }, - "state": { - "$ref": "#/$defs/Status" + "correlation_nonce": { + "$ref": "#/$defs/UUID" }, - "reason": { - "$ref": "#/$defs/Reason" + "parent": { + "$ref": "#/$defs/CanonicalParent" } } }, - "Timestamp": { - "type": "string", - "format": "date-time", - "maxLength": 40 - }, - "Token": { - "type": "string", - "pattern": "^[a-zA-Z0-9_-]{1,128}$", - "maxLength": 128 + "SingleAttachmentImportRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload", + "source" + ], + "properties": { + "upload": { + "$ref": "#/$defs/UploadRequest" + }, + "source": { + "$ref": "#/$defs/ImportSource" + } + } }, - "TraceInput": { - "type": "string", - "oneOf": [ - { - "pattern": "^(?!0{32}$)[0-9a-f]{32}$", - "maxLength": 32 + "SingleAttachmentImportResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "job_id", + "upload_id", + "state" + ], + "properties": { + "job_id": { + "$ref": "#/$defs/UUID" }, - { + "upload_id": { "$ref": "#/$defs/UUID" + }, + "state": { + "const": "importing" } - ] - }, - "UUID": { - "type": "string", - "pattern": "^(?!00000000-0000-0000-0000-000000000000$)[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", - "maxLength": 36 + } }, - "UploadRequest": { + "CompletedRecordingImport": { "type": "object", "additionalProperties": false, "required": [ "schema_version", - "attachment_id", - "occurrence_id", "association", "policy_version", "deletion_generation", "mime_type", - "modality", "direction", "source_kind", - "declared_bytes" + "recording_id", + "modality", + "declared_bytes", + "declared_duration_ms" ], "properties": { "schema_version": { "const": 1 }, - "attachment_id": { - "$ref": "#/$defs/UUID" - }, - "occurrence_id": { - "$ref": "#/$defs/UUID" - }, "association": { "$ref": "#/$defs/Association" }, @@ -502,236 +2109,105 @@ "$ref": "#/$defs/SafeInteger" }, "mime_type": { - "$ref": "#/$defs/MIME" - }, - "modality": { - "$ref": "#/$defs/Modality" + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] }, "direction": { "$ref": "#/$defs/Direction" }, "source_kind": { - "$ref": "#/$defs/SourceKind" + "enum": [ + "ProviderFile", + "RemoteUrl" + ] }, - "purpose": { - "$ref": "#/$defs/Purpose" + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "modality": { + "const": "audio" }, "declared_bytes": { "type": "integer", "minimum": 1, - "maximum": 52428800 - }, - "message_index": { - "type": "integer", - "minimum": 0, - "maximum": 65535 - }, - "part_index": { - "type": "integer", - "minimum": 0, - "maximum": 65535 - }, - "recording_id": { - "$ref": "#/$defs/UUID" + "maximum": 1073741824 }, - "segment_index": { + "declared_duration_ms": { "type": "integer", - "minimum": 0, - "maximum": 65535 - }, - "conversation_id": { - "$ref": "#/$defs/Token" - }, - "turn_id": { - "$ref": "#/$defs/Token" - }, - "tool_call_id": { - "$ref": "#/$defs/Token" + "minimum": 1, + "maximum": 7200000 } }, - "dependentRequired": { - "recording_id": [ - "segment_index" - ], - "segment_index": [ - "recording_id" - ] - }, - "allOf": [ - { - "if": { - "properties": { - "modality": { - "const": "audio" - } - } - }, - "then": { - "properties": { - "mime_type": { - "enum": [ - "audio/wav", - "audio/ogg", - "audio/mpeg", - "audio/mp4", - "audio/webm", - "audio/flac", - "audio/L16" - ] - } - } - } - }, - { - "if": { - "properties": { - "modality": { - "const": "image" - } - } - }, - "then": { - "properties": { - "mime_type": { - "enum": [ - "image/png", - "image/jpeg", - "image/webp" - ] - } - } - } - }, - { - "if": { - "properties": { - "modality": { - "const": "video" - } - } - }, - "then": { - "properties": { - "mime_type": { - "enum": [ - "video/mp4", - "video/webm" - ] - } - } - } - }, - { - "if": { - "properties": { - "modality": { - "const": "document" - } - } - }, - "then": { - "properties": { - "mime_type": { - "enum": [ - "application/pdf" - ] - } - } - } - }, - { - "if": { - "properties": { - "modality": { - "const": "file" - } - } - }, - "then": { - "properties": { - "mime_type": { - "enum": [ - "application/octet-stream" - ] - } - } - } + "description": "Admission for a new completed audio recording, not an upload or segment. Exact source length and ceil-to-millisecond duration are required. Server produces bounded segments; no whole-source occurrence is readable. Negotiated limits and atomic reservations also apply." + }, + "RecordingImportRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "mode", + "recording", + "source" + ], + "properties": { + "mode": { + "const": "completed_recording" }, - { - "if": { - "properties": { - "modality": { - "const": "image" - } - } - }, - "then": { - "properties": { - "declared_bytes": { - "maximum": 20971520 - } - } - } + "recording": { + "$ref": "#/$defs/CompletedRecordingImport" }, - { - "if": { - "required": [ - "recording_id" - ] - }, - "then": { - "properties": { - "declared_bytes": { - "maximum": 8388608 - } - } - } + "source": { + "$ref": "#/$defs/ImportSource" } - ] + } }, - "UploadResponse": { + "RecordingImportResponse": { "type": "object", "additionalProperties": false, "required": [ - "upload_id", - "attachment_id", - "occurrence_id", - "state", - "reserved_bytes", - "expires_at", - "transfer_mode", - "write_capability" + "mode", + "job_id", + "recording_id", + "state" ], "properties": { - "upload_id": { - "$ref": "#/$defs/UUID" + "mode": { + "const": "completed_recording" }, - "attachment_id": { + "job_id": { "$ref": "#/$defs/UUID" }, - "occurrence_id": { + "recording_id": { "$ref": "#/$defs/UUID" }, "state": { - "const": "pending_upload" - }, - "reserved_bytes": { - "type": "integer", - "minimum": 1, - "maximum": 52428800 - }, - "expires_at": { - "$ref": "#/$defs/Timestamp" + "const": "importing" + } + } + }, + "ImportStatusResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "job_id", + "state", + "reason" + ], + "properties": { + "job_id": { + "$ref": "#/$defs/UUID" }, - "transfer_mode": { - "const": "authenticated_stream" + "state": { + "$ref": "#/$defs/Status" }, - "write_capability": { - "type": "string", - "minLength": 16, - "maxLength": 4096, - "pattern": "^[a-zA-Z0-9_.-]+$", - "description": "Secret broker-issued capability for this exact upload/occurrence; never log/export/cache this private response or reuse it for another job." + "reason": { + "$ref": "#/$defs/Reason" } } } diff --git a/python/fi_instrumentation/attachments/admission.py b/python/fi_instrumentation/attachments/admission.py new file mode 100644 index 000000000..ed6774ff2 --- /dev/null +++ b/python/fi_instrumentation/attachments/admission.py @@ -0,0 +1,144 @@ +"""Preflight tickets (design section 1): admission before any capture or decode. + +A ticket is single use. It holds one descriptor and a byte budget, never the +source. It is re-checked when used and can only narrow. Expiry is lazy (no +timer); a ticket collected unused returns its budget through ``weakref.finalize``. +""" + +import time +import weakref +from typing import Optional + +from .types import AttachmentHandle, CorrelationHandle + + +class _Reservation: + """Budget owned by a ticket/stream; released exactly once.""" + + __slots__ = ("_manager", "nbytes", "descriptors", "released", "__weakref__") + + def __init__(self, manager, nbytes: int, descriptors: int = 1): + self._manager = weakref.ref(manager) + self.nbytes, self.descriptors, self.released = nbytes, descriptors, False + + def release(self) -> None: + if self.released: + return + self.released = True + manager = self._manager() + if manager is not None: + manager._release(self.nbytes, self.descriptors) + + def shrink(self, nbytes: int) -> None: + manager = self._manager() + if manager is not None and not self.released and nbytes < self.nbytes: + manager._release(self.nbytes - nbytes, 0) + self.nbytes = nbytes + + +class AdmissionTicket: + """Result of ``AttachmentManager.preflight``. ``admitted`` iff reason == "queued".""" + + def __init__(self, manager, reason: str, *, max_bytes: int = 0, correlation: Optional[CorrelationHandle] = None, + span=None, mime_type: str = "", direction: str = "mixed", operation: str = "observe_consumed", + source_kind: str = "Bytes", purpose: Optional[str] = None, capture=None, ttl: float = 10.0, + reservation: Optional[_Reservation] = None): + self.reason = reason + self.admitted = reason == "queued" + self.max_bytes = max_bytes if self.admitted else 0 + self.correlation = correlation if self.admitted else None + self._manager = manager if self.admitted else None + self._span = span if self.admitted else None + self._spec = (mime_type, direction, operation, source_kind, purpose, capture) + self._expires = time.monotonic() + max(0.0, ttl) + self._used = not self.admitted + self._lapsed = False + self._revoked: Optional[str] = None + self._reservation = reservation + if reservation is not None: + self._finalizer = weakref.finalize(self, reservation.release) + manager._track_ticket(self) + + @property + def expired(self) -> bool: + return self.admitted and not self._used and time.monotonic() >= self._expires + + def _consume(self) -> Optional[str]: + """Mark used; returns a denial reason when the ticket cannot be used.""" + if not self.admitted: + return self.reason + if self._lapsed: + return "expired" + if self._revoked: + return self._revoked + if self._used: + return "conflict" + self._used = True + if time.monotonic() >= self._expires: + self._drop() + return "expired" + return None + + def _drop(self) -> None: + if self._reservation is not None: + self._reservation.release() + self._finalizer.detach() + self._span = None + + def _revoke(self, reason: str) -> None: + """Policy tightened before use: the reservation is returned; use reports ``reason``.""" + if not self._used: + self._used, self._revoked = True, reason + self._drop() + + def _sweep(self) -> bool: + """Lazy expiry from a manager entry point. True when budget was returned.""" + if self.expired: + self._used = self._lapsed = True + self._drop() + return True + return False + + def attach(self, source, *, message_index: Optional[int] = None, part_index: Optional[int] = None, + role: Optional[str] = None, channel: Optional[int] = None, conversation_id: Optional[str] = None, + turn_id: Optional[str] = None, tool_call_id: Optional[str] = None) -> AttachmentHandle: + reason = self._consume() + if reason: + return AttachmentHandle(reason) + manager = self._manager + try: + return manager._commit_attach(self, source, dict( + message_index=message_index, part_index=part_index, role=role, channel=channel, + conversation_id=conversation_id, turn_id=turn_id, tool_call_id=tool_call_id)) + except Exception: + self._drop() + return AttachmentHandle("source_unavailable") + finally: + self._span = None + + def start_stream(self, options) -> "object": + from .stream import AttachmentStream + + reason = self._consume() + if reason: + return AttachmentStream.denied(reason) + try: + return self._manager._commit_stream(self, options) + except Exception: + self._drop() + return AttachmentStream.denied("source_unavailable") + + def release(self) -> None: + if not self._used: + self._used = True + self._drop() + + def __enter__(self) -> "AdmissionTicket": + return self + + def __exit__(self, *exc) -> None: + if not self._used: + self.release() + + def __repr__(self) -> str: + return "AdmissionTicket(reason=%r, max_bytes=%r)" % (self.reason, self.max_bytes) diff --git a/python/fi_instrumentation/attachments/errors.py b/python/fi_instrumentation/attachments/errors.py new file mode 100644 index 000000000..9ae9812f8 --- /dev/null +++ b/python/fi_instrumentation/attachments/errors.py @@ -0,0 +1,15 @@ +"""Safe transfer errors. Light module: no network, TLS or schema imports.""" + +from .types import SAFE_REASONS + + +class TransferError(Exception): + """A safe reason only. Never preserves a server body, URL, token or cause.""" + + def __init__(self, reason: str, retryable: bool = False, retry_after: float = 0, http_status: int = 0): + reason = reason if reason in SAFE_REASONS else "incomplete" + super().__init__(reason) + self.reason = reason + self.retryable = retryable + self.retry_after = min(max(float(retry_after or 0), 0.0), 5.0) + self.http_status = http_status diff --git a/python/fi_instrumentation/attachments/imports.py b/python/fi_instrumentation/attachments/imports.py new file mode 100644 index 000000000..aed445879 --- /dev/null +++ b/python/fi_instrumentation/attachments/imports.py @@ -0,0 +1,99 @@ +"""Completed-recording import (design section 5, F01 ``mode: completed_recording``). + +The core never talks to providers: a resolver turns a provider-specific +completed output into an opaque F01 ``ImportSource`` plus exact declared facts. +The import is submitted with the ORIGINAL eligible identity, never a write +capability. There is no span projection and no background polling. +""" + +import asyncio +import threading +from dataclasses import dataclass +from typing import Optional, Protocol, Tuple, Union + +from .types import Completion + + +@dataclass(frozen=True) +class CompletedRecordingRequest: + provider: str # Token, e.g. "livekit_egress" + provider_ref: str # Token, opaque provider id; never a URL or path + direction: str = "mixed" + + +@dataclass(frozen=True) +class ProviderFileSource: + connection_id: str + registered_output_id: str + + +@dataclass(frozen=True) +class EnvelopeSource: + envelope_id: str # minted by a trusted server-side importer, never by this SDK + + +@dataclass(frozen=True) +class ResolvedCompletedRecording: + source: Union[ProviderFileSource, EnvelopeSource] + declared_bytes: int + declared_duration_ms: int + mime_type: str + direction: str + + +class CompletedRecordingResolver(Protocol): + async def resolve(self, request: CompletedRecordingRequest, *, deadline: float + ) -> Union[ResolvedCompletedRecording, str]: ... + + +class UnavailableResolver: + """Core default: no provider lookup is available.""" + + async def resolve(self, request, *, deadline): + return "source_unavailable" + + +class EgressOutputRegistry(Protocol): + """Injected by the application; the backend (B08) provides the implementation.""" + + async def lookup(self, *, connection_id: str, egress_id: str, file_index: int) -> Optional[str]: ... + + +class ImportHandle: + """``reason == "queued"`` means submitted and accepted (202) or in flight.""" + + def __init__(self, reason: str, recording_id: Optional[str] = None, manager=None): + self.reason = reason + self.recording_id = recording_id if reason == "queued" else None + self.job_id: Optional[str] = None + self._manager = manager + self._event = threading.Event() + self._completion: Optional[Completion] = None + if reason != "queued": + self._finish(reason) + + def _finish(self, status: str, job_id: Optional[str] = None) -> None: + if not self._event.is_set(): + if job_id: + self.job_id = job_id + self._completion = Completion(status) + self._event.set() + + def result(self, timeout: float = 0) -> Completion: + if timeout and timeout > 0: + self._event.wait(min(timeout, 30)) + return self._completion or Completion("unfinished") + + async def wait(self, timeout: float = 30.0) -> Completion: + if self._event.is_set(): + return self._completion + return await asyncio.to_thread(self.result, timeout) + + async def status(self, *, timeout: float = 2.0) -> Tuple[str, str]: + """ONE ``GET imports/{job_id}/status`` with the original credentials.""" + if self._manager is None or self.job_id is None: + return ("failed", self.reason if self.reason != "queued" else "incomplete") + return await asyncio.to_thread(self._manager._import_status, self.job_id, timeout) + + def __repr__(self) -> str: + return "ImportHandle(reason=%r)" % self.reason diff --git a/python/fi_instrumentation/attachments/manager.py b/python/fi_instrumentation/attachments/manager.py index 1e6734030..54ff94284 100644 --- a/python/fi_instrumentation/attachments/manager.py +++ b/python/fi_instrumentation/attachments/manager.py @@ -1,49 +1,111 @@ -"""Provider-owned, bounded, best-effort background audio transfer runtime.""" +"""Provider-owned, bounded, best-effort attachment transfer runtime (design sections 1-9). + +Disabled is a strict no-op: ``create_attachment_manager`` returns the +``DisabledAttachmentManager`` null object (no thread, timer, fork hook, atexit +hook, schema or network import). An enabled manager starts one bootstrap +daemon thread at construction and its worker daemon threads lazily on the +first job. Every wait is bounded (<= 1 s slices that re-check ``stopped``). +One fork hook per process resets live managers in the child without touching +inherited locks. This is not a durable spool: a hard exit may lose uploads. +""" import asyncio +import dataclasses import json -import os -import random import re import threading import time import uuid import weakref from collections import deque -from dataclasses import dataclass, field from typing import Mapping, Optional, Union from opentelemetry import trace from opentelemetry.context import _SUPPRESS_INSTRUMENTATION_KEY, get_value from opentelemetry.sdk.trace import SpanProcessor -from opentelemetry.trace import Span, SpanContext from fi_instrumentation.instrumentation.config import TraceConfig -from .policy import AttachmentConfig, AttachmentPolicy, CapturePolicy, ServerPolicy -from .protocol import HTTPTransport, Session, TransferError, Upload -from .types import AttachmentHandle, Bytes, CorrelationHandle, FlushResult, LocalFile, ProviderFile, RemoteUrl -from .sources import OwnedRecordingFile +from ._disabled import DisabledAttachmentManager, OwnedRecordingHandle +from .admission import AdmissionTicket, _Reservation +from .errors import TransferError +from .imports import CompletedRecordingRequest, EnvelopeSource, ImportHandle, ProviderFileSource, \ + ResolvedCompletedRecording +from .policy import AttachmentConfig, AttachmentPolicy, CapturePolicy, ServerPolicy, env_disabled +from .recording import PcmFormat, RecordingOptions, TrackSpec, RecordingWriter, build_manifest, segment_frames, to_ms, \ + validate_options, MAX_SEGMENT_BYTES, MAX_SEGMENT_MS +from .sources import MemorySource, OwnedRecordingFile, WavSegmentSource, parse_wav +from .stream import AttachmentStream, StreamOptions +from .types import AUDIO_MIMES, MIME_MODALITIES, PURPOSES, REFERENCE_ROLES, TOKEN, AttachmentHandle, \ + AttachmentStatus, Bytes, Completion, CorrelationHandle, FlushResult, canonical_uuid + +MiB = 1024 * 1024 +WAIT_SLICE = 1.0 + +_LIVE: "weakref.WeakSet" = weakref.WeakSet() +_FORK_LOCK = threading.Lock() +_FORK_HOOK_REGISTERED = False + + +def _after_fork_in_child() -> None: + for manager in list(_LIVE): + try: + manager._reset_after_fork() + except Exception: + pass + + +def _register_fork_hook_once() -> None: + """One ``os.register_at_fork(after_in_child=...)`` per process, ever (8.4).""" + global _FORK_HOOK_REGISTERED + import os + + if _FORK_HOOK_REGISTERED or not hasattr(os, "register_at_fork"): + return + with _FORK_LOCK: + if not _FORK_HOOK_REGISTERED: + os.register_at_fork(after_in_child=_after_fork_in_child) + _FORK_HOOK_REGISTERED = True + + +class _Lane: + """Strict per-recording order: at most one job in flight.""" + + __slots__ = ("writer", "jobs", "busy", "scheduled", "__weakref__") + + def __init__(self, writer): + self.writer, self.jobs, self.busy, self.scheduled = writer, deque(), False, False -@dataclass(eq=False) class _Job: - handle: AttachmentHandle - payload: object = field(repr=False) - request: dict - capture: CapturePolicy - epoch: int - budget: int - cancelled: bool = False - upload: Optional[Upload] = None + __slots__ = ("kind", "handle", "body", "payload", "spec", "epoch", "nbytes", "descriptors", "cancelled", + "upload", "renewals", "lane", "entry", "extra", "initialized", "index", "occurrence_id") + + def __init__(self, kind, *, handle=None, body=None, payload=None, spec=None, epoch=0, nbytes=0, + descriptors=1, lane=None, entry=None, extra=None, occurrence_id=None): + self.kind, self.handle, self.body, self.payload, self.spec = kind, handle, body, payload, spec + self.epoch, self.nbytes, self.descriptors, self.lane, self.entry = epoch, nbytes, descriptors, lane, entry + self.extra, self.occurrence_id = extra or {}, occurrence_id + self.cancelled, self.upload, self.renewals, self.initialized, self.index = False, None, 0, False, None + + +def create_attachment_manager(*, config: Optional[AttachmentConfig] = None, trace_config: Optional[TraceConfig] = None, + project_name: str = "", project_type: str = "observe", + headers: Optional[Mapping[str, str]] = None, transport=None): + """Resolve ``enabled`` ONCE; OFF returns the null object (design 8.1).""" + config = config or AttachmentConfig() + if not config.enabled or env_disabled(): + return DisabledAttachmentManager(config=config, trace_config=trace_config) + return AttachmentManager(config=config, trace_config=trace_config, project_name=project_name, + project_type=project_type, headers=headers, transport=transport) class AttachmentManager: - """One runtime per provider. No network, source reads, or threads when OFF. + """One runtime per provider. No network, source reads or threads when OFF. - A transport double can implement bootstrap/initialize/transfer/complete/abort - for component qualification. It must honor the supplied cancellation check - before every bounded I/O chunk. This is not a durable spool. + A transport double implements the section 9 ``AttachmentTransport`` + protocol for component qualification; it must honor the supplied ``check`` + before every bounded I/O chunk and the supplied deadlines. """ def __init__(self, *, config: Optional[AttachmentConfig] = None, trace_config: Optional[TraceConfig] = None, @@ -53,376 +115,1541 @@ def __init__(self, *, config: Optional[AttachmentConfig] = None, trace_config: O self.policy = AttachmentPolicy(self.config, trace_config) self._project_name, self._project_type = project_name, project_type self._transport = transport - self._initial_status = "disabled" - if self.config.enabled: + self._p = None + self._enabled = bool(self.config.enabled and not env_disabled()) + initial = "disabled" + if self._enabled: + from . import protocol + + self._p = protocol if not project_name: - self._initial_status = "scope_unresolved" + initial = "scope_unresolved" elif transport is None: try: - self._transport = HTTPTransport(self.config.endpoint or "", headers or {}, - timeout=self.config.request_timeout) - self._initial_status = "bootstrap_pending" - except Exception as error: - self._initial_status = error.reason if isinstance(error, TransferError) else "endpoint_unconfigured" + self._transport = protocol.HTTPTransport( + self.config.endpoint or "", headers or {}, timeout=self.config.request_timeout, + workspace_id=self.config.workspace_id) + initial = "bootstrap_pending" + except TransferError as error: + initial = error.reason + except Exception: + initial = "endpoint_unconfigured" else: - self._initial_status = "bootstrap_pending" - self._reset() - if hasattr(os, "register_at_fork"): - ref = weakref.ref(self) - def child_reset(): - manager = ref() - if manager is not None: - manager._reset() - os.register_at_fork(after_in_child=child_reset) - self._start() - - def _reset(self) -> None: - # Never acquire inherited thread locks after fork. Child captures get a - # fresh session/nonce; parent descriptors and payloads are not replayed. - self._condition = threading.Condition() - self._queue = deque() - self._jobs = {} + initial = "bootstrap_pending" + self._initial_state = initial + self._reset(initial) + if self._enabled: + _LIVE.add(self) + _register_fork_hook_once() + if initial == "bootstrap_pending": + self._start_bootstrap() + + # ------------------------------------------------------------ lifecycle + def _reset(self, state: str) -> None: + self._cond = threading.Condition() + self._ready_event = threading.Event() + self._ready_q: deque = deque() + self._lanes: "set" = set() + self._active = 0 + self._queued = 0 self._bytes = 0 + self._descriptors = 0 self._dropped = 0 self._epoch = 0 + self._stopping = False self._stopped = False - self._threads = [] - self._session: Optional[Session] = None - self._ready = threading.Event() - self._status = self._initial_status + self._threads: list = [] + self._bootstrap_thread = None + self._renew_pending = False + self._renew_after = 0.0 + self._renew_sequence = 0 + self._session = None + self._state = state + self._tickets: "weakref.WeakSet" = weakref.WeakSet() + self._streams: "weakref.WeakSet" = weakref.WeakSet() + self._recordings: set = set() + self._active_jobs: dict = {} + self._inflight: set = set() + self._running: dict = {} + self._shutdown_result: Optional[FlushResult] = None + self._shutdown_done = threading.Event() + self._shutdown_deadline: Optional[float] = None + self._pacer = self._p.Pacer() if self._p is not None else None self.capture_session_id = str(uuid.uuid4()) self.correlation_nonce = str(uuid.uuid4()) + if state != "bootstrap_pending": + self._ready_event.set() - def _start(self) -> None: - with self._condition: - if self._threads or self._stopped or self._status != "bootstrap_pending": + def _reset_after_fork(self) -> None: + """Child only. Never acquires an inherited lock; the parent keeps uploading.""" + writers, streams = list(self._recordings), list(self._streams) + state = "bootstrap_pending" if self._initial_state == "bootstrap_pending" else self._initial_state + self._reset(state) + for writer in writers: + writer._reset_after_fork() + for stream in streams: + stream._lock = threading.Lock() + stream._done, stream.reason, stream._buffer, stream._ticket = True, "incomplete", bytearray(), None + + def _start_bootstrap(self) -> None: + with self._cond: + if (self._bootstrap_thread is not None or self._stopped or self._stopping + or self._state != "bootstrap_pending"): return - for target in [self._bootstrap] + [self._worker] * self.config.workers: - worker = threading.Thread(target=target, daemon=True, name="fi-attachment") - self._threads.append(worker) - worker.start() + worker = threading.Thread(target=self._bootstrap, daemon=True, name="fi-attachment-bootstrap") + self._bootstrap_thread = worker + worker.start() + + def _bootstrap_body(self) -> dict: + builder = getattr(self._transport, "bootstrap_body", None) + if builder is not None: + return builder(self._project_name, self._project_type, self.capture_session_id, self.correlation_nonce) + body = {"schema_versions": [1], "project_name": self._project_name, "project_type": self._project_type, + "capture_session_id": self.capture_session_id, "correlation_nonce": self.correlation_nonce} + if self.config.workspace_id: + body["workspace_id"] = self.config.workspace_id + return body def _bootstrap(self) -> None: + p = self._p try: - session = self._retry(lambda: self._transport.bootstrap( - self._project_name, self._project_type, self.capture_session_id, self.correlation_nonce - )) - with self._condition: - if self._stopped: + body = self._bootstrap_body() + key = p.idempotency_key("bootstrap", self.capture_session_id, 0) + session = self._attempts(lambda: self._transport.bootstrap( + body, key=key, deadline=time.monotonic() + self.config.request_timeout), lambda: self._alive(), + self.config.request_timeout * 3) + with self._cond: + if self._stopped or self._stopping: return self._session = session - self._status = "ready" - except Exception as error: - with self._condition: - self._status = error.reason if isinstance(error, TransferError) else "source_unavailable" + self._state = "ready" + self._pacer.set_rate(session.limits.upload_bytes_per_second) + except TransferError as error: + with self._cond: + if not (self._stopped or self._stopping): + self._state = error.reason if error.reason != "incomplete" else "bootstrap_pending" + if self._state == "bootstrap_pending": + # A transport failure leaves bootstrap retryable on the next activity. + self._bootstrap_thread = None + except Exception: + with self._cond: + if not (self._stopped or self._stopping): + self._state = "unsupported_version" finally: - self._ready.set() + self._ready_event.set() + with self._cond: + self._cond.notify_all() + + def _alive(self) -> None: + if self._stopped: + raise TransferError("incomplete") + + def _ensure_workers(self) -> None: + # Caller holds self._cond. + if self._threads or self._stopped: + return + for index in range(self.config.workers): + worker = threading.Thread(target=self._worker, daemon=True, name="fi-attachment-worker-%d" % index) + self._threads.append(worker) + worker.start() + + # -------------------------------------------------------------- status + def _runtime_state(self) -> str: + if self._stopped or self._stopping: + return "incomplete" + state = self._state + if state == "ready" and (self._session is None or self._session.expiring()): + return "expired" + return state + + def _session_or_none(self): + return self._session + + def _limits(self): + session = self._session + return session.limits if session is not None else self._p.Limits() def ready(self, timeout: float = 5) -> bool: - self._start() - if self._status == "bootstrap_pending": - self._ready.wait(max(0, min(timeout, 30))) - return self._status == "ready" and self._session is not None and self._session.expires_at > time.time() + if self._state == "bootstrap_pending": + self._start_bootstrap() + deadline = time.monotonic() + max(0.0, min(float(timeout), 30.0)) + while not self._ready_event.is_set() and time.monotonic() < deadline: + self._ready_event.wait(min(WAIT_SLICE, max(deadline - time.monotonic(), 0))) + return self._runtime_state() == "ready" async def ready_async(self, timeout: float = 5) -> bool: return await asyncio.to_thread(self.ready, timeout) - @property - def status(self) -> str: - if self._session is not None and self._session.expires_at <= time.time(): - return "expired" - return self._status + def status(self) -> AttachmentStatus: + self._sweep() + with self._cond: + return AttachmentStatus( + self._runtime_state(), self._queued, self._active, + sum(1 for t in self._tickets if not t._used), + sum(1 for s in self._streams if s.open), len(self._recordings), self._bytes, self._dropped) @property def owned_bytes(self) -> int: - with self._condition: + with self._cond: return self._bytes - def attach(self, span_or_context: Optional[Union[Span, SpanContext, CorrelationHandle]], - source: Union[Bytes, OwnedRecordingFile, LocalFile, ProviderFile, RemoteUrl], - *, mime_type: str, direction: str, purpose: Optional[str] = None, - conversation_id: Optional[str] = None, turn_id: Optional[str] = None, + # ------------------------------------------------------------- budget + def _release(self, nbytes: int, descriptors: int = 1) -> None: + with self._cond: + self._bytes = max(0, self._bytes - nbytes) + self._descriptors = max(0, self._descriptors - descriptors) + self._cond.notify_all() + + def _reserve(self, nbytes: int) -> bool: + with self._cond: + if self._bytes + nbytes > self.config.max_owned_bytes: + return False + self._bytes += nbytes + return True + + def _track_ticket(self, ticket) -> None: + self._tickets.add(ticket) + + def _track_stream(self, stream) -> None: + self._streams.add(stream) + + def _sweep(self) -> None: + """Lazy expiry of tickets and idle streams at manager entry points (no timers).""" + if self._p is None: + return + now = time.monotonic() + for ticket in list(self._tickets): + ticket._sweep() + for stream in list(self._streams): + stream._sweep(now) + self._maybe_renew() + + def _maybe_renew(self) -> None: + with self._cond: + session = self._session + if (session is None or self._state != "ready" or self._renew_pending or self._stopping or self._stopped + or time.monotonic() < self._renew_after or not session.renew_due()): + return + self._renew_pending = True + self._ready_q.append(_Job("renew", descriptors=0)) + self._ensure_workers() + self._cond.notify_all() + + # ------------------------------------------------------------ preflight + def _cap(self, source_kind: str, mime_type: str) -> int: + limits = self._limits() + cap = min(limits.max_upload_bytes, 50 * MiB) + if MIME_MODALITIES.get(mime_type) == "image": + cap = min(cap, 20 * MiB) + if source_kind in ("Bytes", "Blob"): + cap = min(cap, self.config.max_owned_bytes) + return cap + + def _admission_reason(self, capture, *, mime_type, direction, source_kind, operation, purpose, + import_source=False) -> Optional[str]: + """Steps 1-8 (no source access).""" + if not self._enabled or env_disabled(): + return "disabled" + if self._stopped or self._stopping: + return "incomplete" + state = self._runtime_state() + if state == "bootstrap_pending": + self._start_bootstrap() + if state != "ready": + return state + if get_value(_SUPPRESS_INSTRUMENTATION_KEY): + return "policy_denied" + reason = self.policy.evaluate(self._session.policy, capture, direction=direction, mime_type=mime_type, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=import_source) + if reason: + return reason + if source_kind not in ("Bytes", "Blob", "OwnedRecordingFile") and not import_source: + return "source_unavailable" + return None + + def preflight(self, target=None, *, mime_type: str, direction: str, max_bytes: int, + operation: str = "observe_consumed", source_kind: str = "Bytes", purpose: Optional[str] = None, + capture_policy: Optional[CapturePolicy] = None, ttl: Optional[float] = None, + _import_source: bool = False, _skip_cap: bool = False) -> AdmissionTicket: + """Full deny-wins check without touching the source; reserves a slot and budget.""" + try: + self._sweep() + capture = capture_policy or CapturePolicy() + reason = self._admission_reason(capture, mime_type=mime_type, direction=direction, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=_import_source) + if reason: + return AdmissionTicket(None, reason) + span = trace.get_current_span() if target is None else target + try: + correlation = CorrelationHandle.from_span(span) + except Exception: + return AdmissionTicket(None, "correlation_unavailable") + if not correlation.sampled: + return AdmissionTicket(None, "unsampled") + if type(max_bytes) is not int or max_bytes <= 0 or (not _skip_cap and max_bytes > self._cap(source_kind, mime_type)): + return AdmissionTicket(None, "too_large") + reserve = min(self.config.chunk_bytes, max_bytes) if source_kind == "OwnedRecordingFile" else max_bytes + if _import_source: + reserve = 0 + with self._cond: + if self._stopped or self._stopping: + return AdmissionTicket(None, "incomplete") + if (self._descriptors >= self.config.max_descriptors + or self._bytes + reserve > self.config.max_owned_bytes): + return AdmissionTicket(None, "queue_full") + self._descriptors += 1 + self._bytes += reserve + ttl = self.config.ticket_ttl if ttl is None else min(max(float(ttl), 0.0), 30.0) + projectable = span if not isinstance(span, CorrelationHandle) and hasattr(span, "is_recording") else None + return AdmissionTicket(self, "queued", max_bytes=max_bytes, correlation=correlation, span=projectable, + mime_type=mime_type, direction=direction, operation=operation, + source_kind=source_kind, purpose=purpose, capture=capture, ttl=ttl, + reservation=_Reservation(self, reserve, 1)) + except Exception: + return AdmissionTicket(None, "source_unavailable") + + def _recheck_ticket(self, ticket) -> Optional[str]: + mime, direction, operation, source_kind, purpose, capture = ticket._spec + return self._admission_reason(capture, mime_type=mime, direction=direction, source_kind=source_kind, + operation=operation, purpose=purpose) + + # --------------------------------------------------------------- attach + def attach(self, span_or_context=None, source=None, *, mime_type: str, direction: str, + purpose: Optional[str] = None, conversation_id: Optional[str] = None, turn_id: Optional[str] = None, tool_call_id: Optional[str] = None, message_index: Optional[int] = None, part_index: Optional[int] = None, role: Optional[str] = None, channel: Optional[int] = None, capture_policy: Optional[CapturePolicy] = None) -> AttachmentHandle: - """Try admission without I/O. Rejections never retain or inspect bytes.""" + """``preflight(max_bytes=len(source))`` followed by ``ticket.attach``. Never raises.""" try: - return self._attach(span_or_context, source, mime_type=mime_type, direction=direction, - purpose=purpose, conversation_id=conversation_id, turn_id=turn_id, - tool_call_id=tool_call_id, message_index=message_index, - part_index=part_index, role=role, channel=channel, - capture_policy=capture_policy or CapturePolicy()) + kind = type(source).__name__ + if type(source) is Bytes: + data = source.data + if type(data) not in (bytes, bytearray, memoryview): + return self._deny_handle(capture_policy, mime_type, direction, kind, purpose, "source_unavailable") + length = data.nbytes if type(data) is memoryview else len(data) + elif type(source) is OwnedRecordingFile: + length = source.size + else: + # Unqualified sources cannot trigger even stat(), DNS, or a client call. + return self._deny_handle(capture_policy, mime_type, direction, kind, purpose, "source_unavailable") + operation = "import_existing" if type(source) is OwnedRecordingFile else "observe_consumed" + ticket = self.preflight(span_or_context, mime_type=mime_type, direction=direction, + max_bytes=length, operation=operation, + source_kind=kind, purpose=purpose, capture_policy=capture_policy) + return ticket.attach(source, message_index=message_index, part_index=part_index, role=role, + channel=channel, conversation_id=conversation_id, turn_id=turn_id, + tool_call_id=tool_call_id) except Exception: - # Caller objects, malformed contexts, and instrumentation errors must + # Caller objects, malformed contexts and instrumentation errors must # not fail inference or reach a logger with their repr/exception. return AttachmentHandle("source_unavailable") - def _attach(self, span_or_context, source, **options) -> AttachmentHandle: - if self._status == "bootstrap_pending": - self._start() - capture = options.pop("capture_policy") - kind = type(source).__name__ - reason = self.policy.evaluate(self._session.policy if self._session else None, capture, - direction=options["direction"], mime_type=options["mime_type"], source_kind=kind) - if reason: - if reason == "bootstrap_pending" and self._status != "bootstrap_pending": - reason = self._status - return AttachmentHandle(reason) - if get_value(_SUPPRESS_INSTRUMENTATION_KEY): - return AttachmentHandle("policy_denied") - if self._stopped: - return AttachmentHandle("incomplete") - if self._session.expires_at <= time.time(): - return AttachmentHandle("expired") - # Unqualified sources cannot trigger even stat(), DNS, or a client call. - if type(source) not in (Bytes, OwnedRecordingFile): - return AttachmentHandle("source_unavailable") - span = trace.get_current_span() if span_or_context is None else span_or_context + def _deny_handle(self, capture, mime, direction, kind, purpose, fallback) -> AttachmentHandle: + # Steps 1-7 still win (deny-wins), evaluated without the source: its kind is + # unqualified (step 8), so source authorization is not what decides here. try: - correlation = CorrelationHandle.from_span(span) + if not self._enabled or env_disabled(): + return AttachmentHandle("disabled") + state = self._runtime_state() + if state != "ready": + return AttachmentHandle(state) + if get_value(_SUPPRESS_INSTRUMENTATION_KEY): + return AttachmentHandle("policy_denied") + server = self._session.policy + server = dataclasses.replace(server, allowed_sources=server.allowed_sources | {"Bytes"}) + reason = self.policy.evaluate(server, capture or CapturePolicy(), direction=direction, mime_type=mime, + source_kind="Bytes", purpose=purpose) + return AttachmentHandle(reason or fallback) except Exception: - return AttachmentHandle("correlation_unavailable") - if not correlation.sampled: - return AttachmentHandle("unsampled") - metadata = self._metadata(options) - owned_file = type(source) is OwnedRecordingFile - data = source if owned_file else source.data - if not owned_file and type(data) not in (bytes, bytearray, memoryview): - return AttachmentHandle("source_unavailable") - # Export the mutable buffer only after policy admission. A memoryview - # pins its size, preventing a concurrent resize between budget and copy. - if type(data) is bytearray: - data = memoryview(data) - length = source.size if owned_file else (data.nbytes if type(data) is memoryview else len(data)) - if type(length) is not int or length <= 0 or length > min(self.config.max_attachment_bytes, self._session.max_upload_bytes): - return AttachmentHandle("too_large") - # A mutable buffer may only be copied in bounded callback-sized chunks. - if not owned_file and type(data) is not bytes and length > self.config.chunk_bytes: - return AttachmentHandle("too_large") - budget = self.config.chunk_bytes if owned_file else length - self._condition.acquire() - try: - if self._stopped: - return AttachmentHandle("incomplete") - reason = self.policy.evaluate(self._session.policy, capture, direction=options["direction"], - mime_type=options["mime_type"], source_kind=kind) - if reason: - return AttachmentHandle(reason) - if len(self._jobs) >= self.config.max_descriptors or self._bytes + budget > self.config.max_owned_bytes: - return AttachmentHandle("queue_full") - handle = AttachmentHandle("queued") - request = { - "schema_version": 1, "attachment_id": handle.attachment_id, - "occurrence_id": handle.occurrence_id, - "association": {"capture_session_id": self.capture_session_id, - "correlation_nonce": self.correlation_nonce, - "parent": {"trace_id": correlation.trace_uuid, "span_id": correlation.span_id}}, - "policy_version": self._session.policy.version, - "deletion_generation": self._session.policy.deletion_generation, - "source_kind": kind, "modality": "audio", "declared_bytes": length, - **{k: v for k, v in metadata.items() if k not in ("role", "channel")}, - } - payload = data if owned_file or type(data) is bytes else bytes(data) - job = _Job(handle, payload, request, capture, self._epoch, budget) - self._bytes += budget - self._jobs[handle.occurrence_id] = job - self._queue.append(job) - self._project_reference(span, handle, metadata) - self._condition.notify_all() - return handle - finally: - self._condition.release() + return AttachmentHandle(fallback) @staticmethod - def _metadata(options: dict) -> dict: - result = {"mime_type": options["mime_type"], "direction": options["direction"]} - enums = {"purpose": ("conversation_recording", "turn_recording", "model_input", "model_output", "tool_result", "diagnostic"), - "role": ("user", "assistant", "tool", "system", "unknown")} - for key, allowed in enums.items(): - if options[key] is not None: - if options[key] not in allowed: + def _fields(fields: dict) -> dict: + result = {} + for key, allowed in (("role", REFERENCE_ROLES),): + value = fields.get(key) + if value is not None: + if value not in allowed: raise ValueError("invalid attachment classification") - result[key] = options[key] + result[key] = value for key in ("message_index", "part_index", "channel"): - value = options[key] + value = fields.get(key) if value is not None: if type(value) is not int or not 0 <= value <= (31 if key == "channel" else 65535): raise ValueError("invalid attachment index") result[key] = value for key in ("conversation_id", "turn_id", "tool_call_id"): - value = options[key] + value = fields.get(key) if value is not None: - if not isinstance(value, str) or not re.fullmatch(r"[a-zA-Z0-9_-]{1,128}", value): + if not isinstance(value, str) or not TOKEN.fullmatch(value): raise ValueError("invalid opaque correlation") result[key] = value return result - def _project_reference(self, span, handle, metadata) -> None: - # Only live spans are projected. Authoritative occurrence binding is out - # of band; upload completion must never mutate an ended span. + def _upload_request(self, correlation, *, attachment_id, occurrence_id, mime_type, direction, source_kind, + purpose, declared_bytes, fields=None, recording_id=None, segment_index=None) -> dict: + request = { + "schema_version": 1, "attachment_id": attachment_id, "occurrence_id": occurrence_id, + "association": {"capture_session_id": self.capture_session_id, + "correlation_nonce": self.correlation_nonce, + "parent": {"trace_id": correlation.trace_uuid, "span_id": correlation.span_id}}, + "policy_version": self._session.policy.version, "deletion_generation": 0, + "mime_type": mime_type, "modality": MIME_MODALITIES[mime_type], "direction": direction, + "source_kind": source_kind, "declared_bytes": declared_bytes, + } + if purpose is not None: + request["purpose"] = purpose + for key in ("message_index", "part_index", "conversation_id", "turn_id", "tool_call_id"): + if fields and key in fields: + request[key] = fields[key] + if recording_id is not None: + request["recording_id"], request["segment_index"] = recording_id, segment_index + # Section 7: role and channel never travel in an UploadRequest. + return request + + def _commit_attach(self, ticket, source, fields) -> AttachmentHandle: + mime, direction, operation, source_kind, purpose, capture = ticket._spec + reason = self._recheck_ticket(ticket) + if reason: + ticket._drop() + return AttachmentHandle(reason) + kind = type(source).__name__ + if kind != source_kind or type(source) not in (Bytes, OwnedRecordingFile): + ticket._drop() + return AttachmentHandle("source_unavailable") + fields = self._fields(fields) + if type(source) is Bytes: + data = source.data + if type(data) not in (bytes, bytearray, memoryview): + ticket._drop() + return AttachmentHandle("source_unavailable") + length = data.nbytes if type(data) is memoryview else len(data) + if length <= 0 or length > ticket.max_bytes: + ticket._drop() + return AttachmentHandle("too_large") + if type(data) is not bytes: + # A mutable buffer is copied inside this call, only up to sync_copy_bytes. + if length > self.config.sync_copy_bytes: + ticket._drop() + return AttachmentHandle("too_large") + data = memoryview(data).cast("B").tobytes() + ticket._reservation.shrink(length) + payload = data + else: + length = source.size + if length <= 0 or length > ticket.max_bytes: + ticket._drop() + return AttachmentHandle("too_large") + payload = source + handle = AttachmentHandle("queued") + request = self._upload_request(ticket.correlation, attachment_id=handle.attachment_id, + occurrence_id=handle.occurrence_id, mime_type=mime, direction=direction, + source_kind=source_kind, purpose=purpose, declared_bytes=length, + fields=fields) + ref = {"attachment_id": handle.attachment_id, "occurrence_id": handle.occurrence_id, + "direction": direction, "modality": MIME_MODALITIES[mime], "mime_type": mime} + if purpose is not None: + ref["purpose"] = purpose + ref.update({k: v for k, v in fields.items() if k in ("message_index", "part_index", "role", "channel")}) + return self._enqueue_upload(ticket, handle, request, payload, ref) + + def _enqueue_upload(self, ticket, handle, request, payload, ref) -> AttachmentHandle: + reservation = ticket._reservation + job = _Job("upload", handle=handle, body=self._p.encode(request), payload=payload, spec=ticket._spec, + epoch=self._epoch, nbytes=reservation.nbytes, descriptors=1, occurrence_id=handle.occurrence_id) + span = ticket._span + with self._cond: + if self._stopped or self._stopping: + reservation.release() + ticket._finalizer.detach() + handle._finish("incomplete") + return handle + # The job now owns the ticket's descriptor and bytes. + reservation.released = True + ticket._finalizer.detach() + self._tickets.discard(ticket) + self._ready_q.append(job) + self._queued += 1 + self._ensure_workers() + self._cond.notify_all() + self._project(span, ref) + return handle + + # ---------------------------------------------------------- projection + def _project(self, span, ref: Optional[dict]) -> None: + """Carrier stamp (0.8): all four attributes, only on a live capture target.""" try: - if not span.is_recording(): + if span is None or not span.is_recording(): return attrs = getattr(span, "attributes", None) or {} raw = attrs.get("fi.attachment.refs", "[]") - if not isinstance(raw, str) or len(raw) > 16384: + if not isinstance(raw, str) or len(raw.encode()) > 16384: return references = json.loads(raw) - if not isinstance(references, list) or len(references) >= 64: + if not isinstance(references, list): return - ref = {k: v for k, v in metadata.items() if k not in ("conversation_id", "turn_id", "tool_call_id")} - ref.update(attachment_id=handle.attachment_id, occurrence_id=handle.occurrence_id, modality="audio") - encoded = json.dumps([*references, ref], separators=(",", ":")) - if len(encoded.encode()) <= 16384: - span.set_attribute("fi.attachment.schema_version", 1) - span.set_attribute("fi.attachment.capture_session_id", self.capture_session_id) - span.set_attribute("fi.attachment.correlation_nonce", self.correlation_nonce) - span.set_attribute("fi.attachment.refs", encoded) + if ref is not None: + if len(references) >= 64: + ref = None + else: + references = [*references, ref] + encoded = json.dumps(references, separators=(",", ":")) + if len(encoded.encode()) > 16384: + if ref is None: + return + encoded = raw + span.set_attribute("fi.attachment.schema_version", 1) + span.set_attribute("fi.attachment.refs", encoded) + span.set_attribute("fi.attachment.capture_session_id", self.capture_session_id) + span.set_attribute("fi.attachment.correlation_nonce", self.correlation_nonce) except Exception: pass - def _check(self, job: _Job) -> None: - if self._stopped or job.cancelled: - raise TransferError("incomplete") - if job.epoch != self._epoch: - raise TransferError("policy_denied") + # -------------------------------------------------------------- streams + def start_attachment_stream(self, target=None, options: Optional[StreamOptions] = None) -> AttachmentStream: + try: + ticket = self.preflight(target, mime_type=options.mime_type, direction=options.direction, + max_bytes=options.max_bytes, operation="observe_consumed", source_kind="Bytes", + purpose=options.purpose, capture_policy=options.capture_policy) + return ticket.start_stream(options) + except Exception: + return AttachmentStream.denied("source_unavailable") + + def _commit_stream(self, ticket, options: StreamOptions) -> AttachmentStream: + reason = self._recheck_ticket(ticket) + if reason: + ticket._drop() + return AttachmentStream.denied(reason) + self._fields(dict(message_index=options.message_index, part_index=options.part_index, role=options.role, + channel=options.channel, conversation_id=options.conversation_id, + turn_id=options.turn_id, tool_call_id=options.tool_call_id)) + ticket._attachment_id, ticket._occurrence_id = str(uuid.uuid4()), str(uuid.uuid4()) + self._tickets.discard(ticket) + ticket._finalizer.detach() + return AttachmentStream(self, ticket, options) + + def _commit_stream_finish(self, ticket, options: StreamOptions, data: bytes) -> AttachmentHandle: + mime, direction, operation, source_kind, purpose, capture = ticket._spec + reason = self._recheck_ticket(ticket) + if reason: + ticket._drop() + return AttachmentHandle(reason) + fields = self._fields(dict(message_index=options.message_index, part_index=options.part_index, + role=options.role, channel=options.channel, + conversation_id=options.conversation_id, turn_id=options.turn_id, + tool_call_id=options.tool_call_id)) + ticket._reservation.shrink(len(data)) + handle = AttachmentHandle("queued", ticket._attachment_id, ticket._occurrence_id) + request = self._upload_request(ticket.correlation, attachment_id=handle.attachment_id, + occurrence_id=handle.occurrence_id, mime_type=mime, direction=direction, + source_kind="Bytes", purpose=purpose, declared_bytes=len(data), fields=fields) + ref = {"attachment_id": handle.attachment_id, "occurrence_id": handle.occurrence_id, + "direction": direction, "modality": MIME_MODALITIES[mime], "mime_type": mime} + if purpose is not None: + ref["purpose"] = purpose + ref.update({k: v for k, v in fields.items() if k in ("message_index", "part_index", "role", "channel")}) + return self._enqueue_upload(ticket, handle, request, data, ref) + + # ------------------------------------------------------------ recording + def _recording_denials(self, options: RecordingOptions): session = self._session - if session is None or session.expires_at <= time.time() or job.upload is not None and job.upload.expires_at <= time.time(): - raise TransferError("expired") - reason = self.policy.evaluate(session.policy, job.capture, direction=job.request["direction"], - mime_type=job.request["mime_type"], source_kind=job.request["source_kind"]) + if session is None or self._runtime_state() != "ready": + return None + capture = options.capture_policy or CapturePolicy() + directions = ([t.direction for t in options.tracks] if options.layout == "separate_tracks" else ["mixed"]) + result = [] + for direction in directions: + result.append(self.policy.evaluate(session.policy, capture, direction=direction, mime_type="audio/wav", + source_kind="Bytes", operation=options.operation, + purpose=options.purpose)) + return result + + def start_recording(self, target=None, options: Optional[RecordingOptions] = None) -> RecordingWriter: + try: + self._sweep() + if not self._enabled or env_disabled(): + return RecordingWriter(reason="disabled") + invalid = validate_options(options) + if invalid: + return RecordingWriter(reason=invalid) + if self._stopped or self._stopping: + return RecordingWriter(reason="incomplete") + state = self._runtime_state() + pending = state == "bootstrap_pending" + if pending: + self._start_bootstrap() + elif state != "ready": + return RecordingWriter(reason=state) + if get_value(_SUPPRESS_INSTRUMENTATION_KEY): + return RecordingWriter(reason="policy_denied") + denials = None + if not pending: + denials = self._recording_denials(options) + if all(denials): + return RecordingWriter(reason=next(d for d in denials if d)) + span = trace.get_current_span() if target is None else target + try: + correlation = CorrelationHandle.from_span(span) + except Exception: + return RecordingWriter(reason="correlation_unavailable") + if not correlation.sampled: + return RecordingWriter(reason="unsampled") + slots = min(self._limits().active_recordings, 4) + with self._cond: + if self._descriptors >= self.config.max_descriptors or len(self._recordings) >= slots: + return RecordingWriter(reason="queue_full") + self._descriptors += 1 + writer = RecordingWriter(self, options, "queued", correlation=correlation, pending=pending, + track_denials=denials) + if writer.reason != "queued": + self._release(0, 1) + return writer + with self._cond: + self._recordings.add(writer) + if not isinstance(span, CorrelationHandle) and hasattr(span, "is_recording"): + self._project(span, None) + return writer + except Exception: + return RecordingWriter(reason="source_unavailable") + + def _close_recording(self, writer) -> None: + with self._cond: + if writer in self._recordings: + self._recordings.discard(writer) + self._descriptors = max(0, self._descriptors - 1) + if hasattr(writer, "_lane"): + self._lanes.discard(writer._lane) + self._cond.notify_all() + + def _new_lane(self, writer) -> _Lane: + lane = _Lane(writer) + with self._cond: + self._lanes.add(lane) + return lane + + def _schedule_lane(self, lane: _Lane) -> None: + # Caller holds self._cond. + if lane.jobs and not lane.busy and not lane.scheduled: + lane.scheduled = True + self._ready_q.append(lane) + self._ensure_workers() + self._cond.notify_all() + + def _enqueue_segment(self, writer, entry) -> None: + options = writer._options + spec = ("audio/wav", self._segment_direction(writer, entry), options.operation, "Bytes", options.purpose, + options.capture_policy or CapturePolicy()) + job = _Job("segment", lane=writer._lane, entry=entry, nbytes=entry.nbytes, descriptors=1, spec=spec, + epoch=self._epoch, occurrence_id=entry.occurrence_id) + with self._cond: + self._descriptors += 1 + writer._lane.jobs.append(job) + self._queued += 1 + self._schedule_lane(writer._lane) + + def _enqueue_manifest(self, writer, body: bytes, revision: int, end: int, completed: int) -> None: + job = _Job("manifest", lane=writer._lane, body=body, descriptors=0, + extra={"revision": revision, "end": end, "completed": completed}) + with self._cond: + writer._lane.jobs.append(job) + self._queued += 1 + self._schedule_lane(writer._lane) + + def _drain_lane(self, lane: _Lane, deadline: float) -> None: + with self._cond: + while (lane.jobs or lane.busy) and time.monotonic() < deadline and not self._stopped: + self._cond.wait(min(WAIT_SLICE, max(deadline - time.monotonic(), 0.001))) + + def _cancel_lane(self, lane: _Lane, reason: str) -> None: + with self._cond: + dropped = list(lane.jobs) + lane.jobs.clear() + for job in dropped: + self._queued -= 1 + job.cancelled = True + active = self._active_jobs.get(id(lane)) + if active is not None: + active.cancelled = True + self._cond.notify_all() + for job in dropped: + self._finish_job(job, reason, notify_lane=False) + + def _bounded_deadline(self, deadline: float) -> float: + bound = self._shutdown_deadline + return min(deadline, bound) if bound is not None else deadline + + # ---------------------------------------------------------- owned files + def attach_owned_recording(self, target, source, *, mime_type: str, direction: str, wav_tracks=None, + purpose: str = "conversation_recording", capture_policy=None, + conversation_id: Optional[str] = None) -> OwnedRecordingHandle: + try: + if not self._enabled or env_disabled(): + return OwnedRecordingHandle("denied", "disabled") + if type(source) is not OwnedRecordingFile: + return OwnedRecordingHandle("denied", "source_unavailable") + if purpose not in ("conversation_recording", "turn_recording"): + return OwnedRecordingHandle("denied", "policy_denied") + single_cap = min(self._limits().max_upload_bytes, 50 * MiB) + wav = mime_type == "audio/wav" + if wav and (source.size > single_cap or wav_tracks): + tier = "wav_recording" + elif source.size <= single_cap: + tier = "single" + else: + return OwnedRecordingHandle("denied", "too_large") + if tier == "single": + ticket = self.preflight(target, mime_type=mime_type, direction=direction, max_bytes=source.size, + operation="import_existing", source_kind="OwnedRecordingFile", + purpose=purpose, capture_policy=capture_policy) + if not ticket.admitted: + return OwnedRecordingHandle("denied", ticket.reason) + handle = ticket.attach(source, conversation_id=conversation_id) + return OwnedRecordingHandle("single" if handle.admission == "queued" else "denied", + handle.admission, handle=handle, manager=self) + if wav_tracks is not None: + # Roles are claimed only for a validated 2-channel stereo file (section 7); + # one track describes a mono file. Anything else is refused up front. + tracks = tuple(wav_tracks) + layout = "stereo" if len(tracks) == 2 else "mixed" + if len(tracks) == 1: + tracks = (TrackSpec((0,), "mixed", tracks[0].role if isinstance(tracks[0], TrackSpec) else "x"),) + options = RecordingOptions(format=PcmFormat(8000), layout=layout, tracks=tracks, + operation="observe_consumed") + if len(tracks) not in (1, 2) or validate_options(options): + return OwnedRecordingHandle("denied", "policy_denied") + ticket = self.preflight(target, mime_type=mime_type, direction=direction, max_bytes=source.size, + operation="import_existing", source_kind="OwnedRecordingFile", purpose=purpose, + capture_policy=capture_policy, _skip_cap=True) + if not ticket.admitted: + return OwnedRecordingHandle("denied", ticket.reason) + reason = self._recheck_ticket(ticket) + if reason: + ticket._drop() + return OwnedRecordingHandle("denied", reason) + recording_id = str(uuid.uuid4()) + handle = OwnedRecordingHandle("wav_recording", "queued", recording_id=recording_id, manager=self) + reservation = ticket._reservation + job = _Job("owned_wav", handle=handle, payload=source, spec=ticket._spec, epoch=self._epoch, + nbytes=reservation.nbytes, descriptors=1, + extra={"tracks": wav_tracks, "recording_id": recording_id, "correlation": ticket.correlation, + "conversation_id": conversation_id}) + handle._job = job + with self._cond: + if self._stopped or self._stopping: + ticket._drop() + return OwnedRecordingHandle("denied", "incomplete") + reservation.released = True + ticket._finalizer.detach() + self._tickets.discard(ticket) + self._ready_q.append(job) + self._queued += 1 + self._ensure_workers() + self._cond.notify_all() + self._project(ticket._span, None) + return handle + except Exception: + return OwnedRecordingHandle("denied", "source_unavailable") + + # -------------------------------------------------------------- imports + async def import_completed_recording(self, target, request: CompletedRecordingRequest, *, resolver, + capture_policy: Optional[CapturePolicy] = None, + timeout: float = 30.0) -> ImportHandle: + try: + if not self._enabled or env_disabled(): + return ImportHandle("disabled") + if (not isinstance(request, CompletedRecordingRequest) or not isinstance(request.provider, str) + or not TOKEN.fullmatch(request.provider) or not isinstance(request.provider_ref, str) + or not TOKEN.fullmatch(request.provider_ref) or request.direction not in ("input", "output", "mixed")): + return ImportHandle("policy_denied") + capture = capture_policy or CapturePolicy() + ticket = self.preflight(target, mime_type="audio/ogg", direction=request.direction, max_bytes=1, + operation="import_existing", source_kind="ProviderFile", capture_policy=capture, + _import_source=True, _skip_cap=True) + if not ticket.admitted: + return ImportHandle(ticket.reason) + span = ticket._span + self._project(span, None) + budget = min(max(float(timeout), 0.0), 30.0) + try: + resolved = await asyncio.wait_for(resolver.resolve(request, deadline=time.monotonic() + budget), + budget) + except Exception: + ticket.release() + return ImportHandle("source_unavailable") + if isinstance(resolved, str): + ticket.release() + return ImportHandle(resolved if resolved in ("source_unavailable", "policy_denied", + "credential_scope_unsupported", "too_large") + else "source_unavailable") + reason, body = self._import_body(ticket, request, resolved) + if reason: + ticket.release() + return ImportHandle(reason) + recording = json.loads(body)["recording"] + recording_id = recording["recording_id"] + handle = ImportHandle("queued", recording_id, self) + reservation = ticket._reservation + spec = (recording["mime_type"], recording["direction"], "import_existing", recording["source_kind"], + None, capture) + job = _Job("import", handle=handle, body=body, spec=spec, epoch=self._epoch, nbytes=0, + descriptors=1, extra={"recording_id": recording_id}) + with self._cond: + if self._stopped or self._stopping: + ticket.release() + return ImportHandle("incomplete") + reservation.released = True + ticket._finalizer.detach() + self._tickets.discard(ticket) + self._ready_q.append(job) + self._queued += 1 + self._ensure_workers() + self._cond.notify_all() + return handle + except Exception: + return ImportHandle("source_unavailable") + + def _import_body(self, ticket, request, resolved): + if not isinstance(resolved, ResolvedCompletedRecording): + return "unsupported_version", None + source = resolved.source + if isinstance(source, ProviderFileSource): + if not canonical_uuid(source.connection_id) or not canonical_uuid(source.registered_output_id): + return "unsupported_version", None + wire, kind = {"kind": "ProviderFile", "connection_id": source.connection_id, + "registered_output_id": source.registered_output_id}, "ProviderFile" + elif isinstance(source, EnvelopeSource): + if not canonical_uuid(source.envelope_id): + return "unsupported_version", None + wire, kind = {"kind": "RemoteUrlEnvelope", "envelope_id": source.envelope_id}, "RemoteUrl" + else: + return "unsupported_version", None + limits = self._limits() + if (type(resolved.declared_bytes) is not int or type(resolved.declared_duration_ms) is not int + or not 1 <= resolved.declared_bytes <= min(limits.recording_bytes, 1073741824) + or not 1 <= resolved.declared_duration_ms <= min(limits.recording_duration_ms, 7200000)): + return "too_large", None + if resolved.mime_type not in AUDIO_MIMES: + return "unsupported_version", None + direction = resolved.direction + if direction not in ("input", "output", "mixed"): + return "unsupported_version", None + if request.direction == "mixed" and direction != "mixed": + return "policy_denied", None # trusted ancestry wins; never narrowed + if request.direction != direction and direction != "mixed": + return "policy_denied", None + _, _, operation, _, purpose, capture = ticket._spec + reason = self._admission_reason(capture, mime_type=resolved.mime_type, direction=direction, + source_kind=kind, operation="import_existing", purpose=purpose, + import_source=True) if reason: - raise TransferError(reason) + return reason, None + correlation = ticket.correlation + recording = { + "schema_version": 1, + "association": {"capture_session_id": self.capture_session_id, + "correlation_nonce": self.correlation_nonce, + "parent": {"trace_id": correlation.trace_uuid, "span_id": correlation.span_id}}, + "policy_version": self._session.policy.version, "deletion_generation": 0, + "mime_type": resolved.mime_type, "direction": direction, "source_kind": kind, + "recording_id": str(uuid.uuid4()), "modality": "audio", "declared_bytes": resolved.declared_bytes, + "declared_duration_ms": resolved.declared_duration_ms, + } + body = {"mode": "completed_recording", "recording": recording, "source": wire} + if not self._p.wire_valid("RecordingImportRequest", body): + return "unsupported_version", None + return None, self._p.encode(body) + + def _import_status(self, job_id: str, timeout: float): + try: + session = self._session + if session is None: + return ("failed", "expired") + return self._transport.import_status(session, job_id, deadline=time.monotonic() + min(max(timeout, 0), 30)) + except TransferError as error: + return ("failed", error.reason) + except Exception: + return ("failed", "incomplete") + + # --------------------------------------------------------------- worker + def _sleep(self, delay: float) -> None: + deadline = time.monotonic() + delay + with self._cond: + while time.monotonic() < deadline: + if self._stopped: + raise TransferError("incomplete") + self._cond.wait(min(WAIT_SLICE, max(deadline - time.monotonic(), 0.001))) - def _retry(self, operation, check=lambda: None): - for attempt in range(3): + def _attempts(self, operation, check, budget: float): + """At most 3 attempts (0.5): back off within the remaining budget; never retry security failures.""" + limit = time.monotonic() + budget + for attempt in range(self._p.ATTEMPTS): check() try: return operation() except TransferError as error: - if not error.retryable or attempt == 2: + if not error.retryable or attempt == self._p.ATTEMPTS - 1: raise - delay = max(error.retry_after, random.uniform(0.02, 0.08) * (2 ** attempt)) - with self._condition: - if self._stopped: - raise TransferError("incomplete") from None - self._condition.wait(timeout=delay) + delay = self._p.backoff(attempt + 1, error) + if time.monotonic() + delay > limit: + raise TransferError("throttled" if error.reason == "throttled" else error.reason) from None + self._sleep(delay) + + def _check(self, job: _Job) -> None: + if self._stopped or job.cancelled: + raise TransferError("incomplete") + denied = job.extra.get("denied") + if denied: + raise TransferError(denied) + session = self._session + if session is None: + raise TransferError("expired") + if job.upload is None and session.expiring(): + raise TransferError("expired") + # Re-evaluated before every chunk and attempt: env hide flags and the + # negotiated policy can tighten at any time (deny-wins, never cached). + if job.spec is not None: + mime, direction, operation, source_kind, purpose, capture = job.spec + reason = self.policy.evaluate(session.policy, capture, direction=direction, mime_type=mime, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=job.kind == "import") + if reason: + raise TransferError(reason) + job.epoch = self._epoch def _worker(self) -> None: while True: - with self._condition: - while not self._queue and not self._stopped: - self._condition.wait() + self._maybe_renew() + with self._cond: + while not self._ready_q and not self._stopped: + self._cond.wait(WAIT_SLICE) if self._stopped: return - job = self._queue.popleft() + unit = self._ready_q.popleft() + if isinstance(unit, _Lane): + unit.scheduled = False + if not unit.jobs: + continue + job = unit.jobs.popleft() + unit.busy = True + self._active_jobs[id(unit)] = job + else: + job = unit + if job.handle is not None: + self._running[id(job.handle)] = job + if job.kind != "renew": + self._queued -= 1 + self._active += 1 + self._inflight.add(job) status = "incomplete" - lease = None try: - check = lambda: self._check(job) - check() - session = self._session - payload = job.payload - if type(payload) is OwnedRecordingFile: - lease = payload._open() - payload = lease - check() - job.upload = self._retry(lambda: self._transport.initialize(session, job.request, check), check) - self._retry(lambda: self._transport.transfer(session, job.upload, payload, check, self.config.chunk_bytes), check) - if lease is not None: - lease.check() - self._retry(lambda: self._transport.complete(session, job.upload, check), check) - status = "validating" - except Exception as error: - status = error.reason if isinstance(error, TransferError) else "incomplete" - if job.upload is not None: - try: - self._transport.abort(self._session, job.upload) - except Exception: - pass + status = self._run(job) + except TransferError as error: + status = error.reason + except Exception: + status = "incomplete" finally: - payload = None - if lease is not None: - lease.close() - with self._condition: - self._release(job, status) - self._condition.notify_all() - - def _release(self, job: _Job, status: str) -> None: - if self._jobs.pop(job.handle.occurrence_id, None) is not None: - self._bytes -= job.budget - job.payload = b"" - job.request = {} - job.upload = None - if status != "validating": - self._dropped += 1 - job.handle._finish(status) + with self._cond: + if job.kind != "renew": + self._active -= 1 + self._inflight.discard(job) + if job.handle is not None: + self._running.pop(id(job.handle), None) + if job.lane is not None: + job.lane.busy = False + self._active_jobs.pop(id(job.lane), None) + self._finish_job(job, status) + + def _finish_job(self, job: _Job, status: str, notify_lane: bool = True) -> None: + """Release budget, settle handles and writer callbacks outside the manager lock.""" + with self._cond: + if job.kind in ("upload", "segment", "import", "owned_wav") and not job.extra.get("released"): + job.extra["released"] = True + self._bytes = max(0, self._bytes - job.nbytes) + self._descriptors = max(0, self._descriptors - job.descriptors) + if status not in ("validating", "importing"): + self._dropped += 1 + job.payload = None + if notify_lane and job.lane is not None: + self._schedule_lane(job.lane) + self._cond.notify_all() + if job.kind == "segment": + job.lane.writer._segment_done(job.entry, status, job.upload if status == "validating" else None, + job.body, job.initialized, job.index) + elif job.kind == "manifest": + if not job.extra.get("reported"): + job.extra["reported"] = True + job.lane.writer._manifest_done(status == "validating", job.extra["revision"], job.extra["end"], + job.extra["completed"], fallback=job.extra.get("fallback", False)) + elif job.handle is not None: + if job.kind == "import": + job.handle._finish(status, job.extra.get("job_id")) + else: + job.handle._finish(status) + job.upload = None + + def _ctl(self) -> float: + return time.monotonic() + self.config.request_timeout + def _content_deadline(self) -> float: + limit = self._limits().transfer_timeout_seconds + return time.monotonic() + min(self.config.content_timeout, limit) + + def _run(self, job: _Job) -> str: + if job.kind == "renew": + self._renew_session() + return "validating" + if job.kind == "upload": + return self._run_upload(job, job.payload) + if job.kind == "segment": + return self._run_segment(job) + if job.kind == "manifest": + return self._run_manifest(job) + if job.kind == "import": + return self._run_import(job) + if job.kind == "owned_wav": + return self._run_owned_wav(job) + return "incomplete" + + def _content_source(self, payload): + if type(payload) is OwnedRecordingFile: + return payload._open() + if isinstance(payload, (bytes, bytearray, memoryview)): + return MemorySource(payload) + return payload + + def _renew_upload(self, job: _Job, session) -> None: + if job.renewals >= 3: + raise TransferError("expired") + job.renewals += 1 + job.upload = self._transport.renew_upload(session, job.upload, job.body, deadline=self._ctl()) + + def _with_capability(self, job: _Job, session, operation, check, budget: float): + """Renew before use when expiring (a), and once after a 401 (b).""" + def attempt(): + if job.upload.expiring(): + self._renew_upload(job, session) + try: + return operation() + except TransferError as error: + if error.http_status != 401: + raise + self._renew_upload(job, session) + try: + return operation() + except TransferError as second: + if second.http_status == 401: + raise TransferError("credential_scope_unsupported") from None + raise + return self._attempts(attempt, check, budget) + + def _abort_upload(self, job: _Job, session) -> None: + if job.upload is None or session is None: + return + try: + self._transport.abort(session, job.upload, key=self._p.idempotency_key("abort", job.upload.upload_id), + deadline=self._ctl()) + except Exception: + pass + + def _transfer(self, job: _Job, session, source, check, before_complete=None) -> str: + p = self._p + body = job.body + job.upload = self._attempts(lambda: self._transport.initialize( + session, body, key=p.idempotency_key("upload", job.occurrence_id), deadline=self._ctl(), check=check), + check, self.config.request_timeout * 3) + job.initialized = True + content_budget = self.config.content_timeout + self._with_capability(job, session, lambda: self._transport.put_content( + session, job.upload, source, deadline=self._content_deadline(), check=check, pacer=self._pacer, + chunk_bytes=self.config.chunk_bytes), check, content_budget * 3) + if before_complete is not None: + before_complete() + return self._with_capability(job, session, lambda: self._transport.complete( + session, job.upload, key=p.idempotency_key("complete", job.upload.upload_id), deadline=self._ctl(), + check=check), check, self.config.request_timeout * 3) + + def _run_upload(self, job: _Job, payload) -> str: + source = None + session = self._session + try: + check = lambda: self._check(job) + check() + source = self._content_source(payload) + check() + return self._transfer(job, session, source, check) + except TransferError as error: + if job.upload is not None: + self._abort_upload(job, session) + raise error + except Exception: + if job.upload is not None: + self._abort_upload(job, session) + raise + finally: + if source is not None and hasattr(source, "close"): + try: + source.close() + except Exception: + pass + + def _run_segment(self, job: _Job) -> str: + writer = job.lane.writer + entry = job.entry + session = self._session + check = lambda: self._check(job) + try: + check() + if writer._closing_partial: + raise TransferError("incomplete") + index = writer._next_index() + job.index = index + request = self._upload_request(writer._correlation, attachment_id=entry.attachment_id, + occurrence_id=entry.occurrence_id, mime_type="audio/wav", + direction=self._segment_direction(writer, entry), + source_kind="Bytes", purpose=writer._options.purpose, + declared_bytes=len(entry.source), + fields={k: v for k, v in (("conversation_id", writer._options.conversation_id), + ("turn_id", writer._options.turn_id)) if v}, + recording_id=writer.recording_id, segment_index=index) + job.body = self._p.encode(request) + before = None + if writer._fallback: + before = lambda: self._fallback_manifest(writer, job, session, check) + return self._transfer(job, session, entry.source, check, before) + except TransferError: + if job.upload is not None: + self._abort_upload(job, session) + raise + + @staticmethod + def _segment_direction(writer, entry) -> str: + if entry.track_id is None: + return "mixed" + for track in writer._tracks: + if track["track_id"] == entry.track_id: + return track["direction"] + return "mixed" + + def _fallback_manifest(self, writer, job, session, check) -> None: + """BR-7 fallback: init -> content -> manifest PUT (including this segment) -> complete.""" + with writer._lock: + entry = job.entry + entry.state, entry.index, entry.upload, entry.body = "completed", job.index, job.upload, job.body + writer._completed += 1 + end = writer._settled_end() + body = writer._manifest_body(end, final=False) + writer._completed -= 1 + entry.state, entry.upload = "pending", None + writer._revision += 1 + revision = writer._revision + if body is None: + return + try: + self._put_with_entry(writer, session, job, body, revision, check) + writer._manifest_done(True, revision, end, writer._completed + 1) + except TransferError: + with writer._lock: + writer._closing_partial = True + raise TransferError("incomplete") from None + + def _put_with_entry(self, writer, session, job, body, revision, check) -> None: + p = self._p + self._with_capability(job, session, lambda: self._transport.put_manifest( + session, job.upload.capability, writer.recording_id, body, + key=p.idempotency_key("manifest", writer.recording_id, revision), + deadline=time.monotonic() + self.config.manifest_timeout, check=check), check, + self.config.manifest_timeout * 3) + + def _run_manifest(self, job: _Job) -> str: + writer = job.lane.writer + session = self._session + candidates = writer._capability_entries() + if not candidates: + return "incomplete" + ok = self._put_manifest_with(writer, session, job.body, job.extra["revision"], candidates, + time.monotonic() + self.config.manifest_timeout * 3, lambda: self._check(job)) + if ok is None: + job.extra["fallback"] = True + return "incomplete" + return "validating" if ok else "incomplete" + + def _put_manifest_with(self, writer, session, body, revision, candidates, deadline, check): + """Latest completed segment's capability first (3.3); renew it; fall back to older ones. + + Returns True on success, False on failure, None when BR-7's fallback order applies. + """ + p = self._p + key = p.idempotency_key("manifest", writer.recording_id, revision) + rejected = False + for entry in reversed(candidates): + holder = _Job("manifest", body=entry.body) + holder.upload = entry.upload + attempts = [0] + + def put(): + attempts[0] += 1 + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete") + try: + self._transport.put_manifest(session, holder.upload.capability, writer.recording_id, body, + key=key, deadline=time.monotonic() + min( + self.config.manifest_timeout, remaining), check=check) + except TransferError as error: + # BR-5: a replayed rev whose stored body is identical replays as success. + if error.reason == "conflict" and error.http_status == 409 and attempts[0] > 1: + return None + raise + try: + if holder.upload.expiring(): + self._renew_upload(holder, session) + self._with_capability(holder, session, put, check, max(deadline - time.monotonic(), 0.001)) + entry.upload = holder.upload + return True + except TransferError as error: + entry.upload = holder.upload + if error.reason == "expired": + continue + if error.http_status in (401, 403, 409) or error.reason in ("credential_scope_unsupported", + "policy_denied", "conflict"): + rejected = True + return None if rejected else False + return False + + def _put_manifest_now(self, writer, body: bytes, revision: int, candidates, deadline: float) -> bool: + session = self._session + if session is None: + return False + + def check(): + if time.monotonic() > deadline: + raise TransferError("incomplete") + try: + return bool(self._put_manifest_with(writer, session, body, revision, candidates, deadline, check)) + except TransferError: + return False + except Exception: + return False + + def _run_import(self, job: _Job) -> str: + p = self._p + session = self._session + check = lambda: self._check(job) + recording_id = job.extra["recording_id"] + result = self._attempts(lambda: self._transport.submit_import( + session, job.body, key=p.idempotency_key("import", recording_id), deadline=self._ctl(), check=check), + check, self.config.request_timeout * 3) + job.extra["job_id"] = result.job_id + return "importing" + + def _run_owned_wav(self, job: _Job) -> str: + """Tier ``wav_recording``: segments synthesized from lease ranges; never materialized.""" + p = self._p + session = self._session + check = lambda: self._check(job) + extra = job.extra + lease = None + try: + check() + lease = job.payload._open() + header = lease.read(0, min(4096, len(lease))) + info = parse_wav(header, len(lease)) + limits = self._limits() + single_cap = min(limits.max_upload_bytes, 50 * MiB) + if info is None: + lease.close() + lease = None + if job.payload.size <= single_cap: + job.handle.tier = "single" + return self._owned_single(job) + return "too_large" + duration_ms = -(-info.frames * 1000 // info.rate) + if info.data_bytes > min(limits.recording_bytes, 1073741824) or duration_ms > min( + limits.recording_duration_ms, 7200000): + return "too_large" + tracks_spec = extra["tracks"] + if info.channels == 1: + layout, tracks = "mixed", [{"track_id": str(uuid.uuid4()), "channels": [0], "direction": "mixed", + "role": tracks_spec[0].role if tracks_spec and len(tracks_spec) == 1 + else "unknown"}] + elif info.channels == 2 and tracks_spec and len(tracks_spec) == 2: + layout = "stereo" + tracks = [{"track_id": str(uuid.uuid4()), "channels": list(t.channels), "direction": t.direction, + "role": t.role} for t in tracks_spec] + else: + layout, tracks = "mixed", [{"track_id": str(uuid.uuid4()), "channels": list(range(info.channels)), + "direction": "mixed", "role": "unknown"}] + seg_ms = min(limits.segment_duration_ms, MAX_SEGMENT_MS) + seg_bytes = min(limits.segment_bytes, limits.max_upload_bytes, MAX_SEGMENT_BYTES) + frames_per = segment_frames(info.rate, info.channels * 2, seg_ms, seg_bytes) + if not frames_per: + return "too_large" + segments, gaps, completed = [], [], [] + start = 0 + while start < info.frames: + count = min(frames_per, info.frames - start) + end = start + count + final = end == info.frames + start_ms = to_ms(start, info.rate) + duration = to_ms(end, info.rate, final) - start_ms + source = WavSegmentSource(lease, info, start, count) + part = _Job("segment", spec=job.spec, epoch=job.epoch, occurrence_id=str(uuid.uuid4())) + part.cancelled = job.cancelled + index = len(completed) + request = self._upload_request( + extra["correlation"], attachment_id=str(uuid.uuid4()), occurrence_id=part.occurrence_id, + mime_type="audio/wav", direction="mixed" if layout == "mixed" else job.spec[1], + source_kind="OwnedRecordingFile", purpose=job.spec[4], declared_bytes=len(source), + fields={"conversation_id": extra["conversation_id"]} if extra["conversation_id"] else None, + recording_id=extra["recording_id"], segment_index=index) + part.body = p.encode(request) + try: + self._transfer(part, session, source, lambda: (self._check(job), self._check(part))) + entry = type("E", (), {})() + entry.upload, entry.body = part.upload, part.body + completed.append(entry) + segments.append({"occurrence_id": part.occurrence_id, "index": index, "start_ms": start_ms, + "duration_ms": duration}) + except TransferError as error: + if part.upload is not None: + self._abort_upload(part, session) + if error.reason == "source_unavailable" or job.cancelled or self._stopped: + gaps.append({"start_ms": start_ms, "duration_ms": to_ms(info.frames, info.rate, True) - start_ms, + "reason": "incomplete"}) + break + gaps.append({"start_ms": start_ms, "duration_ms": duration, "reason": "incomplete"}) + start = end + if not completed: + return "incomplete" + manifest = build_manifest(extra["recording_id"], info.rate, layout, tracks, segments, gaps, [], + duration_ms, True) + body = p.encode(manifest) + fake_writer = type("W", (), {"recording_id": extra["recording_id"]})() + ok = self._put_manifest_with(fake_writer, session, body, 1, completed, + time.monotonic() + self.config.manifest_timeout * 3, check) + if ok and not gaps: + return "validating" + return "incomplete" + finally: + if lease is not None: + lease.close() + + def _owned_single(self, job: _Job) -> str: + extra = job.extra + request = self._upload_request( + extra["correlation"], attachment_id=str(uuid.uuid4()), occurrence_id=str(uuid.uuid4()), + mime_type="audio/wav", direction=job.spec[1], source_kind="OwnedRecordingFile", purpose=job.spec[4], + declared_bytes=job.payload.size, + fields={"conversation_id": extra["conversation_id"]} if extra["conversation_id"] else None) + single = _Job("upload", body=self._p.encode(request), spec=job.spec, epoch=job.epoch, + occurrence_id=request["occurrence_id"]) + single.cancelled = job.cancelled + return self._run_upload(single, job.payload) + + def _renew_session(self) -> None: + p = self._p + try: + session = self._session + if session is None: + return + with self._cond: + self._renew_sequence += 1 + sequence = self._renew_sequence + remaining = max(session.expires_at - time.time() - p.SKEW_SECONDS, 0.001) + renewed = self._attempts(lambda: self._transport.renew_session( + session, sequence=sequence, deadline=self._ctl()), self._alive, + min(remaining, self.config.request_timeout * 3)) + tighter = session.policy.tighter_than(renewed.policy) + with self._cond: + self._session = renewed + if tighter: + self.update_policy(renewed.policy) + except TransferError as error: + if error.reason == "scope_unresolved": + self._invalidate("scope_unresolved") + except Exception: + pass + finally: + with self._cond: + self._renew_pending = False + # A failed renewal is retried at the next activity, at most once per second. + self._renew_after = time.monotonic() + 1.0 + + def _invalidate(self, reason: str) -> None: + with self._cond: + self._state = reason + self._session = None + self._epoch += 1 + dropped = [unit for unit in self._ready_q if isinstance(unit, _Job) and unit.kind != "renew"] + self._ready_q = deque(unit for unit in self._ready_q if not (isinstance(unit, _Job) and unit.kind != "renew")) + self._queued -= len(dropped) + self._cond.notify_all() + for job in dropped: + self._finish_job(job, reason) + + # ------------------------------------------------------- policy/flush def update_policy(self, server: ServerPolicy) -> None: - """Invalidate all admitted work, including an active transfer/retry. + """Re-evaluate admitted work. Tightening discards; loosening affects only new admissions. Only the control-plane owner should call this with a negotiated policy. - No queued data survives re-enablement. In-flight I/O checks before the - next bounded chunk; already sent bytes cannot be recalled locally. + In-flight I/O re-checks before the next bounded chunk; bytes already + sent cannot be recalled locally. """ - with self._condition: + if not self._enabled: + return + dropped = [] + with self._cond: self._epoch += 1 if self._session is not None: old = self._session - self._session = Session(old.project_id, old.capture_session_id, server, old.expires_at, old.max_upload_bytes) - while self._queue: - self._release(self._queue.popleft(), "policy_denied") - self._condition.notify_all() - - def cancel(self, handle: AttachmentHandle) -> None: - with self._condition: - job = self._jobs.get(handle.occurrence_id) - if job: - job.cancelled = True - if job in self._queue: - self._queue.remove(job) - self._release(job, "incomplete") - self._condition.notify_all() + self._session = dataclasses.replace(old, policy=server) + kept = deque() + for unit in self._ready_q: + if isinstance(unit, _Job) and unit.spec is not None and unit.kind != "renew": + mime, direction, operation, source_kind, purpose, capture = unit.spec + reason = self.policy.evaluate(server, capture, direction=direction, mime_type=mime, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=unit.kind == "import") + if reason: + dropped.append((unit, reason)) + self._queued -= 1 + continue + unit.epoch = self._epoch + kept.append(unit) + self._ready_q = kept + # Nothing is resurrected: in-flight and lane work denied by ANY + # tightening stays denied even if a later policy loosens again. + pending = list(self._inflight) + [job for lane in self._lanes for job in lane.jobs] + for job in pending: + if job.spec is not None and job.kind != "renew": + mime, direction, operation, source_kind, purpose, capture = job.spec + reason = self.policy.evaluate(server, capture, direction=direction, mime_type=mime, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=job.kind == "import") + else: + reason = None + if reason and not job.extra.get("denied"): + job.extra["denied"] = reason + self._cond.notify_all() + for job, reason in dropped: + self._finish_job(job, reason) + for ticket in list(self._tickets): + if ticket.admitted and not ticket._used: + reason = self._recheck_ticket(ticket) + if reason: + ticket._revoke(reason) + + def _lane_denial(self, writer, server) -> Optional[str]: + options = writer._options + capture = options.capture_policy or CapturePolicy() + directions = ([t.direction for t in options.tracks] if options.layout == "separate_tracks" else ["mixed"]) + reasons = [self.policy.evaluate(server, capture, direction=d, mime_type="audio/wav", source_kind="Bytes", + operation=options.operation, purpose=options.purpose) for d in directions] + return reasons[0] if all(reasons) else None + + def cancel(self, handle) -> None: + """Drop a queued job, or make a running one stop at its next chunk boundary.""" + target = None + with self._cond: + for unit in list(self._ready_q): + if isinstance(unit, _Job) and unit.handle is handle: + self._ready_q.remove(unit) + self._queued -= 1 + target = unit + break + running = self._running.get(id(handle)) + if running is not None: + running.cancelled = True + self._cond.notify_all() + if target is not None: + target.cancelled = True + self._finish_job(target, "incomplete") + + def _unfinished(self) -> int: + return (self._queued + self._active + sum(1 for s in self._streams if s.open) + len(self._recordings)) def flush(self, timeout: float = 5) -> FlushResult: - deadline = time.monotonic() + max(0, min(timeout, 30)) - with self._condition: - while self._jobs and time.monotonic() < deadline: - self._condition.wait(timeout=deadline - time.monotonic()) - return FlushResult(len(self._jobs), self._dropped) + if self._p is None: + return FlushResult(0, self._dropped) + self._sweep() + deadline = time.monotonic() + max(0.0, min(float(timeout), 30.0)) + with self._cond: + while (self._queued or self._active) and time.monotonic() < deadline: + self._cond.wait(min(WAIT_SLICE, max(deadline - time.monotonic(), 0.001))) + return FlushResult(self._unfinished(), self._dropped) async def flush_async(self, timeout: float = 5) -> FlushResult: return await asyncio.to_thread(self.flush, timeout) def shutdown(self, timeout: Optional[float] = None) -> FlushResult: - with self._condition: - if self._stopped: - return FlushResult(len(self._jobs), self._dropped) - deadline = time.monotonic() + (self.config.shutdown_timeout if timeout is None else max(0, min(timeout, 30))) - self.flush(max(0, deadline - time.monotonic())) - with self._condition: - self._stopped = True - self._status = "incomplete" - while self._queue: - self._release(self._queue.popleft(), "incomplete") - self._condition.notify_all() - for worker in self._threads: - if worker is not threading.current_thread(): - worker.join(max(0, deadline - time.monotonic())) - with self._condition: - return FlushResult(len(self._jobs), self._dropped) + """Bounded and idempotent: returns within ``timeout + 250 ms``.""" + budget = self.config.shutdown_timeout if timeout is None else max(0.0, min(float(timeout), 30.0)) + start = time.monotonic() + deadline = start + budget + with self._cond: + if self._stopping or self._stopped: + first = False + else: + first = True + self._stopping = True + self._shutdown_deadline = deadline + self._cond.notify_all() + if not first: + self._shutdown_done.wait(max(0.0, min(budget, 30.0))) + with self._cond: + return self._shutdown_result or FlushResult(self._unfinished(), self._dropped) + try: + for writer in list(self._recordings): + remaining = deadline - time.monotonic() + try: + writer.finish(max(remaining, 0.0)) + except Exception: + pass + for stream in list(self._streams): + stream.abort("incomplete") + for ticket in list(self._tickets): + ticket.release() + self.flush(max(deadline - time.monotonic(), 0.0)) + dropped = [] + with self._cond: + self._stopped = True + self._state = "incomplete" + while self._ready_q: + unit = self._ready_q.popleft() + if isinstance(unit, _Lane): + dropped.extend(unit.jobs) + self._queued -= len(unit.jobs) + unit.jobs.clear() + elif unit.kind != "renew": + dropped.append(unit) + self._queued -= 1 + for job in self._active_jobs.values(): + job.cancelled = True + self._cond.notify_all() + for job in dropped: + job.cancelled = True + self._finish_job(job, "incomplete", notify_lane=False) + current = threading.current_thread() + for worker in list(self._threads) + ([self._bootstrap_thread] if self._bootstrap_thread else []): + if worker is not current: + worker.join(max(0.0, deadline - time.monotonic())) + with self._cond: + self._shutdown_result = FlushResult(self._unfinished(), self._dropped) + return self._shutdown_result + finally: + self._shutdown_done.set() class AttachmentSpanProcessor(SpanProcessor): - """Publish the non-secret writer correlation carrier before span export.""" + """Provider wiring only: flush/shutdown. No span is stamped at start (0.8).""" - def __init__(self, manager: AttachmentManager): + def __init__(self, manager): self.manager = manager def on_start(self, span, parent_context=None): - if self.manager.config.enabled and span.is_recording(): - span.set_attribute("fi.attachment.capture_session_id", self.manager.capture_session_id) - span.set_attribute("fi.attachment.correlation_nonce", self.manager.correlation_nonce) + pass def on_end(self, span): pass diff --git a/python/fi_instrumentation/attachments/policy.py b/python/fi_instrumentation/attachments/policy.py index 75fa30539..afaef4d9b 100644 --- a/python/fi_instrumentation/attachments/policy.py +++ b/python/fi_instrumentation/attachments/policy.py @@ -1,15 +1,24 @@ """Attachment admission is independent of span masking and always deny-wins. -This module never inspects a source. In particular, text PII redaction does not -claim to sanitize audio. Server-side validation is not pre-egress redaction. +The decision is the F01 privacy table (``_privacy_table.json``, vendored from +``spec/attachments/v1/privacy-table.json``) evaluated over facts built here. +This module never inspects a source. Text PII redaction does not claim to +sanitize media, and server-side validation is not pre-egress redaction. """ +import json import os from dataclasses import dataclass, field +from functools import lru_cache +from pathlib import Path from typing import Optional from fi_instrumentation.instrumentation.config import TraceConfig +from .types import MIME_MODALITIES, PURPOSES + +MiB = 1024 * 1024 + def _flag(name: str, default: bool = False) -> bool: value = os.getenv(name) @@ -24,20 +33,56 @@ def _restriction(name: str) -> bool: return value is not None and value.strip().lower() not in ("false", "0", "no") +def env_disabled() -> bool: + """An explicit environment disable cannot be overridden by code or config.""" + return os.getenv("FI_ATTACHMENTS_ENABLED") is not None and not _flag("FI_ATTACHMENTS_ENABLED") + + +# name: (default, ceiling, integer?) +_BOUNDS = { + "max_descriptors": (128, 128, True), + "max_owned_bytes": (32 * MiB, 32 * MiB, True), + "workers": (2, 2, True), + "chunk_bytes": (256 * 1024, 256 * 1024, True), + "sync_copy_bytes": (8 * MiB, 32 * MiB, True), + "window_segments": (2, 4, True), + "request_timeout": (2.0, 30.0, False), + "content_timeout": (120.0, 600.0, False), + "manifest_timeout": (10.0, 30.0, False), + "shutdown_timeout": (5.0, 30.0, False), + "finalization_timeout": (30.0, 30.0, False), + "ticket_ttl": (10.0, 30.0, False), + "stream_idle_ttl": (60.0, 300.0, False), +} + + @dataclass(frozen=True) class AttachmentConfig: + """Client configuration. Every flag defaults OFF. + + ``enabled`` and ``record_audio``/``record_video`` fall back to the + ``FI_ATTACHMENTS_*`` environment once, when this object is built. + """ + enabled: Optional[bool] = None record_audio: Optional[bool] = None record_video: Optional[bool] = None allow_unredacted_media_with_text_pii: Optional[bool] = None endpoint: Optional[str] = field(default=None, repr=False) + workspace_id: Optional[str] = None max_descriptors: int = 128 - max_owned_bytes: int = 32 * 1024 * 1024 - max_attachment_bytes: int = 8 * 1024 * 1024 + max_owned_bytes: int = 32 * MiB workers: int = 2 chunk_bytes: int = 256 * 1024 + sync_copy_bytes: int = 8 * MiB + window_segments: int = 2 request_timeout: float = 2.0 + content_timeout: float = 120.0 + manifest_timeout: float = 10.0 shutdown_timeout: float = 5.0 + finalization_timeout: float = 30.0 + ticket_ttl: float = 10.0 + stream_idle_ttl: float = 60.0 def __post_init__(self) -> None: for name in ("enabled", "record_audio", "record_video", "allow_unredacted_media_with_text_pii"): @@ -48,32 +93,47 @@ def __post_init__(self) -> None: raise ValueError("attachment flags must be booleans") if self.endpoint is None: object.__setattr__(self, "endpoint", os.getenv("FI_ATTACHMENTS_ENDPOINT")) - for name, ceiling in (("max_descriptors", 128), ("max_owned_bytes", 32 * 1024 * 1024), - ("max_attachment_bytes", 8 * 1024 * 1024), ("workers", 2), - ("chunk_bytes", 256 * 1024)): + if self.workspace_id is not None and not isinstance(self.workspace_id, str): + raise ValueError("invalid attachment workspace") + for name, (_, ceiling, integer) in _BOUNDS.items(): value = getattr(self, name) - if type(value) is not int or not 0 < value <= ceiling: - raise ValueError("invalid attachment resource bound") - for value in (self.request_timeout, self.shutdown_timeout): - if not isinstance(value, (int, float)) or not 0 < value <= 30: + if integer: + if type(value) is not int or not 0 < value <= ceiling: + raise ValueError("invalid attachment resource bound") + elif isinstance(value, bool) or not isinstance(value, (int, float)) or not 0 < value <= ceiling: raise ValueError("invalid attachment deadline") @dataclass(frozen=True) class ServerPolicy: - """Negotiated policy; unknown policy is never permissive.""" + """Negotiated F01 ``Policy``; an unknown policy is never permissive.""" enabled: bool = False credential_write: bool = False - allowed_sources: frozenset[str] = frozenset() - allowed_directions: frozenset[str] = frozenset() + allowed_sources: frozenset = frozenset() + allowed_modalities: frozenset = frozenset(("audio",)) + allowed_directions: frozenset = frozenset(("input", "output", "mixed")) require_media_redaction: bool = True require_metadata_removal: bool = True allow_unredacted_media_with_text_pii: bool = False record_audio: bool = False + record_video: bool = False version: str = "" deletion_generation: int = 0 + def tighter_than(self, other: "ServerPolicy") -> bool: + """True when any admission allowed by ``self`` might be denied by ``other``.""" + return (self.version != other.version or (self.enabled and not other.enabled) + or (self.credential_write and not other.credential_write) + or not other.allowed_sources >= self.allowed_sources + or not other.allowed_modalities >= self.allowed_modalities + or not other.allowed_directions >= self.allowed_directions + or (other.require_media_redaction and not self.require_media_redaction) + or (other.require_metadata_removal and not self.require_metadata_removal) + or (self.allow_unredacted_media_with_text_pii and not other.allow_unredacted_media_with_text_pii) + or (self.record_audio and not other.record_audio) + or (self.record_video and not other.record_video)) + @dataclass(frozen=True) class CapturePolicy: @@ -81,7 +141,7 @@ class CapturePolicy: Adapters must preserve model-input ancestry even for tool outputs. Unknown direction is treated as mixed; a caller cannot relabel a mixed recording. - No qualified local audio sanitizer is installed by this runtime. + No qualified local media sanitizer is installed by this runtime. """ capture_content: bool = True @@ -94,67 +154,128 @@ class CapturePolicy: contains_input: bool = False contains_output: bool = False error_detail: bool = False + # Deprecated alias for operation="create_recording"; kept deny-wins. new_recording: bool = False - def __post_init__(self) -> None: if any(type(value) is not bool for value in vars(self).values()): raise ValueError("capture policy facts must be booleans") +@lru_cache(maxsize=1) +def _table(): + from jsonschema import Draft202012Validator # enabled managers only + + table = json.loads(Path(__file__).with_name("_privacy_table.json").read_text()) + context = Draft202012Validator(table["context_schema"]) + rules = tuple((rule["reason"], Draft202012Validator(rule["deny_if"])) for rule in table["rules"]) + return context, rules + + +def decide(facts: dict) -> Optional[str]: + """Interpret the ordered F01 privacy table. None means allowed (``queued``).""" + context, rules = _table() + if not context.is_valid(facts): + return "policy_denied" + for reason, rule in rules: + if rule.is_valid(facts): + return reason + return None + + +_HIDE = ("hide_inputs", "hide_outputs", "hide_input_messages", "hide_output_messages", + "hide_input_images", "hide_input_text", "hide_output_text", "hide_error_details", "pii_redaction") + + class AttachmentPolicy: def __init__(self, config: AttachmentConfig, trace_config: Optional[TraceConfig] = None): self.config = config self.trace_config = trace_config or TraceConfig() + def _hidden(self, name: str) -> bool: + return bool(getattr(self.trace_config, name, False)) or _restriction("FI_" + name.upper()) + + def facts(self, server: Optional[ServerPolicy], capture: CapturePolicy, *, direction: str, + mime_type: str, source_kind: str, operation: str = "observe_consumed", + purpose: Optional[str] = None, import_source: bool = False) -> dict: + """Build the F01 privacy-table context. Unknown facts fail closed.""" + modality = MIME_MODALITIES.get(mime_type, "file") + known = server is not None + server = server or ServerPolicy() + ancestry = purpose in ("model_input", "computer_screenshot") or capture.model_input + record_audio = self.config.record_audio and ( + os.getenv("FI_ATTACHMENTS_RECORD_AUDIO") is None or _flag("FI_ATTACHMENTS_RECORD_AUDIO")) + record_video = self.config.record_video and ( + os.getenv("FI_ATTACHMENTS_RECORD_VIDEO") is None or _flag("FI_ATTACHMENTS_RECORD_VIDEO")) + if capture.new_recording: + operation = "create_recording" + facts = { + "enabled": self.config.enabled and not env_disabled(), + "endpoint_configured": True, + "policy_known": known, + "server_allowed": server.enabled, + "credential_allowed": server.credential_write, + "integration_capture_content": capture.capture_content, + "integration_record_inputs": capture.record_inputs, + "integration_record_outputs": capture.record_outputs, + "muted": capture.muted, + "temporary_chat": capture.temporary_chat, + "server_require_media_redaction": server.require_media_redaction, + "qualified_client_sanitizer": False, + "allow_unredacted_media_with_text_pii": self.config.allow_unredacted_media_with_text_pii, + "server_allow_unredacted_media_with_text_pii": server.allow_unredacted_media_with_text_pii, + "require_metadata_removal": server.require_metadata_removal, + "qualified_client_metadata_removal": False, + "modality_allowed": modality in server.allowed_modalities and direction in server.allowed_directions, + "source_authorized": source_kind in server.allowed_sources, + "call_requested": capture.requested, + # Steps 9-12 of preflight check these against the real target/budget. + "sampled": True, "correlation_available": True, "generation_current": True, + "source_available": True, "budget_available": True, "queue_available": True, + "direction": direction, + "semantic_input": direction in ("input", "mixed") or capture.contains_input or ancestry, + "semantic_output": direction in ("output", "mixed") or capture.contains_output, + "model_bound_image": modality == "image" and ancestry, + "opaque_text_possible": True, + "error_diagnostic": capture.error_detail or purpose == "diagnostic", + "modality": modality, + "source_kind": source_kind, + "operation": operation, + "record_audio": record_audio, + "record_video": record_video, + "server_record_audio": server.record_audio, + "server_record_video": server.record_video, + "browser_remote_fetch": False, + # The SDK never fetches. Only a server-minted envelope import (whose + # fetch the trusted importer qualified) reaches a RemoteUrl kind. + "remote_destination_approved": import_source, "all_addresses_public": import_source, + "tls_ip_pinned": import_source, "redirects_revalidated": import_source, + "ambient_credentials_absent": import_source, + # Only scope-created OwnedRecordingFile objects reach this point. + "owned_session_bound": source_kind == "OwnedRecordingFile", + "owned_file_lease_valid": source_kind == "OwnedRecordingFile", + # Provider connection authority and completion are checked by the + # server and the resolver respectively; only the import path sets them. + "provider_connection_authorized": import_source, + "provider_output_completed": import_source, + "explicit_partial_allowed": False, + } + for name in _HIDE: + facts[name] = self._hidden(name) + return facts + def evaluate(self, server: Optional[ServerPolicy], capture: CapturePolicy, *, - direction: str, mime_type: str, source_kind: str) -> Optional[str]: - if not self.config.enabled: - return "disabled" - # An explicit environment disable cannot be overridden by a call/config. - if os.getenv("FI_ATTACHMENTS_ENABLED") is not None and not _flag("FI_ATTACHMENTS_ENABLED"): + direction: str, mime_type: str, source_kind: str, operation: str = "observe_consumed", + purpose: Optional[str] = None, import_source: bool = False) -> Optional[str]: + """Deny-wins privacy decision; returns the first denial reason or None.""" + if not self.config.enabled or env_disabled(): return "disabled" if server is None: return "bootstrap_pending" - if not server.enabled: - return "policy_denied" - if not server.credential_write: - return "credential_scope_unsupported" - if not capture.capture_content or capture.muted or capture.temporary_chat or not capture.requested: - return "policy_denied" - inputs = direction in ("input", "mixed") or capture.contains_input or capture.model_input - outputs = direction in ("output", "mixed") or capture.contains_output - if direction not in ("input", "output", "mixed"): - return "policy_denied" - if inputs and not capture.record_inputs or outputs and not capture.record_outputs: - return "policy_denied" - - def hidden(name: str) -> bool: - return bool(getattr(self.trace_config, name)) or _restriction("FI_" + name.upper()) - - if inputs and any(hidden(n) for n in ("hide_inputs", "hide_input_messages", "hide_input_text")): - return "policy_denied" - if outputs and any(hidden(n) for n in ("hide_outputs", "hide_output_messages", "hide_output_text")): - return "policy_denied" - if inputs and mime_type.startswith("image/") and hidden("hide_input_images"): - return "policy_denied" - if capture.error_detail and hidden("hide_error_details"): - return "policy_denied" - if server.require_media_redaction or server.require_metadata_removal: - return "redaction_unavailable" - if hidden("pii_redaction") and not ( - self.config.allow_unredacted_media_with_text_pii - and server.allow_unredacted_media_with_text_pii - ): - return "redaction_unavailable" - if direction not in server.allowed_directions or source_kind not in server.allowed_sources: + if direction not in ("input", "output", "mixed") or (purpose is not None and purpose not in PURPOSES): return "policy_denied" - record_audio = self.config.record_audio and server.record_audio - if os.getenv("FI_ATTACHMENTS_RECORD_AUDIO") is not None: - record_audio = record_audio and _flag("FI_ATTACHMENTS_RECORD_AUDIO") - if capture.new_recording and not record_audio: - return "recording_disabled" - # Wave A is audio only. Other modalities remain explicitly unsupported. - if mime_type not in ("audio/wav", "audio/L16", "audio/flac", "audio/mpeg", "audio/ogg", "audio/mp4", "audio/webm"): + if mime_type not in MIME_MODALITIES: return "source_unavailable" - return None + return decide(self.facts(server, capture, direction=direction, mime_type=mime_type, + source_kind=source_kind, operation=operation, purpose=purpose, + import_source=import_source)) diff --git a/python/fi_instrumentation/attachments/protocol.py b/python/fi_instrumentation/attachments/protocol.py index 02f7c720f..b6cb0d634 100644 --- a/python/fi_instrumentation/attachments/protocol.py +++ b/python/fi_instrumentation/attachments/protocol.py @@ -1,43 +1,229 @@ -"""Versioned fi.attachments.v1 adapter. No storage/source URLs are followed. +"""The ONE versioned fi.attachments.v1 wire adapter (design section 9). -Only a separately configured HTTPS control origin is used. This adapter uses no -ambient proxies, cookies, netrc, redirects, or instrumentation. Server validation -and occurrence binding remain prerequisites for playback; a completed transfer -is only `validating`. +Every HTTP shape, path, header, idempotency key, status mapping and response +validation lives here. Managers, writers and imports call only this interface; +test doubles implement it. Only a separately configured HTTPS control origin is +used: no ambient proxies, cookies, netrc, redirects or instrumentation. A +completed transfer is only ``validating``; readiness is a server decision. + +Importing this module imports ``jsonschema`` lazily (on first validation) and +``http.client``/``ssl``; only an ENABLED manager's transport construction does. """ import http.client import json +import random import re import ssl +import threading import time import uuid -from functools import lru_cache -from pathlib import Path - -from jsonschema import Draft202012Validator, FormatChecker from dataclasses import dataclass, field from datetime import datetime -from typing import Callable, Mapping, Optional +from functools import lru_cache +from pathlib import Path +from typing import Callable, Mapping, Optional, Tuple from urllib.parse import urlsplit from fi_instrumentation.instrumentation.config import suppress_tracing +from .errors import TransferError from .policy import ServerPolicy +from .types import SAFE_REASONS, canonical_uuid +SKEW_SECONDS = 5.0 +ATTEMPTS = 3 +_SUCCESS_BODY = 64 * 1024 +_ERROR_BODY = 4 * 1024 +_CREDENTIAL_HEADERS = ("authorization", "x-api-key", "x-secret-key", "x-workspace-id") -class TransferError(Exception): - def __init__(self, reason: str, retryable: bool = False, retry_after: float = 0): - # Never preserve a server body, URL, token, or originating exception. - safe_reasons = {"disabled", "bootstrap_pending", "policy_denied", "credential_scope_unsupported", - "source_unavailable", "unsupported_version", "endpoint_unconfigured", "scope_unresolved", - "redaction_unavailable", "recording_disabled", "expired", "deleted", "incomplete", - "too_large", "throttled", "conflict", "validation_failed"} - reason = reason if reason in safe_reasons else "incomplete" - super().__init__(reason) - self.reason = reason - self.retryable = retryable - self.retry_after = min(max(retry_after, 0), 2) +# HTTP status -> (default reason, retryable, Error.code refinements allowed). Section 0.5. +_STATUS = { + 400: ("unsupported_version", False, frozenset(("unsupported_version",))), + 401: ("credential_scope_unsupported", False, frozenset(("credential_scope_unsupported", "expired"))), + 403: ("policy_denied", False, frozenset(("policy_denied", "redaction_unavailable", "recording_disabled", + "correlation_unavailable", "credential_scope_unsupported"))), + 404: ("not_found", False, frozenset(("not_found", "scope_unresolved"))), + 409: ("conflict", False, frozenset(("conflict", "deleted", "expired", "policy_denied"))), + 410: ("expired", False, frozenset(("expired", "deleted"))), + 413: ("too_large", False, frozenset(("too_large",))), + 429: ("throttled", True, frozenset()), +} +for _code in (408, 500, 502, 503, 504): + _STATUS[_code] = ("incomplete", True, frozenset()) + + +def map_status(status: int, error_body: bytes = b"", retry_after: Optional[str] = None) -> TransferError: + """Section 0.5: one table for every route, with in-class ``Error.code`` refinement.""" + reason, retryable, refinements = _STATUS.get(status, ("incomplete", False, frozenset())) + if refinements and error_body: + try: + value = strict_json(error_body) + if (isinstance(value, dict) and set(value) == {"code", "request_id"} + and canonical_uuid(value["request_id"]) and value["code"] in refinements): + reason = value["code"] + except Exception: + pass + delay = 0.0 + if status == 429: + delay = 1.0 + if retry_after is not None: + text = retry_after.strip() + # Integer delta-seconds only; an HTTP-date is treated as 1 s. + delay = min(float(int(text)), 5.0) if text.isdigit() else 1.0 + return TransferError(reason, retryable, delay, status) + + +def strict_json(raw: bytes): + def pairs(items): + result = {} + for key, value in items: + if key in result: + raise TransferError("unsupported_version") + result[key] = value + return result + + def constant(_value): + raise TransferError("unsupported_version") + + return json.loads(raw, object_pairs_hook=pairs, parse_constant=constant) + + +def encode(value: dict) -> bytes: + return json.dumps(value, separators=(",", ":"), sort_keys=False).encode() + + +def hexid(value: str) -> str: + return uuid.UUID(value).hex + + +def idempotency_key(route: str, identifier: str, sequence: Optional[int] = None) -> str: + """Section 0.6 key derivations (F01 Token).""" + prefix = {"bootstrap": "bs", "upload": "up", "complete": "cp", "abort": "ab", + "manifest": "mf", "import": "im"}[route] + key = prefix + "-" + hexid(identifier) + return key if sequence is None else key + "-" + str(int(sequence)) + + +@lru_cache(maxsize=1) +def _schema() -> dict: + return json.loads(Path(__file__).with_name("_protocol_schema.json").read_text()) + + +@lru_cache(maxsize=32) +def _validator(name: str): + from jsonschema import Draft202012Validator, FormatChecker + + return Draft202012Validator({**_schema(), "$ref": "#/$defs/" + name}, format_checker=FormatChecker()) + + +def is_valid(name: str, value) -> bool: + return _validator(name).is_valid(value) + + +def wire_valid(name: str, value) -> bool: + """Schema plus the cross-field rules mirrored from F01 ``validate.py`` (SDK shapes).""" + try: + if not is_valid(name, value): + return False + if name == "SpanAttributes": + raw = value["fi.attachment.refs"] + return len(raw.encode("utf-8")) <= 16384 and wire_valid("References", strict_json(raw.encode())) + if name == "References": + ids = [entry["occurrence_id"] for entry in value] + return len(ids) == len(set(ids)) and all(wire_valid("Reference", entry) for entry in value) + if name in ("Reference", "UploadRequest"): + modality, mime = value["modality"], value["mime_type"] + allowed = {"audio": mime.startswith("audio/"), "image": mime.startswith("image/"), + "video": mime.startswith("video/"), "document": mime == "application/pdf", + "file": mime == "application/octet-stream"} + if not allowed[modality]: + return False + if name == "UploadRequest": + if value["modality"] == "image" and value["declared_bytes"] > 20971520: + return False + if "recording_id" in value and value["declared_bytes"] > 8388608: + return False + if name == "RecordingImportRequest": + expected = "RemoteUrl" if value["source"]["kind"] == "RemoteUrlEnvelope" else "ProviderFile" + return value["recording"]["source_kind"] == expected and wire_valid( + "CompletedRecordingImport", value["recording"]) + if name == "RecordingManifest": + validate_manifest(value) + return True + except TransferError: + return False + except Exception: + return False + + +def validate(name: str, value) -> None: + if not is_valid(name, value): + raise TransferError("unsupported_version") + + +def validate_wire(name: str, value) -> None: + if not wire_valid(name, value): + raise TransferError("unsupported_version") + + +def validate_manifest(manifest: dict) -> None: + """Schema plus the cross-field rules mirrored from F01 ``validate.py``.""" + validate("RecordingManifest", manifest) + if len(encode(manifest)) > 1048576: + raise TransferError("too_large") + if manifest["capture_complete"] and manifest["gaps"]: + raise TransferError("validation_failed") + track_ids = [track["track_id"] for track in manifest["tracks"]] + channels = sorted(c for track in manifest["tracks"] for c in track["channels"]) + if len(track_ids) != len(set(track_ids)) or channels != list(range(manifest["channels"])): + raise TransferError("validation_failed") + if manifest["layout"] == "mixed" and any(t["direction"] != "mixed" for t in manifest["tracks"]): + raise TransferError("validation_failed") + if manifest["layout"] == "stereo" and manifest["channels"] != 2: + raise TransferError("validation_failed") + seen, previous = set(), -1 + for index, segment in enumerate(manifest["segments"]): + if segment["index"] != index or segment["start_ms"] < previous or segment["occurrence_id"] in seen: + raise TransferError("validation_failed") + seen.add(segment["occurrence_id"]) + previous = segment["start_ms"] + timelines = {t: [] for t in track_ids} if manifest["layout"] == "separate_tracks" else {None: []} + for interval in manifest["segments"] + manifest["gaps"]: + if interval.get("track_id") not in timelines: + raise TransferError("validation_failed") + timelines[interval.get("track_id")].append(interval) + for intervals in timelines.values(): + end = 0 + for interval in sorted(intervals, key=lambda item: item["start_ms"]): + if interval["start_ms"] != end: + raise TransferError("validation_failed") + end += interval["duration_ms"] + if end != manifest["duration_ms"]: + raise TransferError("validation_failed") + for interval in manifest["segments"] + manifest["gaps"] + manifest["playout"]: + if interval["start_ms"] + interval["duration_ms"] > manifest["duration_ms"]: + raise TransferError("validation_failed") + + +@dataclass(frozen=True) +class Limits: + max_upload_bytes: int = 8 * 1024 * 1024 + segment_bytes: int = 8 * 1024 * 1024 + segment_duration_ms: int = 30000 + recording_bytes: int = 1073741824 + recording_duration_ms: int = 7200000 + active_transfers: int = 16 + active_recordings: int = 4 + reserved_bytes: int = 1073741824 + validation_jobs: int = 1024 + initializations_per_minute: int = 120 + links_per_minute: int = 1000 + upload_bytes_per_second: int = 1073741824 + playback_bytes_per_second: int = 1073741824 + transfer_timeout_seconds: int = 600 + grant_ttl_seconds: int = 60 + revocation_check_seconds: int = 5 @dataclass(frozen=True) @@ -46,7 +232,22 @@ class Session: capture_session_id: str policy: ServerPolicy expires_at: float - max_upload_bytes: int + limits: Limits = field(default_factory=Limits) + scope: Tuple[str, str, str] = ("", "", "") + issued_at: float = 0.0 + request: Optional[bytes] = field(default=None, repr=False) + + @property + def max_upload_bytes(self) -> int: + return self.limits.max_upload_bytes + + def expiring(self, now: Optional[float] = None) -> bool: + return self.expires_at - SKEW_SECONDS <= (time.time() if now is None else now) + + def renew_due(self, now: Optional[float] = None) -> bool: + now = time.time() if now is None else now + lifetime = max(self.expires_at - (self.issued_at or now), 0) + return self.expires_at - now <= max(60.0, 0.2 * lifetime) @dataclass(frozen=True) @@ -54,12 +255,46 @@ class Upload: upload_id: str expires_at: float capability: str = field(default="", repr=False) + reserved_bytes: int = 0 + def expiring(self) -> bool: + return self.expires_at - SKEW_SECONDS <= time.time() -def _uuid(value) -> str: - if not isinstance(value, str) or not re.fullmatch(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}", value) or not uuid.UUID(value).int: - raise TransferError("unsupported_version") - return value + +@dataclass(frozen=True) +class ImportJob: + job_id: str + recording_id: str + + +class Pacer: + """One token bucket per manager at ``limits.upload_bytes_per_second``.""" + + def __init__(self, rate: int = 1073741824): + self._lock = threading.Lock() + self.rate = max(int(rate), 1) + self._tokens = float(self.rate) + self._stamp = time.monotonic() + + def set_rate(self, rate: int) -> None: + with self._lock: + self.rate = max(int(rate), 1) + self._tokens = min(self._tokens, float(self.rate)) + + def acquire(self, size: int, deadline: float, check: Callable[[], None]) -> None: + while True: + check() + with self._lock: + now = time.monotonic() + self._tokens = min(float(self.rate), self._tokens + (now - self._stamp) * self.rate) + self._stamp = now + if self._tokens >= min(size, self.rate): + self._tokens -= size + return + wait = (min(size, self.rate) - self._tokens) / self.rate + if now + wait > deadline: + raise TransferError("incomplete", True) + time.sleep(min(wait, 1.0)) def _expiry(value) -> float: @@ -72,28 +307,25 @@ def _expiry(value) -> float: timestamp = date.timestamp() except (ValueError, OverflowError): raise TransferError("unsupported_version") from None - if timestamp <= time.time(): + if timestamp - SKEW_SECONDS <= time.time(): raise TransferError("expired") return timestamp -@lru_cache(maxsize=6) -def _validator(name: str): - schema = json.loads(Path(__file__).with_name("_protocol_schema.json").read_text()) - return Draft202012Validator({**schema, "$ref": "#/$defs/" + name}, format_checker=FormatChecker()) - - -def _validate(name: str, value: dict) -> None: - if not _validator(name).is_valid(value): +def _uuid(value) -> str: + if canonical_uuid(value) is None: raise TransferError("unsupported_version") + return value -def _object(pairs): +def safe_headers(headers: Mapping[str, str]) -> dict: result = {} - for key, value in pairs: - if key in result: - raise TransferError("unsupported_version") - result[key] = value + for key, value in (headers or {}).items(): + name = str(key).lower() + if name in _CREDENTIAL_HEADERS: + if not isinstance(value, str) or "\r" in value or "\n" in value or len(value) > 8192: + raise TransferError("credential_scope_unsupported") + result[name] = value return result @@ -101,92 +333,86 @@ class HTTPTransport: """Trusted control-plane transport, not a generic media fetch client.""" def __init__(self, endpoint: str, headers: Mapping[str, str], *, timeout: float = 2, - ssl_context: Optional[ssl.SSLContext] = None): - parsed = urlsplit(endpoint) - if parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.path not in ("", "/"): + ssl_context: Optional[ssl.SSLContext] = None, workspace_id: Optional[str] = None): + parsed = urlsplit(endpoint or "") + if (parsed.scheme != "https" or not parsed.hostname or parsed.username or parsed.password + or parsed.query or parsed.fragment or parsed.path not in ("", "/")): raise TransferError("endpoint_unconfigured") self._host, self._port = parsed.hostname, parsed.port or 443 - self._timeout, self._ssl_context = timeout, ssl_context - self._headers = {k.lower(): v for k, v in headers.items() - if k.lower() in ("authorization", "x-api-key", "x-secret-key")} - if not self._headers: + self._timeout, self._ssl_context = float(timeout), ssl_context + self._headers = safe_headers(headers) + if not any(k in self._headers for k in ("authorization", "x-api-key", "x-secret-key")): raise TransferError("credential_scope_unsupported") + explicit = workspace_id or self._headers.get("x-workspace-id") + if explicit is not None and canonical_uuid(explicit) is None: + raise TransferError("scope_unresolved") + self.workspace_id = explicit - def _request(self, method: str, path: str, *, body=None, payload=None, - capability: str = "", check: Callable[[], None] = lambda: None, + # ------------------------------------------------------------------ HTTP + def _request(self, method: str, path: str, *, expect: int, deadline: float, body: Optional[bytes] = None, + source=None, length: int = 0, capability: str = "", key: Optional[str] = None, + check: Callable[[], None] = lambda: None, pacer: Optional[Pacer] = None, chunk_bytes: int = 256 * 1024): check() - connection = http.client.HTTPSConnection(self._host, self._port, - timeout=self._timeout, context=self._ssl_context) - headers = dict(self._headers) - if capability: - headers = {"authorization": "Bearer " + capability} - data = json.dumps(body, separators=(",", ":")).encode() if body is not None else b"" - headers["Content-Type"] = "application/json" if payload is None else "application/octet-stream" - headers["Content-Length"] = str(len(data) if payload is None else len(payload)) - deadline = time.monotonic() + self._timeout + if deadline - time.monotonic() <= 0: + raise TransferError("incomplete", True) + headers = {"authorization": "Bearer " + capability} if capability else dict(self._headers) + if capability and (not re.fullmatch(r"[a-zA-Z0-9_.-]{16,4096}", capability)): + raise TransferError("credential_scope_unsupported") + headers["Cache-Control"] = "no-store" + if key is not None: + headers["Idempotency-Key"] = key + if source is not None: + headers["Content-Type"] = "application/octet-stream" + headers["Content-Length"] = str(length) + elif body is not None: + headers["Content-Type"] = "application/json" + headers["Content-Length"] = str(len(body)) + connection = http.client.HTTPSConnection( + self._host, self._port, timeout=max(min(self._timeout, deadline - time.monotonic()), 0.001), + context=self._ssl_context) + + def arm(stall: float) -> None: + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete", True) + if connection.sock: + connection.sock.settimeout(min(remaining, stall)) + try: with suppress_tracing(): - connection.putrequest(method, path) - for key, value in headers.items(): - connection.putheader(key, value) + connection.putrequest(method, path, skip_accept_encoding=True) + for name, value in headers.items(): + connection.putheader(name, value) connection.endheaders() - # FileLease has an independent bounded pread reader; it never - # advances the application's file position or materializes a file. - source = data if payload is None else payload - for offset in range(0, len(source), chunk_bytes): - check() - remaining = deadline - time.monotonic() - if remaining <= 0: - raise TransferError("incomplete", True) - if connection.sock: - connection.sock.settimeout(min(remaining, self._timeout)) - if isinstance(source, bytes): - chunk = memoryview(source)[offset:offset + chunk_bytes] - else: - chunk = source.read(offset, min(chunk_bytes, len(source) - offset)) - if len(chunk) != min(chunk_bytes, len(source) - offset): + if body is not None: + arm(self._timeout) + connection.send(body) + if source is not None: + for offset in range(0, length, chunk_bytes): + check() + size = min(chunk_bytes, length - offset) + if pacer is not None: + pacer.acquire(size, deadline, check) + chunk = source.read(offset, size) + if len(chunk) != size: raise TransferError("source_unavailable") - check() - connection.send(chunk) - del chunk - if not isinstance(source, bytes): + check() + arm(self._timeout) + connection.send(chunk) + del chunk source.check() check() - remaining = deadline - time.monotonic() - if remaining <= 0: - raise TransferError("incomplete", True) - if connection.sock: - connection.sock.settimeout(remaining) + arm(max(self._timeout, deadline - time.monotonic())) response = connection.getresponse() - if response.status not in (200, 201, 202, 204): - retry = response.status in (408, 429, 500, 502, 503, 504) - reason = {401: "credential_scope_unsupported", 403: "policy_denied", - 404: "source_unavailable", 409: "conflict", 410: "expired", - 413: "too_large", 429: "throttled"}.get(response.status, "incomplete") - retry_after = response.getheader("Retry-After", "0") - try: - retry_after = float(retry_after) - except ValueError: - retry_after = 0 - raise TransferError(reason, retry, retry_after) - # Bound responses and wall time even for a trickling server. - parts, size = [], 0 - while True: - check() - remaining = deadline - time.monotonic() - if remaining <= 0: - raise TransferError("incomplete", True) - if connection.sock: - connection.sock.settimeout(remaining) - part = response.read1(min(4096, 65537 - size)) - if not part: - break - parts.append(part) - size += len(part) - if size > 65536: - raise TransferError("unsupported_version") - value = json.loads(b"".join(parts), object_pairs_hook=_object) if size else {} + if response.status != expect: + retry_after = response.getheader("Retry-After") + raw = self._read(response, _ERROR_BODY, deadline, check, strict=False) + raise map_status(response.status, raw, retry_after) + raw = self._read(response, _SUCCESS_BODY, deadline, check, strict=True) + if expect == 204: + return None + value = strict_json(raw) if raw else None if not isinstance(value, dict): raise TransferError("unsupported_version") return value @@ -199,84 +425,166 @@ def _request(self, method: str, path: str, *, body=None, payload=None, finally: connection.close() - def bootstrap(self, project_name: str, project_type: str, capture_session_id: str, - correlation_nonce: str) -> Session: - result = self._request("POST", "/tracer/v1/attachment-sessions", body={ - "schema_versions": [1], "project_name": project_name, "project_type": project_type, - "capture_session_id": capture_session_id, "correlation_nonce": correlation_nonce, - }) - _validate("BootstrapResponse", result) - try: - if result["schema_version"] != 1 or result["transfer_modes"] != ["authenticated_stream"] or result["capture_session_id"] != capture_session_id: - raise TransferError("unsupported_version") - scope, policy, limits = result["scope"], result["policy"], result["limits"] - for name in ("organization_id", "workspace_id", "project_id"): - _uuid(scope[name]) - for name in ("enabled", "require_media_redaction", "require_metadata_removal", - "allow_unredacted_media_with_text_pii", "record_audio", "record_video"): - if type(policy[name]) is not bool: - raise TransferError("unsupported_version") - if not re.fullmatch(r"[a-zA-Z0-9_-]{1,128}", policy["version"]): - raise TransferError("unsupported_version") - for name in ("allowed_sources", "allowed_modalities"): - if not isinstance(policy[name], list) or len(policy[name]) > 6 or not all(isinstance(v, str) for v in policy[name]): + def _read(self, response, limit: int, deadline: float, check, *, strict: bool) -> bytes: + parts, size = [], 0 + while True: + check() + remaining = deadline - time.monotonic() + if remaining <= 0: + raise TransferError("incomplete", True) + sock = getattr(getattr(response, "fp", None), "raw", None) + sock = getattr(sock, "_sock", None) + if sock is not None: + sock.settimeout(remaining) + part = response.read1(min(4096, limit + 1 - size)) + if not part: + return b"".join(parts) + parts.append(part) + size += len(part) + if size > limit: + if strict: raise TransferError("unsupported_version") - for name, value in limits.items(): - if type(value) is not int or not 0 < value <= 1073741824: - raise TransferError("unsupported_version") - maximum = limits["max_upload_bytes"] - if maximum > 50 * 1024 * 1024: - raise TransferError("unsupported_version") - server = ServerPolicy( - enabled=policy["enabled"] and "audio" in policy["allowed_modalities"], - credential_write=True, allowed_sources=frozenset(policy["allowed_sources"]), - allowed_directions=frozenset(("input", "output", "mixed")), - require_media_redaction=policy["require_media_redaction"], - require_metadata_removal=policy["require_metadata_removal"], - allow_unredacted_media_with_text_pii=policy["allow_unredacted_media_with_text_pii"], - record_audio=policy["record_audio"], version=policy["version"], - ) - return Session(scope["project_id"], capture_session_id, server, - _expiry(result["expires_at"]), maximum) - except TransferError: - raise - except Exception: - raise TransferError("unsupported_version") from None + return b"" + + # ---------------------------------------------------------------- routes + def bootstrap_body(self, project_name: str, project_type: str, capture_session_id: str, + correlation_nonce: str) -> dict: + body = {"schema_versions": [1], "project_name": project_name, "project_type": project_type, + "capture_session_id": capture_session_id, "correlation_nonce": correlation_nonce} + if self.workspace_id: + body["workspace_id"] = self.workspace_id + return body + + def bootstrap(self, body: dict, *, key: str, deadline: float) -> Session: + validate("BootstrapRequest", body) + raw = encode(body) + result = self._request("POST", "/tracer/v1/attachment-sessions", expect=200, deadline=deadline, + body=raw, key=key) + return self._session(result, body, raw) + + def renew_session(self, current: Session, *, sequence: int, deadline: float) -> Session: + if current.request is None: + raise TransferError("expired") + body = strict_json(current.request) + session = self.bootstrap(body, key=idempotency_key("bootstrap", current.capture_session_id, sequence), + deadline=deadline) + if session.scope != current.scope or session.project_id != current.project_id: + raise TransferError("scope_unresolved") + if session.expires_at <= current.expires_at: + raise TransferError("expired") + return session + + def _session(self, result, body: dict, raw: bytes) -> Session: + validate("BootstrapResponse", result) + if result["capture_session_id"] != body["capture_session_id"]: + raise TransferError("unsupported_version") + scope, policy, limits = result["scope"], result["policy"], result["limits"] + if body.get("workspace_id") and scope["workspace_id"] != body["workspace_id"]: + raise TransferError("scope_unresolved") + server = ServerPolicy( + enabled=policy["enabled"], credential_write=True, + allowed_sources=frozenset(policy["allowed_sources"]), + allowed_modalities=frozenset(policy["allowed_modalities"]), + require_media_redaction=policy["require_media_redaction"], + require_metadata_removal=policy["require_metadata_removal"], + allow_unredacted_media_with_text_pii=policy["allow_unredacted_media_with_text_pii"], + record_audio=policy["record_audio"], record_video=policy["record_video"], + version=policy["version"], deletion_generation=0, + ) + return Session(scope["project_id"], body["capture_session_id"], server, _expiry(result["expires_at"]), + Limits(**limits), (scope["organization_id"], scope["workspace_id"], scope["project_id"]), + time.time(), raw) @staticmethod def _base(session: Session) -> str: - return "/tracer/v1/projects/" + _uuid(session.project_id) + "/attachments/uploads" + return "/tracer/v1/projects/" + _uuid(session.project_id) + "/attachments" + + def initialize(self, session: Session, body: bytes, *, key: str, deadline: float, check) -> Upload: + request = strict_json(body) + validate_wire("UploadRequest", request) + result = self._request("POST", self._base(session) + "/uploads", expect=201, deadline=deadline, + body=body, key=key, check=check) + validate("UploadResponse", result) + if (result["attachment_id"] != request["attachment_id"] or result["occurrence_id"] != request["occurrence_id"] + or result["reserved_bytes"] != request["declared_bytes"]): + raise TransferError("unsupported_version") + return Upload(result["upload_id"], _expiry(result["expires_at"]), result["write_capability"], + result["reserved_bytes"]) - def initialize(self, session: Session, request: dict, check: Callable[[], None]) -> Upload: - _validate("UploadRequest", request) - result = self._request("POST", self._base(session), body=request, check=check) - _validate("UploadResponse", result) + def renew_upload(self, session: Session, upload: Upload, body: bytes, *, deadline: float) -> Upload: + request = strict_json(body) try: - if (result["attachment_id"] != request["attachment_id"] or - result["occurrence_id"] != request["occurrence_id"] or - result["reserved_bytes"] != request["declared_bytes"] or - result["state"] != "pending_upload" or result["transfer_mode"] != "authenticated_stream"): - raise TransferError("unsupported_version") - return Upload(_uuid(result["upload_id"]), _expiry(result["expires_at"]), result["write_capability"]) - except TransferError: + renewed = self.initialize(session, body, key=idempotency_key("upload", request["occurrence_id"]), + deadline=deadline, check=lambda: None) + except TransferError as error: + if error.reason in ("conflict", "expired", "deleted"): + raise TransferError("expired") from None raise - except Exception: - raise TransferError("unsupported_version") from None + if (renewed.upload_id != upload.upload_id or renewed.reserved_bytes != upload.reserved_bytes + or renewed.capability == upload.capability or renewed.expires_at <= upload.expires_at): + raise TransferError("expired") + return renewed + + def put_content(self, session: Session, upload: Upload, source, *, deadline: float, check, pacer: Pacer, + chunk_bytes: int = 256 * 1024) -> None: + length = len(source) + if length != upload.reserved_bytes: + raise TransferError("source_unavailable") + result = self._request("PUT", self._base(session) + "/uploads/" + upload.upload_id + "/content", + expect=200, deadline=deadline, source=source, length=length, + capability=upload.capability, check=check, pacer=pacer, chunk_bytes=chunk_bytes) + validate("StatusResponse", result) + if result["upload_id"] != upload.upload_id or result["state"] != "pending_upload": + raise TransferError("unsupported_version") + + def _settle_body(self, session: Session) -> bytes: + return encode({"policy_version": session.policy.version, "deletion_generation": 0}) + + def complete(self, session: Session, upload: Upload, *, key: str, deadline: float, check) -> str: + result = self._request("POST", self._base(session) + "/uploads/" + upload.upload_id + "/complete", + expect=202, deadline=deadline, body=self._settle_body(session), key=key, + capability=upload.capability, check=check) + validate("StatusResponse", result) + # Accepted is not ready: the SDK reports validating in every order. + if result["upload_id"] != upload.upload_id or result["state"] not in ("validating", "ready"): + raise TransferError("unsupported_version") + return "validating" + + def abort(self, session: Session, upload: Upload, *, key: str, deadline: float) -> None: + result = self._request("POST", self._base(session) + "/uploads/" + upload.upload_id + "/abort", + expect=200, deadline=deadline, body=self._settle_body(session), key=key, + capability=upload.capability) + validate("StatusResponse", result) + + def upload_status(self, session: Session, upload: Upload, *, deadline: float) -> Tuple[str, str]: + result = self._request("GET", self._base(session) + "/uploads/" + upload.upload_id + "/status", + expect=200, deadline=deadline, capability=upload.capability) + validate("StatusResponse", result) + return result["state"], result["reason"] - def transfer(self, session: Session, upload: Upload, payload: bytes, - check: Callable[[], None], chunk_bytes: int) -> None: - self._request("PUT", self._base(session) + "/" + upload.upload_id + "/content", - payload=payload, capability=upload.capability, check=check, chunk_bytes=chunk_bytes) - - def complete(self, session: Session, upload: Upload, check: Callable[[], None]) -> None: - result = self._request("POST", self._base(session) + "/" + upload.upload_id + "/complete", - body={"policy_version": session.policy.version, - "deletion_generation": session.policy.deletion_generation}, - capability=upload.capability, check=check) - _validate("StatusResponse", result) - if result.get("state") not in ("validating", "ready") or result.get("upload_id") != upload.upload_id: + def put_manifest(self, session: Session, capability: str, recording_id: str, body: bytes, *, key: str, + deadline: float, check) -> None: + validate_manifest(strict_json(body)) + self._request("PUT", self._base(session) + "/recordings/" + _uuid(recording_id) + "/manifest", + expect=204, deadline=deadline, body=body, key=key, capability=capability, check=check) + + def submit_import(self, session: Session, body: bytes, *, key: str, deadline: float, check) -> ImportJob: + request = strict_json(body) + validate_wire("RecordingImportRequest", request) + result = self._request("POST", self._base(session) + "/imports", expect=202, deadline=deadline, + body=body, key=key, check=check) + validate("RecordingImportResponse", result) + if result["recording_id"] != request["recording"]["recording_id"]: raise TransferError("unsupported_version") + return ImportJob(result["job_id"], result["recording_id"]) + + def import_status(self, session: Session, job_id: str, *, deadline: float) -> Tuple[str, str]: + result = self._request("GET", self._base(session) + "/imports/" + _uuid(job_id) + "/status", + expect=200, deadline=deadline) + validate("ImportStatusResponse", result) + return result["state"], result["reason"] + - def abort(self, session: Session, upload: Upload) -> None: - self._request("POST", self._base(session) + "/" + upload.upload_id + "/abort", - body={}, capability=upload.capability) +def backoff(attempt: int, error: TransferError) -> float: + """Delay before attempt n (n = 1, 2): max(retry_after, U(0.5, 1.0) * 100 ms * 2^n).""" + return max(error.retry_after, random.uniform(0.5, 1.0) * 0.1 * (2 ** attempt)) diff --git a/python/fi_instrumentation/attachments/recording.py b/python/fi_instrumentation/attachments/recording.py new file mode 100644 index 000000000..3d5f8c4dd --- /dev/null +++ b/python/fi_instrumentation/attachments/recording.py @@ -0,0 +1,721 @@ +"""Live PCM recordings (design section 2): WAV segments, gaps and manifests. + +Timing is a sample-count clock, never wall time. Every segment is at most +30 s and 8 MiB including its 44-byte header; all tracks share the same cut +points. Segments upload strictly in order (one in flight per recording), with +a moving window of sealed-but-not-uploaded segments. Manifests are cumulative +and prefix-monotonic, authorized by the latest completed segment's capability. +``try_write`` is synchronous, never does I/O, and never raises. +""" + +import json +import math +import threading +import time +import uuid +from dataclasses import dataclass +from typing import List, Optional, Tuple + +from .sources import wav_header +from .types import GAP_REASONS, TRACK_ROLES + +MAX_DURATION_MS = 7200000 +MAX_SEGMENT_BYTES = 8 * 1024 * 1024 +MAX_SEGMENT_MS = 30000 +MAX_PLAYOUT = 4096 + + +@dataclass(frozen=True) +class PcmFormat: + sample_rate_hz: int + sample_format: str = "s16le" + + +@dataclass(frozen=True) +class TrackSpec: + channels: Tuple[int, ...] + direction: str + role: str + + +@dataclass(frozen=True) +class RecordingOptions: + format: PcmFormat + layout: str + tracks: Tuple[TrackSpec, ...] + operation: str + purpose: str = "conversation_recording" + capture_policy: Optional[object] = None + conversation_id: Optional[str] = None + turn_id: Optional[str] = None + window_segments: int = 2 + + +@dataclass(frozen=True) +class RecordingResult: + recording_id: str + state: str # published | partial | unpublished | denied + reason: Optional[str] + segments_published: int + gap_ms: int + capture_complete: bool + manifest_revision: int + + +@dataclass(frozen=True) +class RecordingStatus: + state: str # pending | recording | truncated | terminal | finished | denied + reason: str + segments_published: int + segments_pending: int + gap_ms: int + manifest_revision: int + + +def boundary_step(rate: int) -> int: + return rate // math.gcd(rate, 1000) + + +def segment_frames(rate: int, frame_bytes: int, seg_ms: int, seg_bytes: int) -> int: + """Largest multiple of g within both the duration and the byte bound (2.5).""" + g = boundary_step(rate) + frames = min(seg_ms * rate // 1000, (seg_bytes - 44) // frame_bytes) + frames -= frames % g + return frames if frames >= g else 0 + + +def to_ms(frames: int, rate: int, final: bool = False) -> int: + value = frames * 1000 + return -(-value // rate) if final else value // rate + + +def validate_options(options: RecordingOptions) -> Optional[str]: + """Local shape rules; returns a denial reason or None.""" + fmt = options.format + if (not isinstance(fmt, PcmFormat) or type(fmt.sample_rate_hz) is not int + or not 8000 <= fmt.sample_rate_hz <= 192000 or fmt.sample_format != "s16le"): + return "source_unavailable" + if options.layout not in ("mixed", "stereo", "separate_tracks") or options.operation not in ( + "observe_consumed", "create_recording"): + return "policy_denied" + if options.purpose not in ("conversation_recording", "turn_recording"): + return "policy_denied" + tracks = tuple(options.tracks) + if not 1 <= len(tracks) <= 32 or not 1 <= options.window_segments <= 4: + return "policy_denied" + channels = [] + for track in tracks: + if (not isinstance(track, TrackSpec) or track.direction not in ("input", "output", "mixed") + or track.role not in TRACK_ROLES or not track.channels): + return "policy_denied" + if any(type(c) is not int or not 0 <= c <= 31 for c in track.channels): + return "policy_denied" + channels.extend(track.channels) + if sorted(channels) != list(range(len(channels))): + return "policy_denied" + if options.layout == "mixed" and (len(tracks) != 1 or tracks[0].direction != "mixed"): + return "policy_denied" + if options.layout == "stereo" and (len(tracks) != 2 or len(channels) != 2): + return "policy_denied" + return None + + +def build_manifest(recording_id: str, rate: int, layout: str, tracks: list, segments: list, gaps: list, + playout: list, duration_ms: int, capture_complete: bool) -> dict: + return { + "schema_version": 1, "recording_id": recording_id, "timebase": "session_relative_ms", + "sample_format": "s16le", "sample_rate_hz": rate, + "channels": sum(len(t["channels"]) for t in tracks), "codec": "pcm", "container": "wav", + "layout": layout, "tracks": tracks, "segments": segments, "gaps": gaps, "playout": playout, + "capture_complete": bool(capture_complete and not gaps and segments), "duration_ms": duration_ms, + } + + +class SegmentSource: + """Header + retained frames without concatenating them.""" + + def __init__(self, header: bytes, frames: bytes): + self._header, self._frames = header, frames + + def __len__(self) -> int: + return 44 + len(self._frames) + + def read(self, offset: int, size: int) -> bytes: + result = b"" + if offset < 44: + result = self._header[offset:min(44, offset + size)] + size -= len(result) + offset = 44 + if size > 0: + result += self._frames[offset - 44:offset - 44 + size] + return result + + def check(self) -> None: + return None + + +class _Entry: + __slots__ = ("occurrence_id", "attachment_id", "f0", "f1", "track_id", "state", "index", "upload", + "body", "fail", "nbytes", "source") + + def __init__(self, f0, f1, track_id, source, nbytes): + self.occurrence_id, self.attachment_id = str(uuid.uuid4()), str(uuid.uuid4()) + self.f0, self.f1, self.track_id = f0, f1, track_id + self.state, self.index, self.upload, self.body, self.fail = "pending", None, None, None, None + self.source, self.nbytes = source, nbytes + + +class _Window: + __slots__ = ("f0", "f1", "entries", "gaps") + + def __init__(self, f0, f1): + self.f0, self.f1, self.entries, self.gaps = f0, f1, [], [] + + def settled(self) -> bool: + return all(e.state != "pending" for e in self.entries) + + +class _Stream: + """One PCM input: the whole interleaved stream (mixed/stereo) or one track.""" + + __slots__ = ("track_id", "frame_bytes", "carry", "cursor", "run_start", "run", "intervals", "denied", + "direction", "channels") + + def __init__(self, track_id, channels, direction): + self.track_id, self.channels, self.direction = track_id, channels, direction + self.frame_bytes = channels * 2 + self.carry, self.cursor, self.run_start, self.run = b"", 0, None, bytearray() + self.intervals, self.denied = [], None + + +class RecordingWriter: + """Created by ``AttachmentManager.start_recording``. Inert unless ``reason == "queued"``.""" + + def __init__(self, manager=None, options: Optional[RecordingOptions] = None, reason: str = "queued", *, + correlation=None, pending: bool = False, track_denials: Optional[List[Optional[str]]] = None): + self.recording_id = str(uuid.uuid4()) + self.reason = reason + self._manager = manager + self._options = options + self._lock = threading.Lock() + self._closed = reason != "queued" + self._state = "denied" if reason != "queued" else ("pending" if pending else "recording") + self._result: Optional[RecordingResult] = None + if self._closed: + return + self._correlation = correlation + self._epoch = manager._epoch + session = manager._session_or_none() + limits = manager._limits() + layout = options.layout + self._rate = options.format.sample_rate_hz + self._g = boundary_step(self._rate) + self._tracks = [{"track_id": str(uuid.uuid4()), "channels": list(t.channels), "direction": t.direction, + "role": t.role} for t in options.tracks] + if layout == "separate_tracks": + self._streams = [_Stream(t["track_id"], len(t["channels"]), t["direction"]) for t in self._tracks] + else: + direction = "mixed" + self._streams = [_Stream(None, sum(len(t["channels"]) for t in self._tracks), direction)] + for stream, denial in zip(self._streams, track_denials or []): + stream.denied = denial + seg_ms = min(limits.segment_duration_ms, MAX_SEGMENT_MS) + seg_bytes = min(limits.segment_bytes, limits.max_upload_bytes, MAX_SEGMENT_BYTES) + self._frames = min(segment_frames(self._rate, s.frame_bytes, seg_ms, seg_bytes) for s in self._streams) + self._max_bytes = min(limits.recording_bytes, 1073741824) + self._max_frames = min(limits.recording_duration_ms, MAX_DURATION_MS) * self._rate // 1000 + self._ceiling_frames = MAX_DURATION_MS * self._rate // 1000 + self._window = _Window(0, self._frames) + self._windows: List[_Window] = [] + self._retained = 0 + self._completed = 0 + self._published_prefix = 0 # frames covered by the last successful manifest + self._revision = 0 + self._last_put_completed = 0 + self._manifest_pending = False + self._playout: list = [] + self._playout_dropped = 0 + self._truncated = False + self._fallback = False + self._abort_index: Optional[int] = None + self._closing_partial = False + self._final_end: Optional[int] = None + self._lane = manager._new_lane(self) + self._session_ref = session + del session + if self._frames == 0: + self._deny("too_large") + + # ----------------------------------------------------------- helpers + def _deny(self, reason: str) -> None: + self.reason, self._state, self._closed = reason, "denied", True + if self._manager is not None: + self._manager._close_recording(self) + + @property + def _open(self) -> bool: + return not self._closed + + def _frame_end(self, stream: _Stream, frames: int) -> int: + return min(stream.cursor + frames, self._ceiling_frames) + + def _close_run(self, stream: _Stream) -> None: + if stream.run_start is not None: + data = bytes(stream.run) + stream.intervals.append(("data", stream.run_start, stream.cursor, data)) + stream.run_start, stream.run = None, bytearray() + + def _add_gap(self, stream: _Stream, frames: int, reason: str) -> None: + """Advance the clock by a gap, splitting at window boundaries; coalesce within a window.""" + self._close_run(stream) + reason = reason if reason in GAP_REASONS else "incomplete" + while frames > 0 and stream.cursor < self._ceiling_frames: + step = min(frames, self._window.f1 - stream.cursor, self._ceiling_frames - stream.cursor) + if step <= 0: + self._seal() + continue + last = stream.intervals[-1] if stream.intervals else None + if last is not None and last[0] == "gap" and last[3] == reason and last[2] == stream.cursor: + stream.intervals[-1] = ("gap", last[1], stream.cursor + step, reason) + else: + stream.intervals.append(("gap", stream.cursor, stream.cursor + step, reason)) + stream.cursor += step + frames -= step + if stream.cursor >= self._window.f1: + self._seal() + + def _add_data(self, stream: _Stream, view: memoryview) -> None: + frames = len(view) // stream.frame_bytes + offset = 0 + while frames > 0: + step = min(frames, self._window.f1 - stream.cursor) + if step <= 0: + self._seal() + continue + if stream.run_start is None: + stream.run_start = stream.cursor + stream.run += view[offset:offset + step * stream.frame_bytes] + offset += step * stream.frame_bytes + stream.cursor += step + frames -= step + if stream.cursor >= self._window.f1: + self._seal() + + def _seal(self, final_end: Optional[int] = None) -> None: + """Seal the current window at its end (or at ``final_end``) for every stream.""" + window = self._window + end = window.f1 if final_end is None else final_end + for stream in self._streams: + if stream.cursor < end: + self._close_run(stream) + stream.intervals.append(("gap", stream.cursor, end, "source_unavailable")) + stream.cursor = end + self._close_run(stream) + window.f1 = end + final = final_end is not None + items = [] + for ordinal, stream in enumerate(self._streams): + for interval in stream.intervals: + f0, f1 = interval[1], interval[2] + if to_ms(f1, self._rate, final and f1 == end) - to_ms(f0, self._rate) <= 0: + if interval[0] == "data": + self._manager._release(len(interval[3]), 0) + self._retained -= len(interval[3]) + continue + items.append((f0, ordinal, interval, stream)) + stream.intervals = [] + for f0, _, interval, stream in sorted(items, key=lambda item: (item[0], item[1])): + if interval[0] == "data": + frames = interval[2] - interval[1] + header = wav_header(stream.channels, self._rate, frames) + entry = _Entry(interval[1], interval[2], stream.track_id, SegmentSource(header, interval[3]), + len(interval[3])) + window.entries.append(entry) + else: + window.gaps.append((interval[1], interval[2], interval[3], stream.track_id)) + self._windows.append(window) + for entry in window.entries: + self._manager._enqueue_segment(self, entry) + self._window = _Window(end, end + self._frames) + + def _pending_segments(self) -> int: + return sum(1 for w in self._windows for e in w.entries if e.state == "pending") + + def _check_admission(self, stream: _Stream) -> Optional[str]: + """Returns a gap reason when these frames cannot be retained.""" + manager = self._manager + if self._state == "pending": + state = manager._runtime_state() + if state == "bootstrap_pending": + return "bootstrap_pending" + denials = manager._recording_denials(self._options) if state == "ready" else None + if denials is None or all(denials): + self._deny_terminal_pending(state if denials is None else next(d for d in denials if d)) + return "denied" + for s, denial in zip(self._streams, denials): + s.denied = denial + self._state, self._epoch = "recording", manager._epoch + if self._truncated: + return "truncated" + if self._state == "terminal": + return self.reason if self.reason in GAP_REASONS else "incomplete" + if manager._epoch != self._epoch: + denials = manager._recording_denials(self._options) + self._epoch = manager._epoch + if denials is None or all(denials): + self._terminal("policy_denied") + return "policy_denied" + for s, denial in zip(self._streams, denials): + if denial and not s.denied: + s.denied = denial + self._drop_run(s, "policy_denied") + if stream.denied: + return "policy_denied" + if manager._runtime_state() == "expired": + return "incomplete" + return None + + def _deny_terminal_pending(self, reason: str) -> None: + # Denied after pending: no manifest is ever published; counters discarded. + self.reason, self._state, self._closed = reason, "denied", True + for stream in self._streams: + stream.intervals, stream.run, stream.run_start = [], bytearray(), None + self._manager._close_recording(self) + + def _drop_run(self, stream: _Stream, reason: str) -> None: + if stream.run_start is not None: + frames = stream.cursor - stream.run_start + self._manager._release(len(stream.run), 0) + self._retained -= len(stream.run) + stream.cursor = stream.run_start + stream.run_start, stream.run = None, bytearray() + self._add_gap(stream, frames, reason) + + def _terminal(self, reason: str) -> None: + """Stop retaining: free every unsealed byte and turn it into a gap of ``reason``.""" + self.reason, self._state = reason, "terminal" + gap = reason if reason in GAP_REASONS else "incomplete" + for stream in self._streams: + self._drop_run(stream, gap) + kept = [] + for interval in stream.intervals: + if interval[0] == "data": + self._manager._release(len(interval[3]), 0) + self._retained -= len(interval[3]) + interval = ("gap", interval[1], interval[2], gap) + if kept and kept[-1][0] == "gap" and kept[-1][3] == interval[3] and kept[-1][2] == interval[1]: + kept[-1] = ("gap", kept[-1][1], interval[2], interval[3]) + else: + kept.append(interval) + stream.intervals = kept + + # ------------------------------------------------------------- public + def try_write(self, pcm, *, track: int = 0) -> bool: + try: + view = memoryview(pcm).cast("B") + with self._lock: + if self._closed or type(track) is not int or not 0 <= track < len(self._streams): + return False + manager = self._manager + if manager._stopping or manager._stopped: + return False + stream = self._streams[track] + pieces = [] + if stream.carry: + need = stream.frame_bytes - len(stream.carry) + if len(view) < need: + stream.carry += bytes(view) + return True + pieces.append(memoryview(stream.carry + bytes(view[:need]))) + view = view[need:] + stream.carry = b"" + whole = len(view) - len(view) % stream.frame_bytes + if whole != len(view): + stream.carry = bytes(view[whole:]) + pieces.append(view[:whole]) + step = max(manager.config.chunk_bytes - manager.config.chunk_bytes % stream.frame_bytes, + stream.frame_bytes) + retained = True + for piece in pieces: + for offset in range(0, len(piece), step): + part = piece[offset:offset + step] + if not self._accept(stream, part): + retained = False + if self._closed: + return False + return retained + except Exception: + return False + + def _accept(self, stream: _Stream, part: memoryview) -> bool: + frames = len(part) // stream.frame_bytes + if not frames: + return True + reason = self._check_admission(stream) + if reason == "denied": + return False + if reason is None and (stream.cursor + frames > self._max_frames + or self._retained + len(part) + 44 > self._max_bytes): + self._truncated = True + for s in self._streams: + self._close_run(s) + reason = "truncated" + if reason is None and self._pending_segments() >= self._options.window_segments * len(self._streams): + reason = "queue_full" + if reason is None and not self._manager._reserve(len(part)): + reason = "queue_full" + if reason is not None: + self._add_gap(stream, frames, reason) + return False + self._retained += len(part) + self._add_data(stream, part) + return True + + def mark_gap(self, duration_ms: int, *, reason: str = "source_unavailable", track: Optional[int] = None) -> None: + try: + with self._lock: + if self._closed or type(duration_ms) is not int or duration_ms <= 0: + return + frames = -(-duration_ms * self._rate // 1000) + frames += (-frames) % self._g + streams = self._streams if track is None else [self._streams[track]] + for stream in streams: + self._add_gap(stream, frames, reason) + except Exception: + return + + def mark_playout(self, start_ms: int, duration_ms: int, evidence: str) -> None: + try: + with self._lock: + if self._closed or evidence not in ("generated", "played", "unknown", "truncated"): + return + if type(start_ms) is not int or type(duration_ms) is not int or start_ms < 0 or duration_ms <= 0: + return + if len(self._playout) >= MAX_PLAYOUT: + self._playout_dropped += 1 + return + self._playout.append({"start_ms": start_ms, "duration_ms": duration_ms, "evidence": evidence}) + except Exception: + return + + # ------------------------------------------------- worker callbacks + def _next_index(self) -> int: + with self._lock: + return self._completed + + def _segment_done(self, entry: _Entry, status: str, upload=None, body=None, initialized: bool = False, + index: Optional[int] = None) -> None: + with self._lock: + self._retained -= entry.nbytes + entry.source = None + if status == "validating": + entry.state, entry.index, entry.upload, entry.body = "completed", index, upload, body + self._completed += 1 + self._abort_index = None + else: + entry.state, entry.fail = "failed", status + if status == "conflict" and index is not None and self._abort_index == index: + self._closing_partial = True + self._terminal("incomplete") + elif initialized and index is not None: + self._abort_index = index + self._maybe_manifest() + + def _settled_end(self) -> int: + end = 0 + for window in self._windows: + if not window.settled(): + break + end = window.f1 + return end + + def _maybe_manifest(self) -> None: + # Caller holds self._lock. + if self._closed or self._manifest_pending or self._fallback: + return + end = self._settled_end() + if end <= self._published_prefix or not self._completed: + return + if (self._completed - self._last_put_completed >= 4 + or to_ms(end, self._rate) - to_ms(self._published_prefix, self._rate) >= 30000): + body = self._manifest_body(end, final=False) + if body is not None: + self._manifest_pending = True + self._revision += 1 + self._manager._enqueue_manifest(self, body, self._revision, end, self._completed) + + def _capability_entries(self) -> list: + return [e for w in self._windows for e in w.entries if e.state == "completed" and e.upload is not None] + + def _manifest_body(self, end: int, *, final: bool, drop_unsettled: bool = False) -> Optional[bytes]: + """Cumulative manifest over the settled prefix (or everything when final).""" + rate = self._rate + segments, gaps = [], [] + + def interval(f0, f1): + start = to_ms(f0, rate) + return start, to_ms(f1, rate, final and f1 == end) - start + + for window in self._windows: + if window.f1 > end: + break + settled = window.settled() + if not settled and not final: + break + for f0, f1, reason, track_id in window.gaps: + start, duration = interval(f0, f1) + if duration > 0: + gap = {"start_ms": start, "duration_ms": duration, "reason": reason} + if track_id: + gap["track_id"] = track_id + gaps.append(gap) + for entry in window.entries: + start, duration = interval(entry.f0, entry.f1) + if duration <= 0: + continue + if entry.state == "completed": + segment = {"occurrence_id": entry.occurrence_id, "index": entry.index, "start_ms": start, + "duration_ms": duration} + if entry.track_id: + segment["track_id"] = entry.track_id + segments.append(segment) + else: + reason = "policy_denied" if entry.fail == "policy_denied" else "incomplete" + gap = {"start_ms": start, "duration_ms": duration, "reason": reason} + if entry.track_id: + gap["track_id"] = entry.track_id + gaps.append(gap) + if not segments: + return None + segments.sort(key=lambda s: s["index"]) + gaps.sort(key=lambda g: (g["start_ms"], g.get("track_id", ""))) + duration = to_ms(end, rate, final) + playout = [p for p in self._playout if p["start_ms"] + p["duration_ms"] <= duration] + manifest = build_manifest(self.recording_id, rate, self._options.layout, self._tracks, segments, gaps, + playout, duration, final) + return json.dumps(manifest, separators=(",", ":")).encode() + + def _manifest_done(self, ok: bool, revision: int, end: int, completed: int, fallback: bool = False) -> None: + with self._lock: + self._manifest_pending = False + if ok: + self._published_prefix = max(self._published_prefix, end) + self._last_put_completed = completed + self._last_ok_revision = revision + elif fallback: + self._fallback = True + self._maybe_manifest() + + # ------------------------------------------------------- finish/abort + def finish(self, timeout: float = 30.0) -> RecordingResult: + manager = self._manager + if self._state == "denied" or manager is None: + return self._finish_result("denied", self.reason) + try: + budget = min(max(float(timeout), 0.0), manager.config.finalization_timeout) + except Exception: + budget = 0.0 + deadline = manager._bounded_deadline(time.monotonic() + budget) + with self._lock: + if self._result is not None: + return self._result + if self._closed and self._state == "aborted": + return self._finish_result(*self._aborted_state()) + pending_only = self._state == "pending" + self._closed = True + if not pending_only: + end = max(s.cursor for s in self._streams) + if end > self._window.f0 or any(s.run_start is not None or s.intervals for s in self._streams): + self._seal(final_end=end) + self._final_end = end + if pending_only: + manager._close_recording(self) + return self._finish_result("unpublished", "bootstrap_pending") + reserve = min(manager.config.request_timeout, max(deadline - time.monotonic(), 0.0) / 2) + manager._drain_lane(self._lane, deadline - reserve) + manager._cancel_lane(self._lane, "incomplete") + with self._lock: + end = self._final_end or 0 + body = self._manifest_body(end, final=True) + self._revision += 1 + revision = self._revision + candidates = self._capability_entries() + ok = False + if body is not None and candidates: + ok = manager._put_manifest_now(self, body, revision, candidates, deadline) + with self._lock: + if ok: + self._last_ok_revision = revision + last_ok = getattr(self, "_last_ok_revision", 0) + manifest = json.loads(body) if body is not None else None + manager._close_recording(self) + if manifest is None or not last_ok: + return self._finish_result("unpublished", "incomplete" if self._completed == 0 else "conflict", + revision=last_ok) + gap_ms = sum(g["duration_ms"] for g in manifest["gaps"]) if ok else 0 + complete = ok and manifest["capture_complete"] + state = "published" if complete else "partial" + return self._finish_result(state, None if complete else (self.reason if self.reason != "queued" + else "incomplete"), + gap_ms=gap_ms, complete=complete, revision=last_ok) + + async def finish_async(self, timeout: float = 30.0) -> RecordingResult: + import asyncio + + return await asyncio.to_thread(self.finish, timeout) + + def _aborted_state(self): + return ("partial", "incomplete") if getattr(self, "_last_ok_revision", 0) else ("unpublished", "incomplete") + + def _finish_result(self, state: str, reason: Optional[str], *, gap_ms: int = 0, complete: bool = False, + revision: Optional[int] = None) -> RecordingResult: + if self._result is None: + self._state = "denied" if state == "denied" else "finished" + self._result = RecordingResult(self.recording_id, state, reason, getattr(self, "_completed", 0), + gap_ms, complete, + revision if revision is not None else getattr(self, "_last_ok_revision", 0)) + return self._result + + def abort(self) -> None: + """Synchronous, no I/O: drop retained bytes and cancel queued segments.""" + manager = self._manager + if manager is None: + return + try: + with self._lock: + if self._closed: + return + self._closed, self._state = True, "aborted" + for stream in self._streams: + if stream.run_start is not None: + manager._release(len(stream.run), 0) + self._retained -= len(stream.run) + for interval in stream.intervals: + if interval[0] == "data": + manager._release(len(interval[3]), 0) + self._retained -= len(interval[3]) + stream.run, stream.run_start, stream.intervals = bytearray(), None, [] + manager._cancel_lane(self._lane, "incomplete") + manager._close_recording(self) + except Exception: + return + + def status(self) -> RecordingStatus: + if self._state == "denied" or self._manager is None: + return RecordingStatus("denied", self.reason, 0, 0, 0, 0) + with self._lock: + return RecordingStatus(self._state if not self._truncated else "truncated", + self.reason, self._completed, self._pending_segments(), 0, + getattr(self, "_last_ok_revision", 0)) + + def _reset_after_fork(self) -> None: + # Child: never touch the inherited lock. The parent owns every byte. + self._lock = threading.Lock() + self._closed, self._state, self.reason = True, "terminal", "incomplete" + if hasattr(self, "_streams"): + for stream in self._streams: + stream.run, stream.intervals = bytearray(), [] + self._windows = [] + + def __repr__(self) -> str: + return "RecordingWriter(reason=%r)" % self.reason diff --git a/python/fi_instrumentation/attachments/sources.py b/python/fi_instrumentation/attachments/sources.py index 52be71254..714aca725 100644 --- a/python/fi_instrumentation/attachments/sources.py +++ b/python/fi_instrumentation/attachments/sources.py @@ -1,16 +1,35 @@ -"""Explicit session-owned file leases. Arbitrary LocalFile remains disabled. +"""Explicit session-owned file leases (design section 4). Arbitrary LocalFile stays disabled. -Bind a trusted session root during application setup/finalization, not an audio -callback. Report paths are never authority. All traversal uses no-follow directory -FDs, regular files only, and an expected identity supplied by the owning session. +Bind a trusted session root during application setup/finalization, never on an +audio callback. Report paths are never authority. All traversal uses no-follow +directory FDs, regular files only, and an identity taken from the opened file. +Windows is unsupported (``source_unavailable``). """ import os import stat +import struct import threading from dataclasses import dataclass, field +from typing import Optional -from .protocol import TransferError +from .errors import TransferError + + +@dataclass(frozen=True) +class FileIdentity: + device: int + inode: int + size: int + + +def _parts(relative_path) -> tuple: + if not isinstance(relative_path, str) or len(relative_path) > 4096: + raise ValueError("invalid owned recording path") + parts = relative_path.split("/") + if not parts or any(part in ("", ".", "..") for part in parts) or len(parts) > 32: + raise ValueError("invalid owned recording path") + return tuple(parts) class RecordingFileScope: @@ -26,7 +45,7 @@ def __init__(self, root: str, *, enabled: bool = False): self._lock = threading.Lock() if not enabled: raise ValueError("owned recording files require explicit permission") - if not os.path.isabs(root) or not hasattr(os, "O_NOFOLLOW"): + if os.name != "posix" or not os.path.isabs(root) or not hasattr(os, "O_NOFOLLOW"): raise ValueError("unsupported recording root") fd = os.open("/", os.O_RDONLY | os.O_DIRECTORY) try: @@ -43,49 +62,80 @@ def __init__(self, root: str, *, enabled: bool = False): os.close(fd) raise ValueError("recording root unavailable") from None - def source(self, relative_path: str, *, device: int, inode: int, size: int) -> "OwnedRecordingFile": - # No file operations here. The adapter must obtain identity from the - # actual owned file, not trust an arbitrary report/tool-supplied path. - if not isinstance(relative_path, str) or len(relative_path) > 4096: - raise ValueError("invalid owned recording path") - parts = relative_path.split("/") - if not parts or any(part in ("", ".", "..") for part in parts) or len(parts) > 32: - raise ValueError("invalid owned recording path") - if any(type(v) is not int or v < 0 for v in (device, inode, size)): - raise ValueError("invalid owned recording identity") - return OwnedRecordingFile(self, tuple(parts), device, inode, size) + def __enter__(self) -> "RecordingFileScope": + return self - def _open(self, source: "OwnedRecordingFile") -> "FileLease": + def __exit__(self, *exc) -> None: + self.close() + + def _open_parts(self, parts: tuple) -> int: if os.getpid() != self._pid: + self._forget_after_fork() raise TransferError("source_unavailable") with self._lock: if self._fd < 0: raise TransferError("source_unavailable") fd = os.dup(self._fd) try: - for part in source._parts[:-1]: + for part in parts[:-1]: next_fd = os.open(part, os.O_RDONLY | os.O_DIRECTORY | os.O_NOFOLLOW, dir_fd=fd) os.close(fd) fd = next_fd - file_fd = os.open(source._parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=fd) - try: - info = os.fstat(file_fd) - if not stat.S_ISREG(info.st_mode) or (info.st_dev, info.st_ino, info.st_size) != (source.device, source.inode, source.size): - raise TransferError("source_unavailable") - return FileLease(file_fd, info) - except Exception: - os.close(file_fd) - raise + file_fd = os.open(parts[-1], os.O_RDONLY | os.O_NOFOLLOW | os.O_NONBLOCK, dir_fd=fd) except Exception: raise TransferError("source_unavailable") from None finally: os.close(fd) + try: + if not stat.S_ISREG(os.fstat(file_fd).st_mode): + raise TransferError("source_unavailable") + except Exception: + os.close(file_fd) + raise TransferError("source_unavailable") from None + return file_fd + + def identify(self, relative_path: str) -> FileIdentity: + """Secure open + fstat + close; never ``os.stat`` on a path.""" + file_fd = self._open_parts(_parts(relative_path)) + try: + info = os.fstat(file_fd) + return FileIdentity(info.st_dev, info.st_ino, info.st_size) + finally: + os.close(file_fd) + + def source(self, relative_path: str, identity: Optional[FileIdentity] = None, *, device: Optional[int] = None, + inode: Optional[int] = None, size: Optional[int] = None) -> "OwnedRecordingFile": + # No file operations here. Identity must come from ``identify`` (or the + # owning session), not from an arbitrary report/tool-supplied path. + if identity is None: + identity = FileIdentity(device, inode, size) + if any(type(v) is not int or v < 0 for v in (identity.device, identity.inode, identity.size)): + raise ValueError("invalid owned recording identity") + return OwnedRecordingFile(self, _parts(relative_path), identity.device, identity.inode, identity.size) + + def _open(self, source: "OwnedRecordingFile") -> "FileLease": + file_fd = self._open_parts(source._parts) + try: + info = os.fstat(file_fd) + if (info.st_dev, info.st_ino, info.st_size) != (source.device, source.inode, source.size): + raise TransferError("source_unavailable") + return FileLease(file_fd, info) + except Exception: + os.close(file_fd) + raise TransferError("source_unavailable") from None + + def _forget_after_fork(self) -> None: + # A child must not use an inherited lock; just close the duplicated fd. + if self._fd >= 0: + try: + os.close(self._fd) + except OSError: + pass + self._fd = -1 def close(self) -> None: if os.getpid() != self._pid: - if self._fd >= 0: - os.close(self._fd) - self._fd = -1 + self._forget_after_fork() return with self._lock: if self._fd >= 0: @@ -106,6 +156,8 @@ def _open(self) -> "FileLease": class FileLease: + """Internal: obtained by the worker, never by adapters. ``pread`` only.""" + def __init__(self, fd: int, info): self._fd, self._info = fd, info @@ -117,6 +169,8 @@ def read(self, offset: int, size: int) -> bytes: return os.pread(self._fd, size, offset) def check(self) -> None: + if self._fd < 0: + raise TransferError("source_unavailable") info = os.fstat(self._fd) original = self._info if (info.st_dev, info.st_ino, info.st_size, info.st_mtime_ns, info.st_ctime_ns) != ( @@ -125,4 +179,97 @@ def check(self) -> None: raise TransferError("source_unavailable") def close(self) -> None: - os.close(self._fd) + if self._fd >= 0: + os.close(self._fd) + self._fd = -1 + + +class MemorySource: + """``ContentSource`` over bytes or a pinned memoryview.""" + + def __init__(self, data): + self._data = memoryview(data).cast("B") if not isinstance(data, bytes) else data + + def __len__(self) -> int: + return len(self._data) + + def read(self, offset: int, size: int): + return self._data[offset:offset + size] + + def check(self) -> None: + return None + + +def wav_header(channels: int, rate: int, frames: int) -> bytes: + """Canonical 44-byte RIFF/WAVE PCM s16le header.""" + data = frames * channels * 2 + return struct.pack("<4sI4s4sIHHIIHH4sI", b"RIFF", 36 + data, b"WAVE", b"fmt ", 16, 1, channels, rate, + rate * channels * 2, channels * 2, 16, b"data", data) + + +@dataclass(frozen=True) +class WavInfo: + channels: int + rate: int + data_offset: int + data_bytes: int + + @property + def frames(self) -> int: + return self.data_bytes // (self.channels * 2) + + +def parse_wav(header: bytes, file_size: int) -> Optional[WavInfo]: + """Strict RIFF/WAVE PCM 16-bit parse of at most 4 KiB; None when unsupported.""" + try: + if len(header) < 12 or header[:4] != b"RIFF" or header[8:12] != b"WAVE": + return None + offset, fmt = 12, None + while offset + 8 <= len(header): + chunk, size = struct.unpack_from("<4sI", header, offset) + body = offset + 8 + if chunk == b"fmt ": + if size < 16 or body + size > len(header): + return None + tag, channels, rate, _, align, bits = struct.unpack_from(" int: + return self._length + + def read(self, offset: int, size: int) -> bytes: + result = b"" + if offset < 44: + result = self._header[offset:min(44, offset + size)] + size -= len(result) + offset = 44 + if size > 0: + result += self._lease.read(self._start + offset - 44, size) + return result + + def check(self) -> None: + self._lease.check() diff --git a/python/fi_instrumentation/attachments/stream.py b/python/fi_instrumentation/attachments/stream.py new file mode 100644 index 000000000..b8644005b --- /dev/null +++ b/python/fi_instrumentation/attachments/stream.py @@ -0,0 +1,136 @@ +"""Consumed-stream observation (design section 6): a single bounded object. + +The core never pulls from, clones or tees a caller's stream. An adapter on the +application's own consumption path forwards chunks the application already +read. The whole ``max_bytes`` is reserved at admission; exceeding it discards +everything (``too_large``). A reference is projected only at ``finish()``. +""" + +import threading +import time +import weakref +from dataclasses import dataclass +from typing import Optional + +from .types import AttachmentHandle + + +@dataclass(frozen=True) +class StreamOptions: + mime_type: str + direction: str + max_bytes: int + purpose: Optional[str] = None + capture_policy: Optional[object] = None + message_index: Optional[int] = None + part_index: Optional[int] = None + role: Optional[str] = None + channel: Optional[int] = None + conversation_id: Optional[str] = None + turn_id: Optional[str] = None + tool_call_id: Optional[str] = None + idle_ttl: float = 60.0 + + +class AttachmentStream: + """Synchronous, non-throwing, no I/O on ``try_write``.""" + + def __init__(self, manager=None, ticket=None, options: Optional[StreamOptions] = None, reason: str = "queued"): + self.reason = reason + self.attachment_id: Optional[str] = None + self.occurrence_id: Optional[str] = None + self._manager = manager + self._ticket = ticket + self._options = options + self._buffer = bytearray() + self._lock = threading.Lock() + self._epoch = manager._epoch if manager is not None else 0 + self._last = time.monotonic() + self._idle = min(max(float(options.idle_ttl), 0.0), 300.0) if options is not None else 0.0 + self._done = reason != "queued" + self._handle: Optional[AttachmentHandle] = None + if not self._done: + self.attachment_id = ticket._attachment_id + self.occurrence_id = ticket._occurrence_id + reservation = ticket._reservation + self._finalizer = weakref.finalize(self, reservation.release) + manager._track_stream(self) + + @classmethod + def denied(cls, reason: str) -> "AttachmentStream": + return cls(reason=reason) + + @property + def open(self) -> bool: + return not self._done + + def _discard(self, reason: str) -> None: + # Caller holds self._lock. + self._done = True + self.reason = reason + self._buffer = bytearray() + self.attachment_id = self.occurrence_id = None + if self._ticket is not None: + self._ticket._drop() + self._finalizer.detach() + self._ticket = None + + def try_write(self, chunk) -> bool: + try: + with self._lock: + if self._done: + return False + manager = self._manager + if manager._stopped or manager._stopping: + self._discard("incomplete") + return False + if manager._epoch != self._epoch: + reason = manager._recheck_ticket(self._ticket) + if reason: + self._discard(reason) + return False + self._epoch = manager._epoch + view = memoryview(chunk).cast("B") + if len(self._buffer) + len(view) > self._ticket.max_bytes: + self._discard("too_large") + return False + step = manager.config.chunk_bytes + for offset in range(0, len(view), step): + self._buffer += view[offset:offset + step] + self._last = time.monotonic() + return True + except Exception: + return False + + def finish(self) -> AttachmentHandle: + with self._lock: + if self._done: + return self._handle or AttachmentHandle(self.reason) + self._done = True + data, self._buffer = bytes(self._buffer), bytearray() + ticket, self._ticket = self._ticket, None + self._finalizer.detach() + if not data: + ticket._drop() + self.reason = "incomplete" + self._handle = AttachmentHandle("incomplete") + return self._handle + try: + self._handle = self._manager._commit_stream_finish(ticket, self._options, data) + except Exception: + ticket._drop() + self._handle = AttachmentHandle("source_unavailable") + self.reason = self._handle.admission + return self._handle + + def abort(self, reason: str = "incomplete") -> None: + with self._lock: + if not self._done: + self._discard("policy_denied" if reason == "policy_denied" else "incomplete") + + def _sweep(self, now: float) -> bool: + with self._lock: + if not self._done and now - self._last >= self._idle: + self._discard("incomplete") + return True + return False diff --git a/python/fi_instrumentation/attachments/types.py b/python/fi_instrumentation/attachments/types.py index 4f045eee7..766f0d7d5 100644 --- a/python/fi_instrumentation/attachments/types.py +++ b/python/fi_instrumentation/attachments/types.py @@ -1,4 +1,4 @@ -"""Content-free handles and typed attachment sources (no implicit reads).""" +"""Content-free handles, shared vocabulary and typed sources (no implicit reads).""" import asyncio import re @@ -10,6 +10,42 @@ from opentelemetry import trace from opentelemetry.trace import SpanContext +# F01 MIME -> Modality (contract.schema.json allOf mapping). +MIME_MODALITIES = { + "audio/wav": "audio", "audio/ogg": "audio", "audio/mpeg": "audio", "audio/mp4": "audio", + "audio/webm": "audio", "audio/flac": "audio", "audio/L16": "audio", + "image/png": "image", "image/jpeg": "image", "image/webp": "image", + "video/mp4": "video", "video/webm": "video", + "application/pdf": "document", "application/octet-stream": "file", +} +AUDIO_MIMES = frozenset(m for m, k in MIME_MODALITIES.items() if k == "audio") +PURPOSES = ("conversation_recording", "turn_recording", "model_input", "model_output", "tool_result", + "computer_screenshot", "diagnostic", "document") +REFERENCE_ROLES = ("user", "assistant", "tool", "system", "unknown") +TRACK_ROLES = ("user", "assistant", "mixed", "unknown") +DIRECTIONS = ("input", "output", "mixed") +GAP_REASONS = ("queue_full", "bootstrap_pending", "source_unavailable", "policy_denied", "truncated", "incomplete") +ADMISSION_REASONS = frozenset(( + "queued", "disabled", "bootstrap_pending", "policy_denied", "credential_scope_unsupported", + "source_unavailable", "unsampled", "too_large", "queue_full", "unsupported_version", + "endpoint_unconfigured", "scope_unresolved", "correlation_unavailable", "redaction_unavailable", + "recording_disabled", "expired", "deleted", "incomplete", +)) +COMPLETION_STATUSES = frozenset(( + "validating", "importing", "incomplete", "expired", "deleted", "policy_denied", "too_large", "throttled", + "conflict", "not_found", "credential_scope_unsupported", "validation_failed", "unsupported_version", + "source_unavailable", "redaction_unavailable", +)) +SAFE_REASONS = ADMISSION_REASONS | COMPLETION_STATUSES +TOKEN = re.compile(r"[a-zA-Z0-9_-]{1,128}") +UUID_RE = re.compile(r"[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}") + + +def canonical_uuid(value) -> Optional[str]: + if not isinstance(value, str) or not UUID_RE.fullmatch(value) or not uuid.UUID(value).int: + return None + return value + @dataclass(frozen=True) class Bytes: @@ -81,6 +117,19 @@ def from_span(cls, span_or_context=None) -> "CorrelationHandle": class Completion: status: str # "validating" is transfer completion, not a storage/readiness claim. + # "unfinished" is only the local result of a timed-out wait. + + +@dataclass(frozen=True) +class AttachmentStatus: + state: str + queued: int = 0 + active: int = 0 + open_tickets: int = 0 + open_streams: int = 0 + open_recordings: int = 0 + owned_bytes: int = 0 + dropped: int = 0 class AttachmentHandle: @@ -90,9 +139,9 @@ class AttachmentHandle: references and must not be projected onto spans or diagnostics. """ - def __init__(self, admission: str): - self._attachment_id = str(uuid.uuid4()) - self._occurrence_id = str(uuid.uuid4()) + def __init__(self, admission: str, attachment_id: Optional[str] = None, occurrence_id: Optional[str] = None): + self._attachment_id = attachment_id or str(uuid.uuid4()) + self._occurrence_id = occurrence_id or str(uuid.uuid4()) self._admission = admission self._event = threading.Event() self._completion: Optional[Completion] = None @@ -111,18 +160,28 @@ def occurrence_id(self) -> str: def admission(self) -> str: return self._admission + @property + def reason(self) -> str: + return self._admission + def _finish(self, status: str) -> None: if not self._event.is_set(): self._completion = Completion(status) self._event.set() def result(self, timeout: float = 0) -> Completion: - self._event.wait(max(0, min(timeout, 30))) + if timeout and timeout > 0: + self._event.wait(min(timeout, 30)) return self._completion or Completion("unfinished") async def wait(self, timeout: float = 5) -> Completion: + if self._event.is_set(): + return self._completion return await asyncio.to_thread(self.result, timeout) + def __repr__(self) -> str: + return "AttachmentHandle(admission=%r)" % self._admission + @dataclass(frozen=True) class FlushResult: diff --git a/python/fi_instrumentation/otel.py b/python/fi_instrumentation/otel.py index a768ea5e0..75df92b8c 100644 --- a/python/fi_instrumentation/otel.py +++ b/python/fi_instrumentation/otel.py @@ -254,18 +254,19 @@ def register( # default: a later add_span_processor() call adds next to it, as in upstream OpenTelemetry. tracer_provider.add_span_processor(span_processor) - # Attachment control-plane configuration is independent of OTLP. OFF does - # not construct a transport, start workers, or make any bootstrap request. - from fi_instrumentation.attachments import AttachmentManager, AttachmentSpanProcessor + # Attachment control-plane configuration is independent of OTLP. OFF returns + # the null object: no transport, thread, timer, fork hook or bootstrap request. + from fi_instrumentation.attachments import AttachmentConfig, AttachmentSpanProcessor, create_attachment_manager from fi_instrumentation.instrumentation.config import TraceConfig tracer_provider.trace_config = trace_config or TraceConfig() - tracer_provider.attachment_manager = AttachmentManager( + attachment_config = attachment_config or AttachmentConfig() + tracer_provider.attachment_manager = create_attachment_manager( config=attachment_config, trace_config=tracer_provider.trace_config, project_name=project_name, project_type=project_type.value, - headers=_with_fi_auth_headers(headers), + headers=_with_fi_auth_headers(headers) if attachment_config.enabled else None, ) - if tracer_provider.attachment_manager.config.enabled: + if tracer_provider.attachment_manager.status().state != "disabled": tracer_provider.add_span_processor(AttachmentSpanProcessor(tracer_provider.attachment_manager)) if set_global_tracer_provider: diff --git a/python/tests/attachments/conftest.py b/python/tests/attachments/conftest.py index 2b4b12c5f..b3a44043a 100644 --- a/python/tests/attachments/conftest.py +++ b/python/tests/attachments/conftest.py @@ -1,12 +1,23 @@ +import json import os +import sys import threading import time import uuid -from dataclasses import replace +from pathlib import Path import pytest from fi_instrumentation.attachments import AttachmentConfig, AttachmentManager, ServerPolicy -from fi_instrumentation.attachments.protocol import Session, Upload +from fi_instrumentation.attachments.errors import TransferError +from fi_instrumentation.attachments.protocol import ImportJob, Limits, Session, Upload, strict_json + +sys.path.insert(0, str(Path(__file__).parent)) + +F01 = Path(__file__).parent / "f01" + + +def f01(name): + return json.loads((F01 / name).read_text()) @pytest.fixture(autouse=True) @@ -16,56 +27,162 @@ def clean_attachment_env(monkeypatch): monkeypatch.delenv(key, raising=False) +def capability(): + return "cap_" + uuid.uuid4().hex + + class TransportDouble: - def __init__(self, policy=None): + """Section 9 AttachmentTransport double. Honors check() and deadlines.""" + + def __init__(self, policy=None, limits=None): self.policy = policy or ServerPolicy( - enabled=True, credential_write=True, allowed_sources=frozenset(("Bytes", "OwnedRecordingFile")), - allowed_directions=frozenset(("input", "output", "mixed")), require_media_redaction=False, - require_metadata_removal=False, version="v1") - self.requests, self.payloads, self.aborts = [], [], [] + enabled=True, credential_write=True, + allowed_sources=frozenset(("Bytes", "OwnedRecordingFile", "ProviderFile", "RemoteUrl")), + allowed_modalities=frozenset(("audio", "image", "video", "document", "file")), + require_media_redaction=False, require_metadata_removal=False, record_audio=True, version="v1") + self.limits = limits or Limits() + self.requests, self.payloads, self.aborts, self.keys = [], [], [], [] + self.manifests, self.imports, self.statuses = [], [], [] self.entered = threading.Event() self.release = threading.Event() self.release.set() - self.failures = [] + self.failures, self.init_failures, self.complete_failures, self.manifest_failures = [], [], [], [] self.calls = 0 self.bootstraps = 0 + self.bootstrap_bodies = [] + self.session_ttl = 600 + self.renew_result = "fresh" + self.renewals = [] + self.session_renewals = [] + self.renew_scope = None + self.renew_policy = None + self.uploads = {} + self.capability_used = [] + self.content_thread = [] + self.block_forever = False + + def _session(self, body, ttl=None): + scope = ("00000000-0000-4000-8000-000000000001", "00000000-0000-4000-8000-000000000002", + "00000000-0000-4000-8000-000000000003") + now = time.time() + return Session(scope[2], body["capture_session_id"], self.policy, now + (ttl or self.session_ttl), + self.limits, scope, now, json.dumps(body).encode()) - def bootstrap(self, project_name, project_type, session_id, nonce): + def bootstrap(self, body, *, key, deadline): self.bootstraps += 1 - return Session(str(uuid.uuid4()), session_id, self.policy, time.time() + 60, 8 * 1024 * 1024) + self.bootstrap_bodies.append(dict(body)) + self.keys.append(key) + return self._session(body) + + def renew_session(self, current, *, sequence, deadline): + self.session_renewals.append(sequence) + if self.renew_result == "fail": + raise TransferError("incomplete", True) + body = json.loads(current.request) + session = self._session(body) + if self.renew_scope is not None: + session = Session(self.renew_scope, session.capture_session_id, session.policy, session.expires_at, + session.limits, (session.scope[0], session.scope[1], self.renew_scope), + session.issued_at, session.request) + if self.renew_policy is not None: + session = Session(session.project_id, session.capture_session_id, self.renew_policy, + session.expires_at, session.limits, session.scope, session.issued_at, session.request) + if session.scope != current.scope: + raise TransferError("scope_unresolved") + return session - def initialize(self, session, request, check): + def initialize(self, session, body, *, key, deadline, check): check() - self.requests.append(dict(request)) - return Upload(str(uuid.uuid4()), time.time() + 60) + request = strict_json(body) + self.keys.append(key) + self.requests.append(request) + if self.init_failures: + raise self.init_failures.pop(0) + upload = self.uploads.get(key) + if upload is None: + upload = Upload(str(uuid.uuid4()), time.time() + 60, capability(), request["declared_bytes"]) + self.uploads[key] = upload + return upload - def transfer(self, session, upload, payload, check, chunk_bytes): + def renew_upload(self, session, upload, body, *, deadline): + self.renewals.append(body) + if self.renew_result == "same": + raise TransferError("expired") + fresh = Upload(upload.upload_id, time.time() + 120, capability(), upload.reserved_bytes) + return fresh + + def put_content(self, session, upload, source, *, deadline, check, pacer, chunk_bytes=256 * 1024): self.calls += 1 + self.content_thread.append(threading.current_thread().name) self.entered.set() - assert self.release.wait(5) + while not self.release.wait(0.05): + if self.block_forever: + continue + check() + if time.monotonic() > deadline: + raise TransferError("incomplete", True) check() + self.capability_used.append(("content", upload.capability)) if self.failures: raise self.failures.pop(0) - if not isinstance(payload, bytes): - payload = payload.read(0, len(payload)) - self.payloads.append(payload) + data = b"".join(bytes(source.read(o, min(chunk_bytes, len(source) - o))) + for o in range(0, len(source), chunk_bytes)) + source.check() + self.payloads.append(data) - def complete(self, session, upload, check): + def complete(self, session, upload, *, key, deadline, check): check() + self.keys.append(key) + self.capability_used.append(("complete", upload.capability)) + if self.complete_failures: + raise self.complete_failures.pop(0) + return "validating" - def abort(self, session, upload): + def abort(self, session, upload, *, key, deadline): + self.keys.append(key) self.aborts.append(upload.upload_id) + def upload_status(self, session, upload, *, deadline): + return ("validating", "binding_pending") + + def put_manifest(self, session, capability_token, recording_id, body, *, key, deadline, check): + check() + self.keys.append(key) + self.capability_used.append(("manifest", capability_token)) + if self.manifest_failures: + raise self.manifest_failures.pop(0) + self.manifests.append((recording_id, json.loads(body), key, capability_token)) + + def submit_import(self, session, body, *, key, deadline, check): + check() + self.keys.append(key) + request = json.loads(body) + self.imports.append((request, key)) + if self.failures: + raise self.failures.pop(0) + return ImportJob(str(uuid.uuid4()), request["recording"]["recording_id"]) + + def import_status(self, session, job_id, *, deadline): + self.statuses.append(job_id) + return ("importing", "binding_pending") + @pytest.fixture def transport(): return TransportDouble() +def make_manager(transport, **config): + manager = AttachmentManager(config=AttachmentConfig(enabled=True, **config), project_name="synthetic", + transport=transport) + assert manager.ready(2) + return manager + + @pytest.fixture def manager(transport): - manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) - assert manager.ready(2) + manager = make_manager(transport) yield manager transport.release.set() + transport.block_forever = False manager.shutdown(2) diff --git a/python/tests/attachments/exit_probe.py b/python/tests/attachments/exit_probe.py new file mode 100644 index 000000000..84382a294 --- /dev/null +++ b/python/tests/attachments/exit_probe.py @@ -0,0 +1,179 @@ +"""Separate-interpreter exit probes (design 8.5, T-LC-06..11). + +Run as ``python exit_probe.py ``. Prints ``DONE`` and exits 0 on success. +Never imported by pytest: forking a threaded pytest process is unsafe (the +latest OpenTelemetry SDK's own at-fork handler can deadlock a child). +""" + +import asyncio +import os +import sys +import threading +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).parent)) + +from fi_instrumentation.attachments import ( # noqa: E402 + AttachmentConfig, AttachmentManager, Bytes, CompletedRecordingRequest, CorrelationHandle, PcmFormat, + RecordingOptions, TrackSpec, +) + +CONTEXT = CorrelationHandle("1234567890abcdef1234567890abcdef", "1234567890abcdef", True) + + +def TransportDouble(): + # Imported lazily: the disabled case must not import the wire adapter. + from conftest import TransportDouble as Double + + return Double() + + +def manager(transport, **config): + result = AttachmentManager(config=AttachmentConfig(enabled=True, **config), project_name="synthetic", + transport=transport) + assert result.ready(5) + return result + + +def case_disabled(): + import atexit + + registered = [] + original_fork, original_atexit = os.register_at_fork, atexit.register + def owner(function): + function = getattr(function, "__func__", function) + return getattr(function, "__module__", "") or "" + + os.register_at_fork = lambda **kw: (registered.extend(owner(f) for f in kw.values()), original_fork(**kw))[1] + atexit.register = lambda f, *a, **kw: (registered.append(owner(f)), original_atexit(f, *a, **kw))[1] + from fi_instrumentation import register + + before = threading.active_count() + provider = register(project_name="synthetic", batch=False, set_global_tracer_provider=False, verbose=False) + atexit.register = original_atexit + os.register_at_fork = original_fork + with provider.get_tracer("probe").start_as_current_span("span") as span: + attributes = dict(span.attributes or {}) + provider.shutdown() + assert provider.attachment_manager.status().state == "disabled" + # The OpenTelemetry SDK registers its own hooks; attachments registers none. + assert not [m for m in registered if m.startswith("fi_instrumentation.attachments")], registered + from fi_instrumentation.attachments import manager as attachment_manager + + assert attachment_manager._FORK_HOOK_REGISTERED is False + assert "fi_instrumentation.attachments.protocol" not in sys.modules + # fi_instrumentation.otel itself imports jsonschema; attachments must not + # compile its privacy table or load the wire schema when disabled. + from fi_instrumentation.attachments import policy + + assert policy._table.cache_info().currsize == 0 + assert not any(k.startswith("fi.attachment.") for k in attributes) + assert not [t.name for t in threading.enumerate() if t.name.startswith("fi-attachment")] + assert threading.active_count() == before, (before, threading.active_count()) + + +def case_enabled_idle(): + result = manager(TransportDouble()) + assert result.status().state == "ready" + assert result.shutdown(1).unfinished == 0 + + +def case_enabled_blocked(): + transport = TransportDouble() + transport.release.clear() + transport.block_forever = True + result = manager(transport, shutdown_timeout=1) + handle = result.attach(CONTEXT, Bytes(b"x" * 64), mime_type="audio/wav", direction="mixed") + assert handle.admission == "queued" + assert transport.entered.wait(5) + start = time.monotonic() + flushed = result.shutdown() + assert time.monotonic() - start < 1.25, time.monotonic() - start + assert flushed.unfinished >= 1 + + +def case_enabled_no_shutdown(): + transport = TransportDouble() + transport.release.clear() + transport.block_forever = True + result = manager(transport) + result.attach(CONTEXT, Bytes(b"x" * 64), mime_type="audio/wav", direction="mixed") + assert transport.entered.wait(5) + # Return without shutdown: daemon threads must not hold the process. + + +def case_fork(): + transport = TransportDouble() + transport.release.clear() + result = manager(transport) + parent_session = result.capture_session_id + parent = result.attach(CONTEXT, Bytes(b"parent"), mime_type="audio/wav", direction="mixed") + assert transport.entered.wait(5) + read_fd, write_fd = os.pipe() + pid = os.fork() + if pid == 0: + try: + os.close(read_fd) + transport.release.set() + ok = result.owned_bytes == 0 and result.capture_session_id != parent_session + ok = ok and result.status().state == "bootstrap_pending" and result.ready(5) + child = result.attach(CONTEXT, Bytes(b"child"), mime_type="audio/wav", direction="mixed") + ok = ok and child.result(5).status == "validating" + ok = ok and result.flush(5).unfinished == 0 + ok = ok and transport.bootstrap_bodies[-1]["capture_session_id"] != parent_session + os.write(write_fd, b"ok" if ok else b"failed") + finally: + os._exit(0) + os.close(write_fd) + answer = os.read(read_fd, 20) + os.close(read_fd) + _, status = os.waitpid(pid, 0) + assert answer == b"ok" and status == 0, (answer, status) + transport.release.set() + assert parent.result(5).status == "validating" + assert result.shutdown(2).unfinished == 0 + + +def case_mid_recording(): + transport = TransportDouble() + result = manager(transport) + options = RecordingOptions(PcmFormat(24000), "mixed", (TrackSpec((0,), "mixed", "unknown"),), + "observe_consumed") + writer = result.start_recording(CONTEXT, options) + assert writer.reason == "queued", writer.reason + chunk = b"\x00\x01" * 480 # 20 ms at 24 kHz mono + for _ in range(250): # 5 s + writer.try_write(chunk) + start = time.monotonic() + result.shutdown(5) + assert time.monotonic() - start < 5.25 + final = writer.finish(0) + assert final.state in ("published", "partial"), final + assert transport.manifests, "final manifest not PUT" + + +def case_import_pending(): + transport = TransportDouble() + result = manager(transport) + + class Never: + async def resolve(self, request, *, deadline): + await asyncio.sleep(3600) + + async def run(): + return await result.import_completed_recording( + CONTEXT, CompletedRecordingRequest("livekit_egress", "EG_synthetic"), resolver=Never(), timeout=1) + + handle = asyncio.run(run()) + assert handle.reason == "source_unavailable", handle.reason + assert result.shutdown(1).unfinished == 0 + + +CASES = {"disabled": case_disabled, "enabled-idle": case_enabled_idle, "enabled-blocked": case_enabled_blocked, + "enabled-no-shutdown": case_enabled_no_shutdown, "fork": case_fork, "mid-recording": case_mid_recording, + "import-pending": case_import_pending} + +if __name__ == "__main__": + CASES[sys.argv[1]]() + print("DONE", flush=True) diff --git a/python/tests/attachments/f01/README.txt b/python/tests/attachments/f01/README.txt new file mode 100644 index 000000000..2cf5d02d9 --- /dev/null +++ b/python/tests/attachments/f01/README.txt @@ -0,0 +1,4 @@ +Vendored, unmodified copies of spec/attachments/v1 fixtures from the F01 +contract (traceAI PR #675, branch feat/attachments-contract, commit f3b0923c62). +Refresh them together with fi_instrumentation/attachments/_protocol_schema.json +and _privacy_table.json when the contract revision changes. diff --git a/python/tests/attachments/f01/lifecycle-fixtures.json b/python/tests/attachments/f01/lifecycle-fixtures.json new file mode 100644 index 000000000..b4d411c84 --- /dev/null +++ b/python/tests/attachments/f01/lifecycle-fixtures.json @@ -0,0 +1,180 @@ +{ + "schema_version": 1, + "initial": { + "state": "pending_upload", + "binding": "pending", + "generation": 0 + }, + "terminal": [ + "failed", + "rejected", + "expired", + "deleted" + ], + "transitions": [ + { + "event": "complete", + "from": [ + "pending_upload", + "importing" + ], + "to": "validating" + }, + { + "event": "validate", + "from": [ + "validating" + ], + "to": "ready" + }, + { + "event": "fail", + "from": [ + "pending_upload", + "importing", + "validating" + ], + "to": "failed" + }, + { + "event": "reject", + "from": [ + "pending_upload", + "importing", + "validating" + ], + "to": "rejected" + }, + { + "event": "expire", + "from": [ + "pending_upload", + "importing", + "validating", + "ready" + ], + "to": "expired" + }, + { + "event": "delete", + "from": [ + "pending_upload", + "importing", + "validating", + "ready", + "failed", + "rejected", + "expired" + ], + "to": "deleted" + } + ], + "cases": [ + { + "id": "late-root-releases-ready-bytes", + "events": [ + "complete", + "validate", + "bind" + ], + "readable_after_each": [ + false, + false, + true + ], + "final": "ready" + }, + { + "id": "root-first-still-needs-validation", + "events": [ + "bind", + "complete", + "validate" + ], + "readable_after_each": [ + false, + false, + true + ], + "final": "ready" + }, + { + "id": "missing-tail-sampled-root", + "events": [ + "complete", + "validate", + "expire", + "bind" + ], + "readable_after_each": [ + false, + false, + false, + false + ], + "final": "expired" + }, + { + "id": "deletion-fences-completion-and-binding", + "events": [ + "complete", + "delete", + "validate", + "bind" + ], + "readable_after_each": [ + false, + false, + false, + false + ], + "final": "deleted" + }, + { + "id": "ready-delete-replay", + "events": [ + "bind", + "complete", + "validate", + "delete", + "complete", + "validate" + ], + "readable_after_each": [ + false, + false, + true, + false, + false, + false + ], + "final": "deleted" + }, + { + "id": "client-success-not-readiness", + "events": [ + "bind", + "complete" + ], + "readable_after_each": [ + false, + false + ], + "final": "validating" + }, + { + "id": "failed-cannot-retry-validation", + "events": [ + "fail", + "complete", + "validate" + ], + "readable_after_each": [ + false, + false, + false + ], + "final": "failed" + } + ] +} diff --git a/python/tests/attachments/f01/privacy-fixtures.json b/python/tests/attachments/f01/privacy-fixtures.json new file mode 100644 index 000000000..1419df0cf --- /dev/null +++ b/python/tests/attachments/f01/privacy-fixtures.json @@ -0,0 +1,5758 @@ +{ + "schema_version": 1, + "cases": [ + { + "id": "explicit-import-does-not-start-recording", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "deny-enabled", + "stage": "admission", + "context": { + "enabled": false, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "disabled", + "effects": [] + } + }, + { + "id": "deny-endpoint_configured", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": false, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "endpoint_unconfigured", + "effects": [] + } + }, + { + "id": "deny-policy_known", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": false, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "bootstrap_pending", + "effects": [] + } + }, + { + "id": "deny-server_allowed", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-credential_allowed", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": false, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "credential_scope_unsupported", + "effects": [] + } + }, + { + "id": "deny-integration_capture_content", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": false, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-integration_record_inputs", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": false, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-integration_record_outputs", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": false, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-muted", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": true, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-temporary_chat", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": true, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_inputs", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": true, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_outputs", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": true, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_input_messages", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": true, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_output_messages", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": true, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_input_text", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": true, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-hide_output_text", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": true, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-pii_redaction", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "deny-server_require_media_redaction", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": true, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "deny-require_metadata_removal", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": true, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "deny-modality_allowed", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": false, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-source_authorized", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": false, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-call_requested", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": false, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "deny-sampled", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": false, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "unsampled", + "effects": [] + } + }, + { + "id": "deny-correlation_available", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": false, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "correlation_unavailable", + "effects": [] + } + }, + { + "id": "deny-generation_current", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": false, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "deleted", + "effects": [] + } + }, + { + "id": "deny-source_available", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": false, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "source_unavailable", + "effects": [] + } + }, + { + "id": "deny-budget_available", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": false, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "too_large", + "effects": [] + } + }, + { + "id": "deny-queue_available", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": false, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "queue_full", + "effects": [] + } + }, + { + "id": "deny-browser_remote_fetch", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": true, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "lower-call-opt-in-cannot-override-server", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "tool-output-model-input-image-ancestry", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": true, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "output", + "semantic_input": false, + "semantic_output": true, + "model_bound_image": true, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "image", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "direct-input-image-hide", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": true, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "input", + "semantic_input": true, + "semantic_output": false, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "image", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "ancestor-input-hide-denies-tool-output", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": true, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "output", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "genuinely-isolated-output-track", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": true, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "output", + "semantic_input": false, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "mixed-track-cannot-claim-input-isolation", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": true, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": false, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "input-image-cannot-reintroduce-hidden-text", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": true, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "input", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "image", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "error-body-denied", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": true, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": true, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "safe-non-error-media", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": true, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-raw-audio", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-qualified-local-audio", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-raw-image", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "image", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-qualified-local-image", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "image", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-raw-video", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "video", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-qualified-local-video", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "video", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-raw-document", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "document", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-qualified-local-document", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "document", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-raw-file", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "file", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-qualified-local-file", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "file", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "pii-client-exception-alone-insufficient", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": true, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "pii-explicit-bilateral-exception", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": true, + "server_allow_unredacted_media_with_text_pii": true, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "server-redaction-non-overridable", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": true, + "server_require_media_redaction": true, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": true, + "server_allow_unredacted_media_with_text_pii": true, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "metadata-client-transform", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": true, + "qualified_client_metadata_removal": true, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "server-transform-is-not-before-egress", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": true, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": true, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "redaction_unavailable", + "effects": [] + } + }, + { + "id": "remote-deny-remote_destination_approved", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": false, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "remote-deny-all_addresses_public", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": false, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "remote-deny-tls_ip_pinned", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": false, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "remote-deny-redirects_revalidated", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": false, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "remote-deny-ambient_credentials_absent", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": false, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "remote-qualified-source", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "RemoteUrl", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "owned-file-deny-owned_session_bound", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "OwnedRecordingFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": false, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "owned-file-deny-owned_file_lease_valid", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "OwnedRecordingFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": false, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "owned-file-explicit-lease", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "OwnedRecordingFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "provider-connection-not-granted", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "ProviderFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": false, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "credential_scope_unsupported", + "effects": [] + } + }, + { + "id": "egress-start-is-not-complete", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "ProviderFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": false, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "source_unavailable", + "effects": [] + } + }, + { + "id": "egress-completed-output", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "ProviderFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "egress-labelled-partial", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "ProviderFile", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": false, + "explicit_partial_allowed": true + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "new-audio-off", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "recording_disabled", + "effects": [] + } + }, + { + "id": "new-audio-client-only", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": true, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "recording_disabled", + "effects": [] + } + }, + { + "id": "new-audio-explicit", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": true, + "record_video": false, + "server_record_audio": true, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "new-video-off", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "video", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "recording_disabled", + "effects": [] + } + }, + { + "id": "new-video-client-only", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "video", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": false, + "record_video": true, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "recording_disabled", + "effects": [] + } + }, + { + "id": "new-video-explicit", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "video", + "source_kind": "Bytes", + "operation": "create_recording", + "record_audio": false, + "record_video": true, + "server_record_audio": false, + "server_record_video": true, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "allow", + "reason": "queued", + "effects": [ + "read", + "copy", + "hash", + "upload", + "reference" + ] + } + }, + { + "id": "tightened-policy-read", + "stage": "read", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "tightened-generation-read", + "stage": "read", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": false, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "deleted", + "effects": [] + } + }, + { + "id": "tightened-policy-upload", + "stage": "upload", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "tightened-generation-upload", + "stage": "upload", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": false, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "deleted", + "effects": [] + } + }, + { + "id": "tightened-policy-retry", + "stage": "retry", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "tightened-generation-retry", + "stage": "retry", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": false, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "deleted", + "effects": [] + } + }, + { + "id": "tightened-policy-serve", + "stage": "serve", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": false, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + }, + { + "id": "tightened-generation-serve", + "stage": "serve", + "context": { + "enabled": true, + "endpoint_configured": true, + "policy_known": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": false, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "deleted", + "effects": [] + } + }, + { + "id": "unknown-policy-fact-fails-closed", + "stage": "admission", + "context": { + "enabled": true, + "endpoint_configured": true, + "server_allowed": true, + "credential_allowed": true, + "integration_capture_content": true, + "integration_record_inputs": true, + "integration_record_outputs": true, + "muted": false, + "temporary_chat": false, + "hide_inputs": false, + "hide_outputs": false, + "hide_input_messages": false, + "hide_output_messages": false, + "hide_input_images": false, + "hide_input_text": false, + "hide_output_text": false, + "hide_error_details": false, + "pii_redaction": false, + "server_require_media_redaction": false, + "qualified_client_sanitizer": false, + "allow_unredacted_media_with_text_pii": false, + "server_allow_unredacted_media_with_text_pii": false, + "require_metadata_removal": false, + "qualified_client_metadata_removal": false, + "modality_allowed": true, + "source_authorized": true, + "call_requested": true, + "sampled": true, + "correlation_available": true, + "generation_current": true, + "source_available": true, + "budget_available": true, + "queue_available": true, + "direction": "mixed", + "semantic_input": true, + "semantic_output": true, + "model_bound_image": false, + "opaque_text_possible": true, + "error_diagnostic": false, + "modality": "audio", + "source_kind": "Bytes", + "operation": "import_existing", + "record_audio": false, + "record_video": false, + "server_record_audio": false, + "server_record_video": false, + "browser_remote_fetch": false, + "remote_destination_approved": true, + "all_addresses_public": true, + "tls_ip_pinned": true, + "redirects_revalidated": true, + "ambient_credentials_absent": true, + "owned_session_bound": true, + "owned_file_lease_valid": true, + "provider_connection_authorized": true, + "provider_output_completed": true, + "explicit_partial_allowed": false + }, + "expected": { + "decision": "deny", + "reason": "policy_denied", + "effects": [] + } + } + ] +} diff --git a/python/tests/attachments/f01/recording-import-fixtures.json b/python/tests/attachments/f01/recording-import-fixtures.json new file mode 100644 index 000000000..452488901 --- /dev/null +++ b/python/tests/attachments/f01/recording-import-fixtures.json @@ -0,0 +1,2885 @@ +{ + "contract": "fi.attachments.v1", + "description": "Test-only admission headroom and verified execution observations, never caller-supplied authority or production importer code. Apply recursive object overrides; replace arrays. Each case checks only its named stage.", + "base": { + "request": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "limits": { + "max_upload_bytes": 52428800, + "segment_bytes": 8388608, + "segment_duration_ms": 30000, + "recording_bytes": 1073741824, + "recording_duration_ms": 7200000, + "active_transfers": 16, + "active_recordings": 4, + "reserved_bytes": 1073741824, + "validation_jobs": 1024, + "initializations_per_minute": 120, + "links_per_minute": 1000, + "upload_bytes_per_second": 1048576, + "playback_bytes_per_second": 1048576, + "transfer_timeout_seconds": 120, + "grant_ttl_seconds": 60, + "revocation_check_seconds": 5 + }, + "headroom": { + "project": { + "bytes": 1073741824, + "transfers": 1, + "recordings": 1, + "validation_jobs": 1, + "objects": 2, + "links": 1 + }, + "organization": { + "bytes": 2147483648, + "transfers": 1, + "recordings": 1, + "validation_jobs": 1, + "objects": 2, + "links": 1 + }, + "global": { + "bytes": 2147483648, + "transfers": 1, + "recordings": 1, + "validation_jobs": 1, + "objects": 2, + "links": 1 + } + }, + "source": { + "terminal_completed": true, + "immutable": true, + "bounded_ranges": true + }, + "observation": { + "source_bytes": 172800044, + "source_duration_ms": 3600000, + "generation_matches": true, + "reads": [ + { + "offset": 0, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 8388608, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 16777216, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 25165824, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 33554432, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 41943040, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 50331648, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 58720256, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 67108864, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 75497472, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 83886080, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 92274688, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 100663296, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 109051904, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 117440512, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 125829120, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 134217728, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 142606336, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 150994944, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 159383552, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 167772160, + "bytes": 5027884, + "total_bytes": 172800044 + } + ], + "manifest": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000100-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000101-0000-0000-0000-000000000001", + "index": 1, + "start_ms": 30000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000102-0000-0000-0000-000000000001", + "index": 2, + "start_ms": 60000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000103-0000-0000-0000-000000000001", + "index": 3, + "start_ms": 90000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000104-0000-0000-0000-000000000001", + "index": 4, + "start_ms": 120000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000105-0000-0000-0000-000000000001", + "index": 5, + "start_ms": 150000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000106-0000-0000-0000-000000000001", + "index": 6, + "start_ms": 180000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000107-0000-0000-0000-000000000001", + "index": 7, + "start_ms": 210000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000108-0000-0000-0000-000000000001", + "index": 8, + "start_ms": 240000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000109-0000-0000-0000-000000000001", + "index": 9, + "start_ms": 270000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010a-0000-0000-0000-000000000001", + "index": 10, + "start_ms": 300000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010b-0000-0000-0000-000000000001", + "index": 11, + "start_ms": 330000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010c-0000-0000-0000-000000000001", + "index": 12, + "start_ms": 360000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010d-0000-0000-0000-000000000001", + "index": 13, + "start_ms": 390000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010e-0000-0000-0000-000000000001", + "index": 14, + "start_ms": 420000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010f-0000-0000-0000-000000000001", + "index": 15, + "start_ms": 450000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000110-0000-0000-0000-000000000001", + "index": 16, + "start_ms": 480000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000111-0000-0000-0000-000000000001", + "index": 17, + "start_ms": 510000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000112-0000-0000-0000-000000000001", + "index": 18, + "start_ms": 540000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000113-0000-0000-0000-000000000001", + "index": 19, + "start_ms": 570000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000114-0000-0000-0000-000000000001", + "index": 20, + "start_ms": 600000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000115-0000-0000-0000-000000000001", + "index": 21, + "start_ms": 630000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000116-0000-0000-0000-000000000001", + "index": 22, + "start_ms": 660000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000117-0000-0000-0000-000000000001", + "index": 23, + "start_ms": 690000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000118-0000-0000-0000-000000000001", + "index": 24, + "start_ms": 720000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000119-0000-0000-0000-000000000001", + "index": 25, + "start_ms": 750000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011a-0000-0000-0000-000000000001", + "index": 26, + "start_ms": 780000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011b-0000-0000-0000-000000000001", + "index": 27, + "start_ms": 810000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011c-0000-0000-0000-000000000001", + "index": 28, + "start_ms": 840000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011d-0000-0000-0000-000000000001", + "index": 29, + "start_ms": 870000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011e-0000-0000-0000-000000000001", + "index": 30, + "start_ms": 900000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011f-0000-0000-0000-000000000001", + "index": 31, + "start_ms": 930000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000120-0000-0000-0000-000000000001", + "index": 32, + "start_ms": 960000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000121-0000-0000-0000-000000000001", + "index": 33, + "start_ms": 990000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000122-0000-0000-0000-000000000001", + "index": 34, + "start_ms": 1020000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000123-0000-0000-0000-000000000001", + "index": 35, + "start_ms": 1050000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000124-0000-0000-0000-000000000001", + "index": 36, + "start_ms": 1080000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000125-0000-0000-0000-000000000001", + "index": 37, + "start_ms": 1110000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000126-0000-0000-0000-000000000001", + "index": 38, + "start_ms": 1140000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000127-0000-0000-0000-000000000001", + "index": 39, + "start_ms": 1170000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000128-0000-0000-0000-000000000001", + "index": 40, + "start_ms": 1200000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000129-0000-0000-0000-000000000001", + "index": 41, + "start_ms": 1230000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012a-0000-0000-0000-000000000001", + "index": 42, + "start_ms": 1260000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012b-0000-0000-0000-000000000001", + "index": 43, + "start_ms": 1290000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012c-0000-0000-0000-000000000001", + "index": 44, + "start_ms": 1320000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012d-0000-0000-0000-000000000001", + "index": 45, + "start_ms": 1350000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012e-0000-0000-0000-000000000001", + "index": 46, + "start_ms": 1380000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012f-0000-0000-0000-000000000001", + "index": 47, + "start_ms": 1410000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000130-0000-0000-0000-000000000001", + "index": 48, + "start_ms": 1440000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000131-0000-0000-0000-000000000001", + "index": 49, + "start_ms": 1470000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000132-0000-0000-0000-000000000001", + "index": 50, + "start_ms": 1500000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000133-0000-0000-0000-000000000001", + "index": 51, + "start_ms": 1530000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000134-0000-0000-0000-000000000001", + "index": 52, + "start_ms": 1560000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000135-0000-0000-0000-000000000001", + "index": 53, + "start_ms": 1590000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000136-0000-0000-0000-000000000001", + "index": 54, + "start_ms": 1620000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000137-0000-0000-0000-000000000001", + "index": 55, + "start_ms": 1650000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000138-0000-0000-0000-000000000001", + "index": 56, + "start_ms": 1680000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000139-0000-0000-0000-000000000001", + "index": 57, + "start_ms": 1710000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013a-0000-0000-0000-000000000001", + "index": 58, + "start_ms": 1740000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013b-0000-0000-0000-000000000001", + "index": 59, + "start_ms": 1770000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013c-0000-0000-0000-000000000001", + "index": 60, + "start_ms": 1800000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013d-0000-0000-0000-000000000001", + "index": 61, + "start_ms": 1830000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013e-0000-0000-0000-000000000001", + "index": 62, + "start_ms": 1860000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013f-0000-0000-0000-000000000001", + "index": 63, + "start_ms": 1890000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000140-0000-0000-0000-000000000001", + "index": 64, + "start_ms": 1920000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000141-0000-0000-0000-000000000001", + "index": 65, + "start_ms": 1950000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000142-0000-0000-0000-000000000001", + "index": 66, + "start_ms": 1980000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000143-0000-0000-0000-000000000001", + "index": 67, + "start_ms": 2010000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000144-0000-0000-0000-000000000001", + "index": 68, + "start_ms": 2040000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000145-0000-0000-0000-000000000001", + "index": 69, + "start_ms": 2070000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000146-0000-0000-0000-000000000001", + "index": 70, + "start_ms": 2100000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000147-0000-0000-0000-000000000001", + "index": 71, + "start_ms": 2130000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000148-0000-0000-0000-000000000001", + "index": 72, + "start_ms": 2160000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000149-0000-0000-0000-000000000001", + "index": 73, + "start_ms": 2190000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014a-0000-0000-0000-000000000001", + "index": 74, + "start_ms": 2220000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014b-0000-0000-0000-000000000001", + "index": 75, + "start_ms": 2250000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014c-0000-0000-0000-000000000001", + "index": 76, + "start_ms": 2280000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014d-0000-0000-0000-000000000001", + "index": 77, + "start_ms": 2310000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014e-0000-0000-0000-000000000001", + "index": 78, + "start_ms": 2340000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014f-0000-0000-0000-000000000001", + "index": 79, + "start_ms": 2370000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000150-0000-0000-0000-000000000001", + "index": 80, + "start_ms": 2400000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000151-0000-0000-0000-000000000001", + "index": 81, + "start_ms": 2430000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000152-0000-0000-0000-000000000001", + "index": 82, + "start_ms": 2460000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000153-0000-0000-0000-000000000001", + "index": 83, + "start_ms": 2490000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000154-0000-0000-0000-000000000001", + "index": 84, + "start_ms": 2520000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000155-0000-0000-0000-000000000001", + "index": 85, + "start_ms": 2550000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000156-0000-0000-0000-000000000001", + "index": 86, + "start_ms": 2580000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000157-0000-0000-0000-000000000001", + "index": 87, + "start_ms": 2610000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000158-0000-0000-0000-000000000001", + "index": 88, + "start_ms": 2640000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000159-0000-0000-0000-000000000001", + "index": 89, + "start_ms": 2670000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015a-0000-0000-0000-000000000001", + "index": 90, + "start_ms": 2700000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015b-0000-0000-0000-000000000001", + "index": 91, + "start_ms": 2730000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015c-0000-0000-0000-000000000001", + "index": 92, + "start_ms": 2760000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015d-0000-0000-0000-000000000001", + "index": 93, + "start_ms": 2790000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015e-0000-0000-0000-000000000001", + "index": 94, + "start_ms": 2820000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015f-0000-0000-0000-000000000001", + "index": 95, + "start_ms": 2850000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000160-0000-0000-0000-000000000001", + "index": 96, + "start_ms": 2880000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000161-0000-0000-0000-000000000001", + "index": 97, + "start_ms": 2910000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000162-0000-0000-0000-000000000001", + "index": 98, + "start_ms": 2940000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000163-0000-0000-0000-000000000001", + "index": 99, + "start_ms": 2970000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000164-0000-0000-0000-000000000001", + "index": 100, + "start_ms": 3000000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000165-0000-0000-0000-000000000001", + "index": 101, + "start_ms": 3030000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000166-0000-0000-0000-000000000001", + "index": 102, + "start_ms": 3060000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000167-0000-0000-0000-000000000001", + "index": 103, + "start_ms": 3090000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000168-0000-0000-0000-000000000001", + "index": 104, + "start_ms": 3120000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000169-0000-0000-0000-000000000001", + "index": 105, + "start_ms": 3150000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016a-0000-0000-0000-000000000001", + "index": 106, + "start_ms": 3180000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016b-0000-0000-0000-000000000001", + "index": 107, + "start_ms": 3210000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016c-0000-0000-0000-000000000001", + "index": 108, + "start_ms": 3240000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016d-0000-0000-0000-000000000001", + "index": 109, + "start_ms": 3270000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016e-0000-0000-0000-000000000001", + "index": 110, + "start_ms": 3300000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016f-0000-0000-0000-000000000001", + "index": 111, + "start_ms": 3330000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000170-0000-0000-0000-000000000001", + "index": 112, + "start_ms": 3360000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000171-0000-0000-0000-000000000001", + "index": 113, + "start_ms": 3390000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000172-0000-0000-0000-000000000001", + "index": 114, + "start_ms": 3420000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000173-0000-0000-0000-000000000001", + "index": 115, + "start_ms": 3450000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000174-0000-0000-0000-000000000001", + "index": 116, + "start_ms": 3480000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000175-0000-0000-0000-000000000001", + "index": 117, + "start_ms": 3510000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000176-0000-0000-0000-000000000001", + "index": 118, + "start_ms": 3540000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000177-0000-0000-0000-000000000001", + "index": 119, + "start_ms": 3570000, + "duration_ms": 30000 + } + ], + "gaps": [], + "playout": [ + { + "start_ms": 0, + "duration_ms": 3600000, + "evidence": "unknown" + } + ], + "capture_complete": true, + "duration_ms": 3600000 + }, + "segment_bytes": [ + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044 + ] + } + }, + "cases": [ + { + "id": "one-hour-completed-provider-admitted", + "stage": "admission", + "overrides": {}, + "valid": true + }, + { + "id": "one-hour-produces-120-bounded-segments", + "stage": "completion", + "overrides": {}, + "valid": true + }, + { + "id": "five-minute-completed-recording-admitted", + "stage": "admission", + "overrides": { + "request": { + "recording": { + "declared_bytes": 14400044, + "declared_duration_ms": 300000 + } + } + }, + "valid": true + }, + { + "id": "source-recording-byte-budget", + "stage": "admission", + "overrides": { + "limits": { + "recording_bytes": 172800043 + } + }, + "valid": false + }, + { + "id": "source-recording-duration-budget", + "stage": "admission", + "overrides": { + "limits": { + "recording_duration_ms": 3599999 + } + }, + "valid": false + }, + { + "id": "project-bytes-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "bytes": 181188651 + } + } + }, + "valid": false + }, + { + "id": "project-transfers-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "transfers": 0 + } + } + }, + "valid": false + }, + { + "id": "project-recordings-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "recordings": 0 + } + } + }, + "valid": false + }, + { + "id": "project-validation_jobs-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "validation_jobs": 0 + } + } + }, + "valid": false + }, + { + "id": "project-objects-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "objects": 0 + } + } + }, + "valid": false + }, + { + "id": "project-links-budget", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "links": 0 + } + } + }, + "valid": false + }, + { + "id": "organization-bytes-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "bytes": 181188651 + } + } + }, + "valid": false + }, + { + "id": "organization-transfers-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "transfers": 0 + } + } + }, + "valid": false + }, + { + "id": "organization-recordings-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "recordings": 0 + } + } + }, + "valid": false + }, + { + "id": "organization-validation_jobs-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "validation_jobs": 0 + } + } + }, + "valid": false + }, + { + "id": "organization-objects-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "objects": 0 + } + } + }, + "valid": false + }, + { + "id": "organization-links-budget", + "stage": "admission", + "overrides": { + "headroom": { + "organization": { + "links": 0 + } + } + }, + "valid": false + }, + { + "id": "global-bytes-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "bytes": 181188651 + } + } + }, + "valid": false + }, + { + "id": "global-transfers-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "transfers": 0 + } + } + }, + "valid": false + }, + { + "id": "global-recordings-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "recordings": 0 + } + } + }, + "valid": false + }, + { + "id": "global-validation_jobs-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "validation_jobs": 0 + } + } + }, + "valid": false + }, + { + "id": "global-objects-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "objects": 0 + } + } + }, + "valid": false + }, + { + "id": "global-links-budget", + "stage": "admission", + "overrides": { + "headroom": { + "global": { + "links": 0 + } + } + }, + "valid": false + }, + { + "id": "source-alone-fits-but-output-window-does-not", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "bytes": 172800044 + } + } + }, + "valid": false + }, + { + "id": "exact-initial-reservation-fits", + "stage": "admission", + "overrides": { + "headroom": { + "project": { + "bytes": 181188652 + } + } + }, + "valid": true + }, + { + "id": "deny-source-without-terminal_completed", + "stage": "admission", + "overrides": { + "source": { + "terminal_completed": false + } + }, + "valid": false + }, + { + "id": "deny-source-without-immutable", + "stage": "admission", + "overrides": { + "source": { + "immutable": false + } + }, + "valid": false + }, + { + "id": "deny-source-without-bounded_ranges", + "stage": "admission", + "overrides": { + "source": { + "bounded_ranges": false + } + }, + "valid": false + }, + { + "id": "source-length-mismatch--1", + "stage": "completion", + "overrides": { + "observation": { + "source_bytes": 172800043 + } + }, + "valid": false + }, + { + "id": "source-length-mismatch-1", + "stage": "completion", + "overrides": { + "observation": { + "source_bytes": 172800045 + } + }, + "valid": false + }, + { + "id": "actual-duration-mismatch", + "stage": "completion", + "overrides": { + "observation": { + "source_duration_ms": 3600001 + } + }, + "valid": false + }, + { + "id": "source-generation-changed", + "stage": "completion", + "overrides": { + "observation": { + "generation_matches": false + } + }, + "valid": false + }, + { + "id": "range-not-honored-whole-body", + "stage": "completion", + "overrides": { + "observation": { + "reads": [ + { + "offset": 0, + "bytes": 172800044, + "total_bytes": 172800044 + } + ] + } + }, + "valid": false + }, + { + "id": "range-gap", + "stage": "completion", + "overrides": { + "observation": { + "reads": [ + { + "offset": 0, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 8388609, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 16777216, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 25165824, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 33554432, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 41943040, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 50331648, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 58720256, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 67108864, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 75497472, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 83886080, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 92274688, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 100663296, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 109051904, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 117440512, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 125829120, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 134217728, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 142606336, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 150994944, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 159383552, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 167772160, + "bytes": 5027884, + "total_bytes": 172800044 + } + ] + } + }, + "valid": false + }, + { + "id": "range-declared-total-mismatch", + "stage": "completion", + "overrides": { + "observation": { + "reads": [ + { + "offset": 0, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 8388608, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 16777216, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 25165824, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 33554432, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 41943040, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 50331648, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 58720256, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 67108864, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 75497472, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 83886080, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 92274688, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 100663296, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 109051904, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 117440512, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 125829120, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 134217728, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 142606336, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 150994944, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 159383552, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 167772160, + "bytes": 5027884, + "total_bytes": 172800045 + } + ] + } + }, + "valid": false + }, + { + "id": "missing-final-range", + "stage": "completion", + "overrides": { + "observation": { + "reads": [ + { + "offset": 0, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 8388608, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 16777216, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 25165824, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 33554432, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 41943040, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 50331648, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 58720256, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 67108864, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 75497472, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 83886080, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 92274688, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 100663296, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 109051904, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 117440512, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 125829120, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 134217728, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 142606336, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 150994944, + "bytes": 8388608, + "total_bytes": 172800044 + }, + { + "offset": 159383552, + "bytes": 8388608, + "total_bytes": 172800044 + } + ] + } + }, + "valid": false + }, + { + "id": "segment-over-byte-limit", + "stage": "completion", + "overrides": { + "observation": { + "segment_bytes": [ + 8388609, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044 + ] + } + }, + "valid": false + }, + { + "id": "segment-total-over-recording-budget", + "stage": "completion", + "overrides": { + "limits": { + "recording_bytes": 172800044 + } + }, + "valid": false + }, + { + "id": "negotiated-segment-size-enforced", + "stage": "completion", + "overrides": { + "limits": { + "segment_bytes": 1440043 + } + }, + "valid": false + }, + { + "id": "negotiated-upload-size-enforced", + "stage": "completion", + "overrides": { + "limits": { + "max_upload_bytes": 1048576 + } + }, + "valid": false + }, + { + "id": "negotiated-segment-duration-enforced", + "stage": "completion", + "overrides": { + "limits": { + "segment_duration_ms": 29999 + } + }, + "valid": false + }, + { + "id": "missing-segment-size", + "stage": "completion", + "overrides": { + "observation": { + "segment_bytes": [ + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044, + 1440044 + ] + } + }, + "valid": false + }, + { + "id": "segment-over-duration-limit", + "stage": "completion", + "overrides": { + "observation": { + "manifest": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000100-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 30001 + }, + { + "occurrence_id": "00000101-0000-0000-0000-000000000001", + "index": 1, + "start_ms": 30000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000102-0000-0000-0000-000000000001", + "index": 2, + "start_ms": 60000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000103-0000-0000-0000-000000000001", + "index": 3, + "start_ms": 90000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000104-0000-0000-0000-000000000001", + "index": 4, + "start_ms": 120000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000105-0000-0000-0000-000000000001", + "index": 5, + "start_ms": 150000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000106-0000-0000-0000-000000000001", + "index": 6, + "start_ms": 180000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000107-0000-0000-0000-000000000001", + "index": 7, + "start_ms": 210000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000108-0000-0000-0000-000000000001", + "index": 8, + "start_ms": 240000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000109-0000-0000-0000-000000000001", + "index": 9, + "start_ms": 270000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010a-0000-0000-0000-000000000001", + "index": 10, + "start_ms": 300000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010b-0000-0000-0000-000000000001", + "index": 11, + "start_ms": 330000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010c-0000-0000-0000-000000000001", + "index": 12, + "start_ms": 360000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010d-0000-0000-0000-000000000001", + "index": 13, + "start_ms": 390000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010e-0000-0000-0000-000000000001", + "index": 14, + "start_ms": 420000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000010f-0000-0000-0000-000000000001", + "index": 15, + "start_ms": 450000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000110-0000-0000-0000-000000000001", + "index": 16, + "start_ms": 480000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000111-0000-0000-0000-000000000001", + "index": 17, + "start_ms": 510000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000112-0000-0000-0000-000000000001", + "index": 18, + "start_ms": 540000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000113-0000-0000-0000-000000000001", + "index": 19, + "start_ms": 570000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000114-0000-0000-0000-000000000001", + "index": 20, + "start_ms": 600000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000115-0000-0000-0000-000000000001", + "index": 21, + "start_ms": 630000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000116-0000-0000-0000-000000000001", + "index": 22, + "start_ms": 660000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000117-0000-0000-0000-000000000001", + "index": 23, + "start_ms": 690000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000118-0000-0000-0000-000000000001", + "index": 24, + "start_ms": 720000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000119-0000-0000-0000-000000000001", + "index": 25, + "start_ms": 750000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011a-0000-0000-0000-000000000001", + "index": 26, + "start_ms": 780000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011b-0000-0000-0000-000000000001", + "index": 27, + "start_ms": 810000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011c-0000-0000-0000-000000000001", + "index": 28, + "start_ms": 840000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011d-0000-0000-0000-000000000001", + "index": 29, + "start_ms": 870000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011e-0000-0000-0000-000000000001", + "index": 30, + "start_ms": 900000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000011f-0000-0000-0000-000000000001", + "index": 31, + "start_ms": 930000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000120-0000-0000-0000-000000000001", + "index": 32, + "start_ms": 960000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000121-0000-0000-0000-000000000001", + "index": 33, + "start_ms": 990000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000122-0000-0000-0000-000000000001", + "index": 34, + "start_ms": 1020000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000123-0000-0000-0000-000000000001", + "index": 35, + "start_ms": 1050000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000124-0000-0000-0000-000000000001", + "index": 36, + "start_ms": 1080000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000125-0000-0000-0000-000000000001", + "index": 37, + "start_ms": 1110000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000126-0000-0000-0000-000000000001", + "index": 38, + "start_ms": 1140000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000127-0000-0000-0000-000000000001", + "index": 39, + "start_ms": 1170000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000128-0000-0000-0000-000000000001", + "index": 40, + "start_ms": 1200000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000129-0000-0000-0000-000000000001", + "index": 41, + "start_ms": 1230000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012a-0000-0000-0000-000000000001", + "index": 42, + "start_ms": 1260000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012b-0000-0000-0000-000000000001", + "index": 43, + "start_ms": 1290000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012c-0000-0000-0000-000000000001", + "index": 44, + "start_ms": 1320000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012d-0000-0000-0000-000000000001", + "index": 45, + "start_ms": 1350000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012e-0000-0000-0000-000000000001", + "index": 46, + "start_ms": 1380000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000012f-0000-0000-0000-000000000001", + "index": 47, + "start_ms": 1410000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000130-0000-0000-0000-000000000001", + "index": 48, + "start_ms": 1440000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000131-0000-0000-0000-000000000001", + "index": 49, + "start_ms": 1470000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000132-0000-0000-0000-000000000001", + "index": 50, + "start_ms": 1500000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000133-0000-0000-0000-000000000001", + "index": 51, + "start_ms": 1530000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000134-0000-0000-0000-000000000001", + "index": 52, + "start_ms": 1560000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000135-0000-0000-0000-000000000001", + "index": 53, + "start_ms": 1590000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000136-0000-0000-0000-000000000001", + "index": 54, + "start_ms": 1620000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000137-0000-0000-0000-000000000001", + "index": 55, + "start_ms": 1650000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000138-0000-0000-0000-000000000001", + "index": 56, + "start_ms": 1680000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000139-0000-0000-0000-000000000001", + "index": 57, + "start_ms": 1710000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013a-0000-0000-0000-000000000001", + "index": 58, + "start_ms": 1740000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013b-0000-0000-0000-000000000001", + "index": 59, + "start_ms": 1770000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013c-0000-0000-0000-000000000001", + "index": 60, + "start_ms": 1800000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013d-0000-0000-0000-000000000001", + "index": 61, + "start_ms": 1830000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013e-0000-0000-0000-000000000001", + "index": 62, + "start_ms": 1860000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000013f-0000-0000-0000-000000000001", + "index": 63, + "start_ms": 1890000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000140-0000-0000-0000-000000000001", + "index": 64, + "start_ms": 1920000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000141-0000-0000-0000-000000000001", + "index": 65, + "start_ms": 1950000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000142-0000-0000-0000-000000000001", + "index": 66, + "start_ms": 1980000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000143-0000-0000-0000-000000000001", + "index": 67, + "start_ms": 2010000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000144-0000-0000-0000-000000000001", + "index": 68, + "start_ms": 2040000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000145-0000-0000-0000-000000000001", + "index": 69, + "start_ms": 2070000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000146-0000-0000-0000-000000000001", + "index": 70, + "start_ms": 2100000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000147-0000-0000-0000-000000000001", + "index": 71, + "start_ms": 2130000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000148-0000-0000-0000-000000000001", + "index": 72, + "start_ms": 2160000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000149-0000-0000-0000-000000000001", + "index": 73, + "start_ms": 2190000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014a-0000-0000-0000-000000000001", + "index": 74, + "start_ms": 2220000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014b-0000-0000-0000-000000000001", + "index": 75, + "start_ms": 2250000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014c-0000-0000-0000-000000000001", + "index": 76, + "start_ms": 2280000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014d-0000-0000-0000-000000000001", + "index": 77, + "start_ms": 2310000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014e-0000-0000-0000-000000000001", + "index": 78, + "start_ms": 2340000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000014f-0000-0000-0000-000000000001", + "index": 79, + "start_ms": 2370000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000150-0000-0000-0000-000000000001", + "index": 80, + "start_ms": 2400000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000151-0000-0000-0000-000000000001", + "index": 81, + "start_ms": 2430000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000152-0000-0000-0000-000000000001", + "index": 82, + "start_ms": 2460000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000153-0000-0000-0000-000000000001", + "index": 83, + "start_ms": 2490000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000154-0000-0000-0000-000000000001", + "index": 84, + "start_ms": 2520000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000155-0000-0000-0000-000000000001", + "index": 85, + "start_ms": 2550000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000156-0000-0000-0000-000000000001", + "index": 86, + "start_ms": 2580000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000157-0000-0000-0000-000000000001", + "index": 87, + "start_ms": 2610000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000158-0000-0000-0000-000000000001", + "index": 88, + "start_ms": 2640000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000159-0000-0000-0000-000000000001", + "index": 89, + "start_ms": 2670000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015a-0000-0000-0000-000000000001", + "index": 90, + "start_ms": 2700000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015b-0000-0000-0000-000000000001", + "index": 91, + "start_ms": 2730000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015c-0000-0000-0000-000000000001", + "index": 92, + "start_ms": 2760000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015d-0000-0000-0000-000000000001", + "index": 93, + "start_ms": 2790000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015e-0000-0000-0000-000000000001", + "index": 94, + "start_ms": 2820000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000015f-0000-0000-0000-000000000001", + "index": 95, + "start_ms": 2850000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000160-0000-0000-0000-000000000001", + "index": 96, + "start_ms": 2880000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000161-0000-0000-0000-000000000001", + "index": 97, + "start_ms": 2910000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000162-0000-0000-0000-000000000001", + "index": 98, + "start_ms": 2940000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000163-0000-0000-0000-000000000001", + "index": 99, + "start_ms": 2970000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000164-0000-0000-0000-000000000001", + "index": 100, + "start_ms": 3000000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000165-0000-0000-0000-000000000001", + "index": 101, + "start_ms": 3030000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000166-0000-0000-0000-000000000001", + "index": 102, + "start_ms": 3060000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000167-0000-0000-0000-000000000001", + "index": 103, + "start_ms": 3090000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000168-0000-0000-0000-000000000001", + "index": 104, + "start_ms": 3120000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000169-0000-0000-0000-000000000001", + "index": 105, + "start_ms": 3150000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016a-0000-0000-0000-000000000001", + "index": 106, + "start_ms": 3180000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016b-0000-0000-0000-000000000001", + "index": 107, + "start_ms": 3210000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016c-0000-0000-0000-000000000001", + "index": 108, + "start_ms": 3240000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016d-0000-0000-0000-000000000001", + "index": 109, + "start_ms": 3270000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016e-0000-0000-0000-000000000001", + "index": 110, + "start_ms": 3300000, + "duration_ms": 30000 + }, + { + "occurrence_id": "0000016f-0000-0000-0000-000000000001", + "index": 111, + "start_ms": 3330000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000170-0000-0000-0000-000000000001", + "index": 112, + "start_ms": 3360000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000171-0000-0000-0000-000000000001", + "index": 113, + "start_ms": 3390000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000172-0000-0000-0000-000000000001", + "index": 114, + "start_ms": 3420000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000173-0000-0000-0000-000000000001", + "index": 115, + "start_ms": 3450000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000174-0000-0000-0000-000000000001", + "index": 116, + "start_ms": 3480000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000175-0000-0000-0000-000000000001", + "index": 117, + "start_ms": 3510000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000176-0000-0000-0000-000000000001", + "index": 118, + "start_ms": 3540000, + "duration_ms": 30000 + }, + { + "occurrence_id": "00000177-0000-0000-0000-000000000001", + "index": 119, + "start_ms": 3570000, + "duration_ms": 30000 + } + ], + "gaps": [], + "playout": [ + { + "start_ms": 0, + "duration_ms": 3600000, + "evidence": "unknown" + } + ], + "capture_complete": true, + "duration_ms": 3600000 + } + } + }, + "valid": false + }, + { + "id": "wrong-recording", + "stage": "completion", + "overrides": { + "observation": { + "manifest": { + "recording_id": "ffffffff-ffff-ffff-ffff-ffffffffffff" + } + } + }, + "valid": false + }, + { + "id": "not-a-complete-manifest", + "stage": "completion", + "overrides": { + "observation": { + "manifest": { + "capture_complete": false + } + } + }, + "valid": false + }, + { + "id": "mixed-source-cannot-be-relabeled", + "stage": "completion", + "overrides": { + "request": { + "recording": { + "direction": "output" + } + } + }, + "valid": false + } + ] +} diff --git a/python/tests/attachments/f01/wire-fixtures.json b/python/tests/attachments/f01/wire-fixtures.json new file mode 100644 index 000000000..6fd0aa37d --- /dev/null +++ b/python/tests/attachments/f01/wire-fixtures.json @@ -0,0 +1,4166 @@ +{ + "schema_version": 1, + "cases": [ + { + "id": "valid-BootstrapRequest", + "schema": "BootstrapRequest", + "value": { + "schema_versions": [ + 1 + ], + "project_name": "synthetic-voice", + "project_type": "observe", + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001" + }, + "valid": true + }, + { + "id": "valid-BootstrapResponse", + "schema": "BootstrapResponse", + "value": { + "schema_version": 1, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "policy": { + "version": "policy_v1", + "enabled": true, + "allowed_sources": [ + "Bytes", + "OwnedRecordingFile", + "ProviderFile" + ], + "allowed_modalities": [ + "audio" + ], + "require_media_redaction": false, + "require_metadata_removal": false, + "allow_unredacted_media_with_text_pii": false, + "record_audio": false, + "record_video": false + }, + "limits": { + "max_upload_bytes": 52428800, + "segment_bytes": 8388608, + "segment_duration_ms": 30000, + "recording_bytes": 1073741824, + "recording_duration_ms": 7200000, + "active_transfers": 16, + "active_recordings": 4, + "reserved_bytes": 1073741824, + "validation_jobs": 1024, + "initializations_per_minute": 120, + "links_per_minute": 1000, + "upload_bytes_per_second": 1048576, + "playback_bytes_per_second": 1048576, + "transfer_timeout_seconds": 120, + "grant_ttl_seconds": 60, + "revocation_check_seconds": 5 + }, + "expires_at": "2030-01-01T00:10:00Z", + "transfer_modes": [ + "authenticated_stream" + ] + }, + "valid": true + }, + { + "id": "valid-UploadRequest", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044 + }, + "valid": true + }, + { + "id": "valid-UploadResponse", + "schema": "UploadResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "state": "pending_upload", + "reserved_bytes": 48044, + "expires_at": "2030-01-01T00:10:00Z", + "transfer_mode": "authenticated_stream", + "write_capability": "SYNTHETIC_WRITE_CAPABILITY_NOT_A_CREDENTIAL" + }, + "valid": true + }, + { + "id": "valid-CompleteRequest", + "schema": "CompleteRequest", + "value": { + "policy_version": "policy_v1", + "deletion_generation": 0 + }, + "valid": true + }, + { + "id": "valid-StatusResponse", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending" + }, + "valid": true + }, + { + "id": "valid-ImportRequest", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "valid-ImportResponse", + "schema": "ImportResponse", + "value": { + "job_id": "0000000d-0000-0000-0000-000000000001", + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "importing" + }, + "valid": true + }, + { + "id": "valid-LinkRequest", + "schema": "LinkRequest", + "value": { + "source_occurrence_id": "00000007-0000-0000-0000-000000000001", + "source_parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + }, + "target_parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "abcdef0123456789" + }, + "occurrence_id": "0000000e-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0 + }, + "valid": true + }, + { + "id": "valid-Reference", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "valid": true + }, + { + "id": "valid-References", + "schema": "References", + "value": [ + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + } + ], + "valid": true + }, + { + "id": "valid-SpanAttributes", + "schema": "SpanAttributes", + "value": { + "fi.attachment.schema_version": 1, + "fi.attachment.refs": "[{\"attachment_id\":\"00000006-0000-0000-0000-000000000001\",\"occurrence_id\":\"00000007-0000-0000-0000-000000000001\",\"direction\":\"mixed\",\"modality\":\"audio\",\"mime_type\":\"audio/wav\",\"purpose\":\"conversation_recording\"}]", + "fi.attachment.capture_session_id": "00000004-0000-0000-0000-000000000001", + "fi.attachment.correlation_nonce": "00000005-0000-0000-0000-000000000001" + }, + "valid": true + }, + { + "id": "valid-MessageURI", + "schema": "MessageURI", + "value": { + "type": "uri", + "modality": "audio", + "mime_type": "audio/wav", + "uri": "fi-attachment:00000007-0000-0000-0000-000000000001" + }, + "valid": true + }, + { + "id": "valid-Occurrence", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": true + }, + { + "id": "valid-OccurrencePage", + "schema": "OccurrencePage", + "value": { + "items": [ + { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z" + } + ], + "next_cursor": null + }, + "valid": true + }, + { + "id": "valid-ResolveRequest", + "schema": "ResolveRequest", + "value": { + "items": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + }, + "representation": "playable" + } + ] + }, + "valid": true + }, + { + "id": "valid-ResolveResponse", + "schema": "ResolveResponse", + "value": { + "items": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "status": "ready", + "gateway_path": "/tracer/v1/attachment-media/00000007-0000-0000-0000-000000000001/synthetic_grant", + "expires_at": "2030-01-01T00:10:00Z" + }, + { + "occurrence_id": "0000000e-0000-0000-0000-000000000001", + "status": "not_found" + } + ] + }, + "valid": true + }, + { + "id": "valid-WriteCapabilityClaims", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "create", + "upload", + "complete", + "abort", + "status" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": true + }, + { + "id": "valid-PlaybackGrantClaims", + "schema": "PlaybackGrantClaims", + "value": { + "audience": "fi-attachment-playback", + "viewer_id": "0000000f-0000-0000-0000-000000000001", + "application_session_id": "00000010-0000-0000-0000-000000000001", + "media_session_id": "00000011-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "representation": "playable", + "methods": [ + "GET", + "HEAD" + ], + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": true + }, + { + "id": "valid-RecordingManifest", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000 + }, + "valid": true + }, + { + "id": "valid-OperationRegistryEntry", + "schema": "OperationRegistryEntry", + "value": { + "package": "traceai-pipecat", + "language": "python", + "operation": "bound_audio_processor", + "upstream_version": null, + "source_kind": "Bytes", + "direction": "mixed", + "modality": "audio", + "lifecycle": "explicit_session_binding", + "span_capability": "unqualified", + "attachment_capability": "unqualified", + "policy_requirements": [ + "enabled", + "source_authorized", + "pii_intersection" + ], + "component_test_state": "not_run", + "integrated_gate": "integrated_not_run" + }, + "valid": true + }, + { + "id": "valid-Error", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001" + }, + "valid": true + }, + { + "id": "forbidden-Reference-source_url", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-local_path", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-provider_credential", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-object_key", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-content_hash", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-filename", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-speaker_name", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-exif", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Reference-playback_signature", + "schema": "Reference", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording", + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-source_url", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-local_path", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-provider_credential", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-object_key", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-content_hash", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-filename", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-speaker_name", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-exif", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Occurrence-playback_signature", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z", + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-source_url", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-local_path", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-provider_credential", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-object_key", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-content_hash", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-filename", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-speaker_name", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-exif", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-UploadRequest-playback_signature", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 48044, + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-source_url", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-local_path", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-provider_credential", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-object_key", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-content_hash", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-filename", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-speaker_name", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-exif", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-ImportRequest-playback_signature", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-source_url", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-local_path", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-provider_credential", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-object_key", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-content_hash", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-filename", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-speaker_name", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-exif", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-StatusResponse-playback_signature", + "schema": "StatusResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending", + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-source_url", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-local_path", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-provider_credential", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-object_key", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-content_hash", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-filename", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-speaker_name", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-exif", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-RecordingManifest-playback_signature", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000, + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-source_url", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "source_url": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-local_path", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "local_path": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-provider_credential", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "provider_credential": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-object_key", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "object_key": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-content_hash", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "content_hash": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-filename", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "filename": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-speaker_name", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "speaker_name": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-exif", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "exif": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "forbidden-Error-playback_signature", + "schema": "Error", + "value": { + "code": "not_found", + "request_id": "00000013-0000-0000-0000-000000000001", + "playback_signature": "SYNTHETIC_CANARY_DO_NOT_EXPORT" + }, + "valid": false + }, + { + "id": "write-capability-forbids-list", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "list" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "write-capability-forbids-resolve", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "resolve" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "write-capability-forbids-download", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "download" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "write-capability-forbids-delete", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "delete" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "write-capability-forbids-relink", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "relink" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "write-capability-forbids-provider_connection", + "schema": "WriteCapabilityClaims", + "value": { + "audience": "fi-attachment-write", + "actor_id": "0000000f-0000-0000-0000-000000000001", + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "policy_version": "policy_v1", + "deletion_generation": 0, + "reserved_bytes": 48044, + "operations": [ + "provider_connection" + ], + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "reject-null-scope", + "schema": "Scope", + "value": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": null, + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "valid": false + }, + { + "id": "reject-raw-import-url", + "schema": "ImportSource", + "value": { + "kind": "RemoteUrl", + "url": "https://example.invalid/SYNTHETIC_SECRET" + }, + "valid": false + }, + { + "id": "accept-private-envelope-reference", + "schema": "ImportSource", + "value": { + "kind": "RemoteUrlEnvelope", + "envelope_id": "0000000b-0000-0000-0000-000000000001" + }, + "valid": true + }, + { + "id": "forbid-public-playback", + "schema": "ResolveResponse", + "value": { + "items": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "status": "ready", + "gateway_path": "https://example.invalid/audio.wav", + "expires_at": "2030-01-01T00:10:00Z" + } + ] + }, + "valid": false + }, + { + "id": "forbid-provider-query-playback", + "schema": "ResolveResponse", + "value": { + "items": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "status": "ready", + "gateway_path": "/tracer/v1/attachment-media/00000007-0000-0000-0000-000000000001/grant?token=secret", + "expires_at": "2030-01-01T00:10:00Z" + } + ] + }, + "valid": false + }, + { + "id": "forbid-unknown-reference-version", + "schema": "SpanAttributes", + "value": { + "fi.attachment.schema_version": 2, + "fi.attachment.refs": "[{\"attachment_id\":\"00000006-0000-0000-0000-000000000001\",\"occurrence_id\":\"00000007-0000-0000-0000-000000000001\",\"direction\":\"mixed\",\"modality\":\"audio\",\"mime_type\":\"audio/wav\",\"purpose\":\"conversation_recording\"}]", + "fi.attachment.capture_session_id": "00000004-0000-0000-0000-000000000001", + "fi.attachment.correlation_nonce": "00000005-0000-0000-0000-000000000001" + }, + "valid": false + }, + { + "id": "forbid-65-references", + "schema": "References", + "value": [ + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + } + ], + "valid": false + }, + { + "id": "forbid-unbounded-upload", + "schema": "UploadRequest", + "value": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "Bytes", + "declared_bytes": 52428801 + }, + "valid": false + }, + { + "id": "no-capture-badge-without-evidence", + "schema": "OperationRegistryEntry", + "value": { + "package": "traceai-pipecat", + "language": "python", + "operation": "bound_audio_processor", + "upstream_version": null, + "source_kind": "Bytes", + "direction": "mixed", + "modality": "audio", + "lifecycle": "explicit_session_binding", + "span_capability": "unqualified", + "attachment_capability": "capture", + "policy_requirements": [ + "enabled", + "source_authorized", + "pii_intersection" + ], + "component_test_state": "not_run", + "integrated_gate": "integrated_not_run" + }, + "valid": false + }, + { + "id": "complete-without-any-media", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [], + "gaps": [], + "playout": [], + "capture_complete": true, + "duration_ms": 2000 + }, + "valid": false + }, + { + "id": "unmarked-capture-gap", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000 + }, + "valid": false + }, + { + "id": "overlapping-gap-and-media", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 1, + "codec": "pcm", + "container": "wav", + "layout": "mixed", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "mixed", + "role": "mixed" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 500, + "duration_ms": 1500, + "reason": "queue_full" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000 + }, + "valid": false + }, + { + "id": "nested-page-mime-mismatch", + "schema": "OccurrencePage", + "value": { + "items": [ + { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "image/png", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "01234567-89ab-cdef-0123-456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z" + } + ], + "next_cursor": null + }, + "valid": false + }, + { + "id": "response-parent-must-be-canonical", + "schema": "Occurrence", + "value": { + "reference": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + "scope": { + "organization_id": "00000001-0000-0000-0000-000000000001", + "workspace_id": "00000002-0000-0000-0000-000000000001", + "project_id": "00000003-0000-0000-0000-000000000001" + }, + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + }, + "state": "ready", + "binding": "bound", + "capture_complete": false, + "policy_version": "policy_v1", + "deletion_generation": 0, + "expires_at": "2030-01-01T00:10:00Z" + }, + "valid": false + }, + { + "id": "gateway-path-must-match-occurrence", + "schema": "ResolveResponse", + "value": { + "items": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "status": "ready", + "gateway_path": "/tracer/v1/attachment-media/ffffffff-ffff-ffff-ffff-ffffffffffff/synthetic_grant", + "expires_at": "2030-01-01T00:10:00Z" + }, + { + "occurrence_id": "0000000e-0000-0000-0000-000000000001", + "status": "not_found" + } + ] + }, + "valid": false + }, + { + "id": "missing-upload-capability", + "schema": "UploadResponse", + "value": { + "upload_id": "00000008-0000-0000-0000-000000000001", + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "state": "pending_upload", + "reserved_bytes": 48044, + "expires_at": "2030-01-01T00:10:00Z", + "transfer_mode": "authenticated_stream" + }, + "valid": false + }, + { + "id": "safe-attachment-metadata", + "schema": "AttachmentMetadata", + "value": { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "modality": "audio", + "source_kind": "Bytes", + "provider": "pipecat", + "purpose": "conversation_recording", + "policy_version": "policy_v1", + "state": "pending_upload", + "created_at": "2030-01-01T00:00:00Z" + }, + "valid": true + }, + { + "id": "separate-tracks-have-independent-timelines", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 2, + "codec": "pcm", + "container": "wav", + "layout": "separate_tracks", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "output", + "role": "assistant" + }, + { + "track_id": "ffffffff-ffff-ffff-ffff-ffffffffffff", + "channels": [ + 1 + ], + "direction": "input", + "role": "user" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000, + "track_id": "0000000a-0000-0000-0000-000000000001" + }, + { + "occurrence_id": "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee", + "index": 1, + "start_ms": 0, + "duration_ms": 1000, + "track_id": "ffffffff-ffff-ffff-ffff-ffffffffffff" + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full", + "track_id": "0000000a-0000-0000-0000-000000000001" + }, + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full", + "track_id": "ffffffff-ffff-ffff-ffff-ffffffffffff" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000 + }, + "valid": true + }, + { + "id": "separate-track-needs-track-identity", + "schema": "RecordingManifest", + "value": { + "schema_version": 1, + "recording_id": "00000009-0000-0000-0000-000000000001", + "timebase": "session_relative_ms", + "sample_format": "s16le", + "sample_rate_hz": 24000, + "channels": 2, + "codec": "pcm", + "container": "wav", + "layout": "separate_tracks", + "tracks": [ + { + "track_id": "0000000a-0000-0000-0000-000000000001", + "channels": [ + 0 + ], + "direction": "output", + "role": "assistant" + }, + { + "track_id": "ffffffff-ffff-ffff-ffff-ffffffffffff", + "channels": [ + 1 + ], + "direction": "input", + "role": "user" + } + ], + "segments": [ + { + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "index": 0, + "start_ms": 0, + "duration_ms": 1000, + "track_id": "0000000a-0000-0000-0000-000000000001" + }, + { + "occurrence_id": "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee", + "index": 1, + "start_ms": 0, + "duration_ms": 1000 + } + ], + "gaps": [ + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full", + "track_id": "0000000a-0000-0000-0000-000000000001" + }, + { + "start_ms": 1000, + "duration_ms": 1000, + "reason": "queue_full", + "track_id": "ffffffff-ffff-ffff-ffff-ffffffffffff" + } + ], + "playout": [ + { + "start_ms": 0, + "duration_ms": 2000, + "evidence": "unknown" + } + ], + "capture_complete": false, + "duration_ms": 2000 + }, + "valid": false + }, + { + "id": "same-occurrence-with-different-metadata", + "schema": "References", + "value": [ + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "conversation_recording" + }, + { + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "direction": "mixed", + "modality": "audio", + "mime_type": "audio/wav", + "purpose": "turn_recording" + } + ], + "valid": false + }, + { + "id": "completed-provider-recording-over-50-mib", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "valid-RecordingImportRequest", + "schema": "RecordingImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "valid-CompletedRecordingImport", + "schema": "CompletedRecordingImport", + "value": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "valid": true + }, + { + "id": "valid-RecordingImportResponse", + "schema": "RecordingImportResponse", + "value": { + "mode": "completed_recording", + "job_id": "0000000d-0000-0000-0000-000000000001", + "recording_id": "00000009-0000-0000-0000-000000000001", + "state": "importing" + }, + "valid": true + }, + { + "id": "completed-recording-import-response", + "schema": "ImportResponse", + "value": { + "mode": "completed_recording", + "job_id": "0000000d-0000-0000-0000-000000000001", + "recording_id": "00000009-0000-0000-0000-000000000001", + "state": "importing" + }, + "valid": true + }, + { + "id": "valid-ImportStatusResponse", + "schema": "ImportStatusResponse", + "value": { + "job_id": "0000000d-0000-0000-0000-000000000001", + "state": "validating", + "reason": "binding_pending" + }, + "valid": true + }, + { + "id": "completed-five-minute-recording-over-8-mib", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 14400044, + "declared_duration_ms": 300000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "completed-private-envelope-recording", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "RemoteUrl", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "RemoteUrlEnvelope", + "envelope_id": "00000009-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "reject-completed-declared_bytes-1073741825", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 1073741825, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-declared_duration_ms-7200001", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 7200001 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-declared_bytes-0", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 0, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-declared_duration_ms-0", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 0 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-segment_index-0", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000, + "segment_index": 0 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-attachment_id-00000006-0000-0000-0000-000000000001", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000, + "attachment_id": "00000006-0000-0000-0000-000000000001" + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-occurrence_id-00000007-0000-0000-0000-000000000001", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000, + "occurrence_id": "00000007-0000-0000-0000-000000000001" + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-modality-video", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "video", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-source_kind-LocalFile", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "LocalFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-mime_type-image/png", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "image/png", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-completed-source-source_url", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001", + "source_url": "SYNTHETIC_CANARY" + } + }, + "valid": false + }, + { + "id": "reject-completed-source-provider_credential", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001", + "provider_credential": "SYNTHETIC_CANARY" + } + }, + "valid": false + }, + { + "id": "reject-completed-source-filename", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001", + "filename": "SYNTHETIC_CANARY" + } + }, + "valid": false + }, + { + "id": "reject-ambiguous-import-mode", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + }, + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + } + }, + "valid": false + }, + { + "id": "reject-completed-source-kind-mismatch", + "schema": "ImportRequest", + "value": { + "mode": "completed_recording", + "recording": { + "schema_version": 1, + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "direction": "mixed", + "source_kind": "ProviderFile", + "recording_id": "00000009-0000-0000-0000-000000000001", + "modality": "audio", + "declared_bytes": 172800044, + "declared_duration_ms": 3600000 + }, + "source": { + "kind": "RemoteUrlEnvelope", + "envelope_id": "00000009-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-single-import-unchanged-ceiling-8388609", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 8388609, + "recording_id": "00000009-0000-0000-0000-000000000001", + "segment_index": 0 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-single-import-unchanged-ceiling-52428801", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 52428801 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "reject-single-import-unchanged-ceiling-172800044", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 172800044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": false + }, + { + "id": "single-attachment-import-still-supported", + "schema": "ImportRequest", + "value": { + "upload": { + "schema_version": 1, + "attachment_id": "00000006-0000-0000-0000-000000000001", + "occurrence_id": "00000007-0000-0000-0000-000000000001", + "association": { + "capture_session_id": "00000004-0000-0000-0000-000000000001", + "correlation_nonce": "00000005-0000-0000-0000-000000000001", + "parent": { + "trace_id": "0123456789abcdef0123456789abcdef", + "span_id": "0123456789abcdef" + } + }, + "policy_version": "policy_v1", + "deletion_generation": 0, + "mime_type": "audio/wav", + "modality": "audio", + "direction": "mixed", + "source_kind": "ProviderFile", + "declared_bytes": 48044 + }, + "source": { + "kind": "ProviderFile", + "connection_id": "0000000b-0000-0000-0000-000000000001", + "registered_output_id": "0000000c-0000-0000-0000-000000000001" + } + }, + "valid": true + }, + { + "id": "single-attachment-import-response-still-supported", + "schema": "ImportResponse", + "value": { + "job_id": "0000000d-0000-0000-0000-000000000001", + "upload_id": "00000008-0000-0000-0000-000000000001", + "state": "importing" + }, + "valid": true + } + ] +} diff --git a/python/tests/attachments/test_http_contract.py b/python/tests/attachments/test_http_contract.py index d5c7ab778..13302c31a 100644 --- a/python/tests/attachments/test_http_contract.py +++ b/python/tests/attachments/test_http_contract.py @@ -27,7 +27,7 @@ def expiry(seconds=60): def server(tmp_path): key, cert = tmp_path / "synthetic.key", tmp_path / "synthetic.crt" subprocess.run(["openssl", "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", str(key), "-out", str(cert), "-days", "1", "-subj", "/CN=localhost", "-addext", "subjectAltName=DNS:localhost"], check=True, capture_output=True) - state = {"requests": [], "payloads": [], "fail": None, "policy": {}, "expires": 60} + state = {"requests": [], "payloads": [], "fail": None, "policy": {}, "expires": 600} scope = {k: str(uuid.uuid4()) for k in ("organization_id", "workspace_id", "project_id")} class Handler(BaseHTTPRequestHandler): @@ -45,7 +45,7 @@ def respond(self, status, body, headers=None): def do_POST(self): body = json.loads(self.rfile.read(int(self.headers["Content-Length"]))) - state["requests"].append((self.path, body, dict(self.headers))) + state["requests"].append((self.path, body, {k.lower(): v for k, v in self.headers.items()})) if self.path.endswith("attachment-sessions"): self.respond(200, {"schema_version": 1, "scope": scope, "capture_session_id": body["capture_session_id"], "expires_at": expiry(state["expires"]), @@ -72,18 +72,18 @@ def do_POST(self): elif self.path.endswith("/complete"): self.respond(202, {"upload_id": state["upload_id"], "state": "validating", "reason": "binding_pending"}) elif self.path.endswith("/abort"): - self.respond(200, {}) + self.respond(200, {"upload_id": state["upload_id"], "state": "failed", "reason": "incomplete"}) else: self.respond(404, {}) def do_PUT(self): payload = self.rfile.read(int(self.headers["Content-Length"])) - state["requests"].append((self.path, None, dict(self.headers))) + state["requests"].append((self.path, None, {k.lower(): v for k, v in self.headers.items()})) if state["fail"]: self.respond(state["fail"], {"error": "CANARY_BODY_SIGNED_URL"}, {"Location": "https://never-follow.invalid/secret"}) return state["payloads"].append(payload) - self.respond(200, {}) + self.respond(200, {"upload_id": state["upload_id"], "state": "pending_upload", "reason": "binding_pending"}) server = ThreadingHTTPServer(("127.0.0.1", 0), Handler) context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) @@ -135,7 +135,17 @@ def suppressed(connection, *args, **kwargs): init = state["requests"][1][1] assert init["association"]["parent"]["trace_id"] == CONTEXT.trace_uuid assert init["conversation_id"] == "session_1" + assert "role" not in init and "channel" not in init and init["deletion_generation"] == 0 assert len(json.dumps(init)) < 2048 + # T-TR-03: idempotency keys on every F01 route, never on content. + headers = {path.rsplit("/", 1)[-1]: hdrs for path, _, hdrs in state["requests"]} + sid = uuid.UUID(state["requests"][0][1]["capture_session_id"]).hex + assert headers["attachment-sessions"]["idempotency-key"] == "bs-" + sid + "-0" + assert headers["uploads"]["idempotency-key"] == "up-" + uuid.UUID(handle.occurrence_id).hex + assert headers["complete"]["idempotency-key"] == "cp-" + uuid.UUID(state["upload_id"]).hex + assert "idempotency-key" not in headers["content"] + assert all(h["cache-control"] == "no-store" for h in headers.values()) + assert headers["content"]["content-length"] == str(len(raw)) manager.shutdown(1) @@ -167,7 +177,7 @@ def test_expired_bootstrap_has_no_capture(server): state["expires"] = -1 manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) assert not manager.ready(2) - assert manager.status == "expired" + assert manager.status().state == "expired" assert manager.attach(CONTEXT, Bytes(b"secret"), mime_type="audio/wav", direction="mixed").admission == "expired" assert len(state["requests"]) == 1 manager.shutdown(1) @@ -177,3 +187,69 @@ def test_expired_bootstrap_has_no_capture(server): def test_control_endpoint_rejects_unsafe_shapes(endpoint): with pytest.raises(TransferError): HTTPTransport(endpoint, {"authorization": "synthetic"}) + + +@pytest.mark.parametrize("status,body,expected,retry", [ + (400, None, "unsupported_version", False), (401, None, "credential_scope_unsupported", False), + (401, "expired", "expired", False), (403, "redaction_unavailable", "redaction_unavailable", False), + (403, "conflict", "policy_denied", False), (404, None, "not_found", False), + (404, "scope_unresolved", "scope_unresolved", False), (409, None, "conflict", False), + (409, "deleted", "deleted", False), (410, "deleted", "deleted", False), (413, None, "too_large", False), + (429, None, "throttled", True), (408, None, "incomplete", True), (503, "deleted", "incomplete", True), + (418, None, "incomplete", False), +]) +def test_status_reason_table(status, body, expected, retry): + """T-TR-02: one table for every route; Error.code refines only within its class.""" + from fi_instrumentation.attachments.protocol import map_status + + raw = json.dumps({"code": body, "request_id": str(uuid.uuid4())}).encode() if body else b"" + error = map_status(status, raw, "3" if status == 429 else None) + assert (error.reason, error.retryable) == (expected, retry) + if status == 429: + assert error.retry_after == 3 + + +def test_retry_after_caps(): + from fi_instrumentation.attachments.protocol import map_status + + assert map_status(429, b"", "60").retry_after == 5 + assert map_status(429, b"", "Wed, 21 Oct 2015 07:28:00 GMT").retry_after == 1 + assert map_status(429, b"", None).retry_after == 1 + + +def test_strict_json_rejects_duplicates_and_constants(): + """T-TR-06.""" + from fi_instrumentation.attachments.protocol import strict_json + + with pytest.raises(TransferError): + strict_json(b'{"a":1,"a":2}') + with pytest.raises(TransferError): + strict_json(b'{"a":NaN}') + + + +def test_pacer_honours_rate_within_one_slice(): + """T-TR-05: the token bucket paces content slices at upload_bytes_per_second (± one slice).""" + import time + + from fi_instrumentation.attachments.protocol import Pacer + + rate, slice_bytes, total = 512 * 1024, 128 * 1024, 3 * 512 * 1024 + pacer = Pacer(rate) + start = time.monotonic() + for _ in range(total // slice_bytes): + pacer.acquire(slice_bytes, time.monotonic() + 30, lambda: None) + elapsed = time.monotonic() - start + expected = (total - rate) / rate # the bucket starts full + assert expected - slice_bytes / rate <= elapsed <= expected + 1.0 + + +def test_pacer_respects_deadline(): + import time + + from fi_instrumentation.attachments.protocol import Pacer + + pacer = Pacer(1024) + pacer.acquire(1024, time.monotonic() + 5, lambda: None) + with pytest.raises(TransferError): + pacer.acquire(1024, time.monotonic() + 0.1, lambda: None) diff --git a/python/tests/attachments/test_imports.py b/python/tests/attachments/test_imports.py new file mode 100644 index 000000000..805430658 --- /dev/null +++ b/python/tests/attachments/test_imports.py @@ -0,0 +1,132 @@ +"""T-IM: completed-recording import seam (design section 5).""" + +import asyncio +import json +import uuid + +import pytest +from fi_instrumentation.attachments import ( + CompletedRecordingRequest, EnvelopeSource, ProviderFileSource, ResolvedCompletedRecording, UnavailableResolver, +) +from fi_instrumentation.attachments.errors import TransferError +from fi_instrumentation.attachments.protocol import wire_valid + +from conftest import f01 +from test_policy_runtime import CONTEXT + +CONNECTION = "00000000-0000-4000-8000-00000000c001" +OUTPUT = "00000000-0000-4000-8000-00000000c002" +REQUEST = CompletedRecordingRequest("livekit_egress", "EG_synthetic_1") + + +class Resolver: + def __init__(self, result=None, error=None, delay=0): + self.calls, self.result, self.error, self.delay = 0, result, error, delay + + async def resolve(self, request, *, deadline): + self.calls += 1 + if self.delay: + await asyncio.sleep(self.delay) + if self.error: + raise self.error + return self.result + + +def hour(direction="mixed", source=None, size=172800044, duration=3600000): + return ResolvedCompletedRecording(source or ProviderFileSource(CONNECTION, OUTPUT), size, duration, + "audio/wav", direction) + + +def run(manager, resolver, request=REQUEST, timeout=5): + return asyncio.run(manager.import_completed_recording(CONTEXT, request, resolver=resolver, timeout=timeout)) + + +def test_provider_file_import(manager, transport): + """T-IM-01/09: request validates; key im-{rid}; original credentials, never a capability.""" + handle = run(manager, Resolver(hour())) + assert handle.reason == "queued" + assert handle.result(3).status == "importing" and handle.job_id + body, key = transport.imports[0] + assert wire_valid("RecordingImportRequest", body) + assert key == "im-" + uuid.UUID(handle.recording_id).hex + assert body["recording"]["declared_bytes"] == 172800044 and body["source"]["kind"] == "ProviderFile" + assert not [c for k, c in transport.capability_used if k == "import"] + + +def test_f01_completed_import_fixture_shape(manager, transport): + cases = {c["id"]: c for c in f01("recording-import-fixtures.json")["cases"]} + assert "one-hour-completed-provider-admitted" in cases + run(manager, Resolver(hour())).result(3) + body = transport.imports[0][0] + assert set(body) == {"mode", "recording", "source"} + + +def test_denied_preflight_never_resolves(manager): + """T-IM-02.""" + from dataclasses import replace + + manager.update_policy(replace(manager._session.policy, enabled=False)) + resolver = Resolver(hour()) + assert run(manager, resolver).reason == "policy_denied" and resolver.calls == 0 + + +@pytest.mark.parametrize("resolver", [Resolver(error=RuntimeError("CANARY provider secret")), Resolver(hour(), delay=5)]) +def test_resolver_failure_is_source_unavailable(manager, transport, resolver): + """T-IM-03.""" + handle = run(manager, resolver, timeout=0.5) + assert handle.reason == "source_unavailable" and "CANARY" not in repr(handle) + assert not transport.imports + + +@pytest.mark.parametrize("size,duration", [(1073741825, 1000), (1000, 7200001)]) +def test_out_of_range_is_too_large(manager, transport, size, duration): + """T-IM-04.""" + assert run(manager, Resolver(hour(size=size, duration=duration))).reason == "too_large" + assert not transport.imports + + +def test_mixed_cannot_be_narrowed(manager, transport): + """T-IM-05.""" + assert run(manager, Resolver(hour(direction="output"))).reason == "policy_denied" + widened = run(manager, Resolver(hour(direction="mixed")), + CompletedRecordingRequest("livekit_egress", "EG_2", direction="output")) + assert widened.result(3).status == "importing" + assert transport.imports[-1][0]["recording"]["direction"] == "mixed" + + +def test_envelope_source(manager, transport): + """T-IM-06.""" + envelope = "00000000-0000-4000-8000-00000000e001" + handle = run(manager, Resolver(hour(source=EnvelopeSource(envelope)))) + assert handle.result(3).status == "importing" + body = transport.imports[0][0] + assert body["source"] == {"kind": "RemoteUrlEnvelope", "envelope_id": envelope} + assert body["recording"]["source_kind"] == "RemoteUrl" + + +def test_status_is_one_get(manager, transport): + """T-IM-07.""" + handle = run(manager, Resolver(hour())) + handle.result(3) + assert asyncio.run(handle.status()) == ("importing", "binding_pending") + assert transport.statuses == [handle.job_id] + + +def test_no_location_in_body(manager, transport): + """T-IM-08.""" + run(manager, Resolver(hour())).result(3) + raw = json.dumps(transport.imports[0][0]) + for forbidden in ("source_url", "provider_credential", "filename", "http", "/"): + assert forbidden not in raw.replace("audio/wav", "") + + +def test_throttled_after_three_attempts(manager, transport): + """T-IM-10.""" + transport.failures = [TransferError("throttled", True, 1)] * 3 + handle = run(manager, Resolver(hour())) + assert handle.result(10).status == "throttled" + assert len(transport.imports) <= 3 + + +def test_default_resolver_unavailable(manager): + assert run(manager, UnavailableResolver()).reason == "source_unavailable" diff --git a/python/tests/attachments/test_lifecycle.py b/python/tests/attachments/test_lifecycle.py new file mode 100644 index 000000000..4dd580d86 --- /dev/null +++ b/python/tests/attachments/test_lifecycle.py @@ -0,0 +1,163 @@ +"""T-LC: strict no-op when disabled, bounded shutdown, fork safety (design section 8).""" + +import os +import subprocess +import sys +import threading +import time +from pathlib import Path + +import pytest +from fi_instrumentation.attachments import ( + AttachmentConfig, AttachmentManager, Bytes, CompletedRecordingRequest, DisabledAttachmentManager, PcmFormat, + RecordingOptions, ServerPolicy, StreamOptions, TrackSpec, create_attachment_manager, +) +from fi_instrumentation.attachments import manager as manager_module + +from conftest import TransportDouble, make_manager +from test_policy_runtime import CONTEXT + +PROBE = Path(__file__).with_name("exit_probe.py") + + +def run_probe(case, limit): + start = time.monotonic() + env = dict(os.environ, PYTHONPATH=os.pathsep.join(sys.path)) + result = subprocess.run([sys.executable, str(PROBE), case], capture_output=True, timeout=limit, env=env) + elapsed = time.monotonic() - start + assert result.returncode == 0, result.stderr.decode()[-2000:] + assert b"DONE" in result.stdout + assert elapsed < limit + return elapsed + + +@pytest.mark.parametrize("case,limit", [ + ("disabled", 10), ("enabled-idle", 10), ("enabled-blocked", 10), ("enabled-no-shutdown", 10), + ("fork", 15), ("mid-recording", 15), ("import-pending", 10), +]) +def test_process_exit_probes(case, limit): + """T-LC-06..11: separate interpreters exit 0 within W.""" + if case == "fork" and not hasattr(os, "fork"): + pytest.skip("no fork on this platform") + run_probe(case, limit) + + +def test_disabled_factory_is_null_object(monkeypatch): + """T-LC-01/03: no thread, no fork hook, no network; every call immediate.""" + calls = [] + monkeypatch.setattr(os, "register_at_fork", lambda **kw: calls.append(kw)) + before = {t.ident for t in threading.enumerate()} + manager = create_attachment_manager(config=AttachmentConfig(), project_name="synthetic") + assert isinstance(manager, DisabledAttachmentManager) + assert not calls + start = time.monotonic() + assert manager.status().state == "disabled" and manager.status().owned_bytes == 0 + assert manager.ready(5) is False + assert manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=1).reason == "disabled" + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="mixed").result().status == "disabled" + stream = manager.start_attachment_stream(CONTEXT, StreamOptions("audio/wav", "mixed", 10)) + assert stream.reason == "disabled" and stream.try_write(b"x") is False + writer = manager.start_recording(CONTEXT, RecordingOptions(PcmFormat(24000), "mixed", + (TrackSpec((0,), "mixed", "unknown"),), + "observe_consumed")) + assert writer.reason == "disabled" and writer.try_write(b"\x00\x00") is False + assert writer.finish(1).state == "denied" + assert manager.attach_owned_recording(CONTEXT, None, mime_type="audio/wav", direction="mixed").reason == "disabled" + manager.update_policy(ServerPolicy(enabled=True)) + assert manager.status().state == "disabled" # T-LC-05 + assert manager.flush(5) == manager.shutdown(5) + assert (manager.flush(5).unfinished, manager.flush(5).dropped) == (0, 0) + assert time.monotonic() - start < 0.5 + assert {t.ident for t in threading.enumerate()} == before + + +def test_disabled_import_never_calls_resolver(): + import asyncio + + class Resolver: + async def resolve(self, request, *, deadline): + raise AssertionError("resolver called") + + manager = create_attachment_manager(project_name="synthetic") + handle = asyncio.run(manager.import_completed_recording( + CONTEXT, CompletedRecordingRequest("livekit_egress", "EG_1"), resolver=Resolver())) + assert handle.reason == "disabled" + + +def test_env_disable_returns_null_object(monkeypatch): + monkeypatch.setenv("FI_ATTACHMENTS_ENABLED", "false") + manager = create_attachment_manager(config=AttachmentConfig(enabled=True), project_name="synthetic") + assert isinstance(manager, DisabledAttachmentManager) + + +def test_disabled_register_writes_no_span_attributes(): + """T-LC-04.""" + from fi_instrumentation import register + + provider = register(project_name="synthetic", batch=False, set_global_tracer_provider=False, verbose=False) + try: + with provider.get_tracer("t").start_as_current_span("s") as span: + pass + assert not any(key.startswith("fi.attachment.") for key in (span.attributes or {})) + assert isinstance(provider.attachment_manager, DisabledAttachmentManager) + finally: + provider.shutdown() + + +def test_fork_hook_registered_once(monkeypatch): + """T-LC-14: 1000 enabled managers register exactly one fork hook.""" + calls = [] + monkeypatch.setattr(manager_module, "_FORK_HOOK_REGISTERED", False) + monkeypatch.setattr(os, "register_at_fork", lambda **kw: calls.append(kw)) + for _ in range(1000): + AttachmentManager(config=AttachmentConfig(enabled=True), project_name="") + assert len(calls) == 1 + + +def test_workers_start_lazily(transport): + manager = make_manager(transport) + try: + assert not manager._threads + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="mixed").result(2).status == "validating" + assert len(manager._threads) == manager.config.workers + assert all(t.daemon and t.name.startswith("fi-attachment-worker-") for t in manager._threads) + finally: + manager.shutdown(1) + + +def test_shutdown_idempotent_and_concurrent(transport): + """T-LC-15.""" + manager = make_manager(transport) + results = [] + threads = [threading.Thread(target=lambda: results.append(manager.shutdown(1))) for _ in range(2)] + [t.start() for t in threads] + [t.join(5) for t in threads] + assert len(results) == 2 and results[0] == results[1] + assert manager.shutdown(1) == results[0] + + +def test_shutdown_bounded_with_blocked_transport(transport): + """T-LC-16: returns within timeout + 250 ms even while a transfer blocks.""" + transport.release.clear() + transport.block_forever = True + manager = make_manager(transport) + manager.attach(CONTEXT, Bytes(b"x" * 10), mime_type="audio/wav", direction="mixed") + assert transport.entered.wait(2) + start = time.monotonic() + result = manager.shutdown(0.5) + assert time.monotonic() - start < 0.75 + assert result.unfinished >= 1 + + +def test_ready_state_name(transport): + """T-LC-12.""" + manager = make_manager(transport) + try: + assert manager.status().state == "ready" + finally: + manager.shutdown(1) + + +def test_no_untimed_waits(): + source = Path(manager_module.__file__).read_text() + assert ".wait()" not in source diff --git a/python/tests/attachments/test_policy_runtime.py b/python/tests/attachments/test_policy_runtime.py index 22b0e19f7..794cbd96f 100644 --- a/python/tests/attachments/test_policy_runtime.py +++ b/python/tests/attachments/test_policy_runtime.py @@ -26,13 +26,10 @@ def attach(manager, data=b"synthetic-audio", **kwargs): def test_default_no_workers_no_network(monkeypatch): - constructor = Mock(side_effect=AssertionError("network")) - monkeypatch.setattr("fi_instrumentation.attachments.manager.HTTPTransport", constructor) manager = AttachmentManager(project_name="synthetic") assert attach(manager).admission == "disabled" assert manager.owned_bytes == 0 - assert not manager._threads - constructor.assert_not_called() + assert not manager._threads and manager._transport is None and manager._p is None assert manager.shutdown(0).unfinished == 0 @@ -49,7 +46,7 @@ def data(self): assert result.admission in ("policy_denied", "redaction_unavailable") assert not transport.requests and not transport.payloads assert manager.owned_bytes == 0 - assert not manager._jobs + assert manager.status().queued == 0 assert not hasattr(result, "source") @@ -141,10 +138,10 @@ def test_mutable_buffer_is_owned_only_after_admission(manager, transport): def test_unknown_bootstrap_drops_without_retaining(transport): gate = threading.Event() original = transport.bootstrap - transport.bootstrap = lambda *args: (gate.wait(2), original(*args))[1] + transport.bootstrap = lambda *args, **kw: (gate.wait(2), original(*args, **kw))[1] manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) assert attach(manager).admission == "bootstrap_pending" - assert manager.owned_bytes == 0 and not manager._jobs + assert manager.owned_bytes == 0 and manager.status().queued == 0 gate.set() assert manager.ready(2) assert not transport.requests @@ -158,7 +155,7 @@ def test_unqualified_sources_never_retrieve(manager, transport, monkeypatch, sou monkeypatch.setattr("builtins.open", Mock(side_effect=AssertionError("file read"))) result = manager.attach(CONTEXT, source, mime_type="audio/wav", direction="mixed") assert result.admission == "source_unavailable" - assert not transport.requests and not manager._jobs + assert not transport.requests and manager.status().queued == 0 def test_trace_identity_and_ended_span(manager, transport): @@ -202,10 +199,18 @@ def test_queue_and_memory_include_active(manager, transport): assert manager.owned_bytes == 0 -def test_oversize_callback_rejected(manager, transport): - assert attach(manager, bytearray(manager.config.chunk_bytes + 1)).admission == "too_large" - assert attach(manager, b"x" * (manager.config.max_attachment_bytes + 1)).admission == "too_large" - assert not transport.requests +def test_oversize_rejected_before_copy(transport): + """T-PF-15: a mutable buffer above sync_copy_bytes is refused; immutable bytes are not copied.""" + from conftest import make_manager + + manager = make_manager(transport, sync_copy_bytes=1024) + try: + assert attach(manager, bytearray(1025)).admission == "too_large" + assert attach(manager, b"x" * 1025).result(2).status == "validating" + assert attach(manager, b"x" * (manager._limits().max_upload_bytes + 1)).admission == "too_large" + assert len(transport.requests) == 1 + finally: + manager.shutdown(1) def test_policy_tightening_discards_queue_and_does_not_resurrect(manager, transport): @@ -242,11 +247,11 @@ def test_shutdown_deadline_cancel_and_signal_handlers(manager, transport): assert transport.entered.wait(2) start = time.monotonic() result = manager.shutdown(0.02) - assert time.monotonic() - start < 0.2 and result.unfinished == 1 + assert time.monotonic() - start < 0.27 and result.unfinished == 1 assert signal.getsignal(signal.SIGTERM) == handler transport.release.set() assert handle.result(2).status == "incomplete" - assert manager.shutdown(0).unfinished == 0 + assert manager.shutdown(0) == result def test_async_completion_and_flush(manager): @@ -269,22 +274,3 @@ def test_suppressed_capture_has_no_recursion(manager, transport): with suppress_tracing(): assert attach(manager).admission == "policy_denied" assert not transport.requests - - -def test_after_fork_resets_workers_without_parent_replay(manager, transport): - read_fd, write_fd = os.pipe() - pid = os.fork() - if pid == 0: - try: - os.close(read_fd) - ok = manager.owned_bytes == 0 and manager.ready(2) - ok = ok and attach(manager).result(2).status == "validating" - os.write(write_fd, b"ok" if ok else b"failed") - finally: - os._exit(0) - os.close(write_fd) - assert os.read(read_fd, 20) == b"ok" - os.close(read_fd) - _, status = os.waitpid(pid, 0) - assert status == 0 - assert not transport.requests diff --git a/python/tests/attachments/test_preflight.py b/python/tests/attachments/test_preflight.py new file mode 100644 index 000000000..fb1892311 --- /dev/null +++ b/python/tests/attachments/test_preflight.py @@ -0,0 +1,237 @@ +"""T-PF: preflight tickets before any capture or decode (design section 1).""" + +import gc +import threading +import time +from dataclasses import replace +from pathlib import Path + +import pytest +from fi_instrumentation.attachments import ( + AttachmentConfig, AttachmentManager, AttachmentPolicy, Bytes, CapturePolicy, create_attachment_manager, +) +from fi_instrumentation.attachments.policy import decide +from fi_instrumentation.instrumentation.config import TraceConfig + +from conftest import f01, make_manager +from test_policy_runtime import CONTEXT + + +class Spy: + """A Bytes-like source whose data access is counted.""" + + def __init__(self, data=b"spy-bytes"): + self.reads, self._data = 0, data + + @property + def data(self): + self.reads += 1 + return self._data + + +def test_disabled_preflight_never_touches_source(): + """T-PF-01.""" + manager = create_attachment_manager(project_name="synthetic") + spy = Spy() + ticket = manager.preflight(CONTEXT, mime_type="image/png", direction="output", max_bytes=10) + assert ticket.reason == "disabled" and not ticket.admitted and spy.reads == 0 + + +def test_bootstrap_pending_reserves_nothing(transport): + """T-PF-02.""" + gate = threading.Event() + original = transport.bootstrap + transport.bootstrap = lambda *a, **kw: (gate.wait(5), original(*a, **kw))[1] + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + try: + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=100) + assert ticket.reason == "bootstrap_pending" and manager.owned_bytes == 0 + assert manager.status().open_tickets == 0 + finally: + gate.set() + manager.shutdown(1) + + +@pytest.mark.parametrize("case", f01("privacy-fixtures.json")["cases"], ids=lambda c: c["id"]) +def test_privacy_table_fixture(case): + """T-PF-03: every F01 privacy fixture is reproduced by the vendored table evaluator.""" + reason = decide(case["context"]) + expected = case["expected"] + if expected["decision"] == "allow": + assert reason is None + else: + assert reason == expected["reason"] + + +@pytest.mark.parametrize("client,server,admitted", [(False, True, False), (True, False, False), (True, True, True)]) +def test_create_recording_needs_both_flags(transport, client, server, admitted): + """T-PF-04.""" + transport.policy = replace(transport.policy, record_audio=server) + manager = make_manager(transport, record_audio=client) + try: + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=10, + operation="create_recording") + assert ticket.admitted == admitted + if not admitted: + assert ticket.reason == "recording_disabled" + ticket.release() + finally: + manager.shutdown(1) + + +def test_import_is_not_recording(transport): + """T-PF-05.""" + transport.policy = replace(transport.policy, record_audio=False) + manager = make_manager(transport) + try: + ticket = manager.preflight(CONTEXT, mime_type="audio/ogg", direction="mixed", max_bytes=10, + operation="import_existing") + assert ticket.admitted + ticket.release() + finally: + manager.shutdown(1) + + +def test_mixed_with_hidden_inputs_denied(manager): + """T-PF-06.""" + manager.policy = AttachmentPolicy(manager.config, TraceConfig(hide_inputs=True)) + assert manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=1).reason == "policy_denied" + + +def test_screenshot_keeps_input_ancestry(manager): + """T-PF-07.""" + manager.policy = AttachmentPolicy(manager.config, TraceConfig(hide_input_images=True)) + ticket = manager.preflight(CONTEXT, mime_type="image/png", direction="output", max_bytes=1, + purpose="computer_screenshot") + assert ticket.reason == "policy_denied" + allowed = manager.preflight(CONTEXT, mime_type="image/png", direction="output", max_bytes=1, + purpose="model_output") + assert allowed.admitted + allowed.release() + + +def test_descriptor_and_byte_exhaustion(transport): + """T-PF-08.""" + manager = make_manager(transport, max_descriptors=2, max_owned_bytes=1024) + try: + first = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=100) + second = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=100) + assert first.admitted and second.admitted + assert manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=1).reason == "queue_full" + first.release() + assert manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=1000).reason == "queue_full" + second.release() + assert manager.owned_bytes == 0 + finally: + manager.shutdown(1) + + +def test_voice_adapters_use_public_preflight_only(): + """T-PF-10 (static half): the core exposes preflight/status(); no adapter in this tree reads _session.""" + root = Path(__file__).resolve().parents[2] / "frameworks" + offenders = [] + for name in ("pipecat", "livekit"): + for path in (root / name).rglob("*.py") if (root / name).exists() else []: + text = path.read_text(errors="ignore") + if "manager._session" in text or "manager.policy.evaluate" in text: + offenders.append(str(path)) + assert not offenders, offenders + + +def test_ticket_single_use(manager, transport): + """T-PF-11.""" + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=10) + assert ticket.attach(Bytes(b"one")).result(2).status == "validating" + spy = Spy() + assert ticket.attach(spy).admission == "conflict" and spy.reads == 0 + + +def test_ticket_ttl_is_lazy(manager, monkeypatch): + """T-PF-12: no timer; expiry returns budget at the next entry point.""" + timers = [] + monkeypatch.setattr(threading, "Timer", lambda *a, **kw: timers.append(a)) + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=100, ttl=0.05) + assert manager.owned_bytes == 100 + time.sleep(0.1) + assert manager.status().owned_bytes == 0 + assert ticket.attach(Bytes(b"x")).admission == "expired" + assert not timers + + +def test_ticket_gc_returns_budget(manager): + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=100) + assert manager.owned_bytes == 100 + del ticket + gc.collect() + assert manager.owned_bytes == 0 + + +def test_tightening_between_preflight_and_attach(manager, transport): + """T-PF-13.""" + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=10) + manager.update_policy(replace(manager._session.policy, enabled=False)) + spy = Spy() + handle = ticket.attach(spy) + assert handle.admission == "policy_denied" and spy.reads == 0 + assert manager.owned_bytes == 0 and not transport.requests + + +def test_attach_larger_than_ticket(manager, transport): + """T-PF-14.""" + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=4) + assert ticket.attach(Bytes(bytearray(b"12345"))).admission == "too_large" + assert manager.owned_bytes == 0 and not transport.requests + + +def test_reservation_shrinks_to_actual(manager, transport): + transport.release.clear() + ticket = manager.preflight(CONTEXT, mime_type="audio/wav", direction="mixed", max_bytes=1000) + handle = ticket.attach(Bytes(b"abc")) + assert manager.owned_bytes == 3 + transport.release.set() + assert handle.result(2).status == "validating" + + +@pytest.mark.parametrize("mime,modality", [("image/png", "image"), ("application/pdf", "document"), + ("application/octet-stream", "file"), ("video/mp4", "video")]) +def test_modalities_follow_f01_map(manager, transport, mime, modality): + handle = manager.attach(CONTEXT, Bytes(b"payload"), mime_type=mime, direction="output", purpose="model_output") + assert handle.result(2).status == "validating" + assert transport.requests[-1]["modality"] == modality + + +def test_server_modality_gate(transport): + transport.policy = replace(transport.policy, allowed_modalities=frozenset(("audio",))) + manager = make_manager(transport) + try: + assert manager.preflight(CONTEXT, mime_type="image/png", direction="output", max_bytes=1).reason == "policy_denied" + assert manager.preflight(CONTEXT, mime_type="image/gif", direction="output", max_bytes=1).reason == "source_unavailable" + finally: + manager.shutdown(1) + + +def test_image_cap(manager): + assert manager.preflight(CONTEXT, mime_type="image/png", direction="output", + max_bytes=manager._limits().max_upload_bytes + 1).reason == "too_large" + + +def test_pii_redaction_denies_raw_media(manager): + manager.policy = AttachmentPolicy(manager.config, TraceConfig()) + import os + + os.environ["FI_PII_REDACTION"] = "true" + try: + assert manager.preflight(CONTEXT, mime_type="image/png", direction="output", + max_bytes=1).reason == "redaction_unavailable" + finally: + del os.environ["FI_PII_REDACTION"] + + +def test_capture_policy_new_recording_alias(transport): + transport.policy = replace(transport.policy, record_audio=True) + manager = make_manager(transport) + try: + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="mixed", + capture_policy=CapturePolicy(new_recording=True)).admission == "recording_disabled" + finally: + manager.shutdown(1) diff --git a/python/tests/attachments/test_recording.py b/python/tests/attachments/test_recording.py new file mode 100644 index 000000000..298ff3abf --- /dev/null +++ b/python/tests/attachments/test_recording.py @@ -0,0 +1,407 @@ +"""T-ST: live PCM recordings, segments, gaps and manifests (design section 2).""" + +import json +import struct +import threading +import time +import uuid +from dataclasses import replace + +import pytest +from fi_instrumentation.attachments import ( + AttachmentConfig, AttachmentManager, PcmFormat, RecordingOptions, TrackSpec, +) +from fi_instrumentation.attachments.errors import TransferError +from fi_instrumentation.attachments.protocol import Limits, validate_manifest, wire_valid +from fi_instrumentation.attachments.recording import segment_frames, to_ms +from opentelemetry.sdk.trace import TracerProvider + +from conftest import TransportDouble, make_manager +from test_policy_runtime import CONTEXT + +MONO = (TrackSpec((0,), "mixed", "unknown"),) + + +def options(rate=24000, layout="mixed", tracks=MONO, **kw): + # Tests feed audio faster than real time; a 4-segment window keeps the + # transport double from turning that speed into queue_full gaps. + kw.setdefault("window_segments", 4) + return RecordingOptions(PcmFormat(rate), layout, tracks, kw.pop("operation", "observe_consumed"), **kw) + + +def pcm(frames, channels=1, value=1): + return struct.pack("= 5: + writer.try_write(pcm(24000), track=1) + result = writer.finish(10) + manifest = last_manifest(transport) + assert result.state == "partial" + ids = [t["track_id"] for t in manifest["tracks"]] + assert all(s["track_id"] in ids for s in manifest["segments"]) + assert all(g["track_id"] in ids for g in manifest["gaps"]) + assert any(g["track_id"] == ids[1] and g["reason"] == "source_unavailable" for g in manifest["gaps"]) + assert {r["direction"] for r in transport.requests} == {"input", "output"} + + +def test_track_identity_rules(manager, transport): + """T-ST-07/08: mixed/stereo never carry track_id; channel mapping is checked locally.""" + tracks = (TrackSpec((0,), "input", "user"), TrackSpec((1,), "output", "assistant")) + writer = manager.start_recording(CONTEXT, options(layout="stereo", tracks=tracks)) + feed(writer, 24000, channels=2, step=4800) + writer.finish(5) + manifest = last_manifest(transport) + assert manifest["channels"] == 2 and [t["channels"] for t in manifest["tracks"]] == [[0], [1]] + assert all("track_id" not in s for s in manifest["segments"] + manifest["gaps"]) + broken = json.loads(json.dumps(manifest)) + broken["tracks"][1]["channels"] = [0] + with pytest.raises(TransferError): + validate_manifest(broken) + broken = json.loads(json.dumps(manifest)) + broken["segments"][0]["track_id"] = str(uuid.uuid4()) + with pytest.raises(TransferError): + validate_manifest(broken) + + +def test_budget_exhaustion_records_exact_gap(transport): + """T-ST-09.""" + manager = make_manager(transport, max_owned_bytes=24000 * 2) + try: + transport.release.clear() + writer = manager.start_recording(CONTEXT, options()) + assert writer.try_write(pcm(24000)) # exactly the budget + assert writer.try_write(pcm(2400)) is False # 100 ms rejected + transport.release.set() + result = writer.finish(5) + manifest = last_manifest(transport) if transport.manifests else None + assert result.state in ("partial", "unpublished") + if manifest: + assert {"start_ms": 1000, "duration_ms": 100, "reason": "queue_full"} in manifest["gaps"] + finally: + transport.release.set() + manager.shutdown(1) + + +def test_window_full_with_blocked_transport(transport): + """T-ST-10.""" + transport.release.clear() + limits = Limits(segment_duration_ms=1000) + transport.limits = limits + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options(window_segments=2)) + accepted = [writer.try_write(pcm(24000)) for _ in range(6)] + assert accepted[:2] == [True, True] and not all(accepted) + assert writer.status().segments_pending <= 2 + 1 + transport.release.set() + writer.finish(5) + assert any(g["reason"] == "queue_full" for g in last_manifest(transport)["gaps"]) + finally: + transport.release.set() + manager.shutdown(1) + + +def test_bootstrap_pending_then_ready(transport): + """T-ST-11.""" + gate = threading.Event() + original = transport.bootstrap + transport.bootstrap = lambda *a, **kw: (gate.wait(5), original(*a, **kw))[1] + manager = AttachmentManager(config=AttachmentConfig(enabled=True), project_name="synthetic", transport=transport) + try: + writer = manager.start_recording(CONTEXT, options()) + assert writer.reason == "queued" and writer.status().state == "pending" + assert writer.try_write(pcm(2400)) is False + assert manager.owned_bytes == 0 + gate.set() + assert manager.ready(5) + assert writer.try_write(pcm(24000)) + writer.finish(5) + manifest = last_manifest(transport) + assert manifest["gaps"][0] == {"start_ms": 0, "duration_ms": 100, "reason": "bootstrap_pending"} + assert manifest["segments"][0]["start_ms"] == 100 + finally: + gate.set() + manager.shutdown(1) + + +def test_policy_tightened_mid_recording(manager, transport): + """T-ST-12.""" + writer = manager.start_recording(CONTEXT, options()) + transport.limits = manager._limits() + feed(writer, 24000 * 31, step=24000) + manager.update_policy(replace(manager._session.policy, enabled=False)) + assert writer.try_write(pcm(2400)) is False + assert manager.status().owned_bytes == 0 or writer.status().state == "terminal" + writer.finish(5) + if transport.manifests: + assert last_manifest(transport)["gaps"][-1]["reason"] == "policy_denied" + + +def test_recording_duration_cap(transport): + """T-ST-13.""" + transport.limits = Limits(recording_duration_ms=60000) + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000 * 61, step=24000) + result = writer.finish(15) + manifest = last_manifest(transport) + assert not manifest["capture_complete"] and manifest["gaps"][-1]["reason"] == "truncated" + assert result.state == "partial" + finally: + manager.shutdown(1) + + +def test_segment_failure_reuses_index(short): + manager, transport = short + """T-ST-14.""" + writer = manager.start_recording(CONTEXT, options()) + transport.failures = [TransferError("incomplete", True)] * 3 + feed(writer, 24000 * 3, step=24000) + result = writer.finish(10) + manifest = last_manifest(transport) + assert transport.aborts, "abort not called" + assert [r["segment_index"] for r in transport.requests] == [0, 0, 1] + assert {"start_ms": 0, "duration_ms": 1000, "reason": "incomplete"} in manifest["gaps"] + assert result.state == "partial" + + +def test_reused_index_conflict_closes_partial(short): + manager, transport = short + writer = manager.start_recording(CONTEXT, options()) + transport.failures = [TransferError("incomplete", True)] * 3 + [] + feed(writer, 24000, step=24000) + deadline = time.monotonic() + 5 + while not transport.aborts and time.monotonic() < deadline: + time.sleep(0.01) + transport.init_failures = [TransferError("conflict", http_status=409)] + feed(writer, 24000 * 2, step=24000) + result = writer.finish(5) + assert result.state in ("partial", "unpublished") + + +def test_manifests_are_prefix_monotonic(short): + manager, transport = short + """T-ST-15.""" + writer = manager.start_recording(CONTEXT, options()) + for _ in range(45): + writer.try_write(pcm(24000)) + time.sleep(0.005) + writer.finish(15) + bodies = [m[1] for m in transport.manifests] + keys = [m[2] for m in transport.manifests] + assert len(bodies) >= 3 + for earlier, later in zip(bodies, bodies[1:]): + assert later["segments"][:len(earlier["segments"])] == earlier["segments"] + assert later["duration_ms"] >= earlier["duration_ms"] + hexid = uuid.UUID(writer.recording_id).hex + revs = [int(k.rsplit("-", 1)[1]) for k in keys] + assert all(k.startswith("mf-" + hexid + "-") for k in keys) and revs == sorted(set(revs)) + + +def test_manifest_uses_latest_completed_capability(manager, transport): + """T-ST-16.""" + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000 * 31, step=24000) + writer.finish(10) + content_caps = [cap for kind, cap in transport.capability_used if kind == "complete"] + manifest_caps = [cap for kind, cap in transport.capability_used if kind == "manifest"] + assert manifest_caps[-1] == content_caps[-1] + assert all(cap.startswith("cap_") for cap in manifest_caps) + + +def test_capture_complete_requires_no_gaps(manager, transport): + """T-ST-17.""" + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000, step=2400) + writer.mark_gap(500) + feed(writer, 2400) + writer.finish(5) + manifest = last_manifest(transport) + assert manifest["gaps"] and not manifest["capture_complete"] + forged = dict(manifest, capture_complete=True) + with pytest.raises(TransferError): + validate_manifest(forged) + + +def test_try_write_never_does_io(manager, transport): + """T-ST-18: no transport call on the caller thread.""" + transport.release.clear() + writer = manager.start_recording(CONTEXT, options()) + caller = threading.current_thread().name + started = time.perf_counter() + for _ in range(2000): + writer.try_write(pcm(480)) + elapsed = time.perf_counter() - started + assert caller not in transport.content_thread + print("try_write mean us", elapsed / 2000 * 1e6) + transport.release.set() + writer.abort() + + +def test_finish_bounded_with_blocked_transport(transport): + """T-ST-19.""" + transport.release.clear() + transport.block_forever = True + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000, step=4800) + start = time.monotonic() + result = writer.finish(1) + assert time.monotonic() - start <= 1.25 + assert result.state in ("partial", "unpublished") + finally: + transport.block_forever = False + transport.release.set() + manager.shutdown(1) + + +def test_no_segment_references_and_live_stamp(manager, transport): + """T-ST-20.""" + provider = TracerProvider(shutdown_on_exit=False) + span = provider.get_tracer("t").start_span("root") + writer = manager.start_recording(span, options()) + feed(writer, 24000, step=4800) + writer.finish(5) + attributes = dict(span.attributes) + assert attributes["fi.attachment.refs"] == "[]" and attributes["fi.attachment.schema_version"] == 1 + assert attributes["fi.attachment.capture_session_id"] == manager.capture_session_id + assert wire_valid("SpanAttributes", {k: v for k, v in attributes.items() if k.startswith("fi.attachment.")}) + span.end() + provider.shutdown() + + +def test_abort_is_synchronous_and_uploads_no_manifest(manager, transport): + transport.release.clear() + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000, step=4800) + start = time.monotonic() + writer.abort() + assert time.monotonic() - start < 0.1 + transport.release.set() + assert writer.finish(1).state == "unpublished" + assert not transport.manifests + + +def test_create_recording_requires_both_flags(transport): + transport.policy = replace(transport.policy, record_audio=True) + manager = make_manager(transport) + try: + assert manager.start_recording(CONTEXT, options(operation="create_recording")).reason == "recording_disabled" + finally: + manager.shutdown(1) + + +def test_partial_frames_carry(manager, transport): + writer = manager.start_recording(CONTEXT, options()) + data = pcm(1000) + assert writer.try_write(data[:3]) and writer.try_write(data[3:]) + writer.finish(5) + assert len(transport.payloads[0]) == 44 + 2000 diff --git a/python/tests/attachments/test_renewal.py b/python/tests/attachments/test_renewal.py new file mode 100644 index 000000000..847308282 --- /dev/null +++ b/python/tests/attachments/test_renewal.py @@ -0,0 +1,140 @@ +"""T-RN: session and upload-capability renewal (design section 3).""" + +import json +import logging +import time +import uuid +from dataclasses import replace + +from fi_instrumentation.attachments import Bytes, PcmFormat, RecordingOptions, TrackSpec +from fi_instrumentation.attachments.errors import TransferError +from fi_instrumentation.attachments.protocol import Upload + +from conftest import TransportDouble, make_manager +from test_policy_runtime import CONTEXT + + +def wait_for(predicate, limit=5.0): + deadline = time.monotonic() + limit + while time.monotonic() < deadline: + if predicate(): + return True + time.sleep(0.01) + return False + + +def test_session_renewal_keeps_ids(transport): + """T-RN-01.""" + transport.session_ttl = 30 # inside the 60 s renewal window + manager = make_manager(transport) + try: + sid, nonce = manager.capture_session_id, manager.correlation_nonce + transport.session_ttl = 600 # the renewed session gets a fresh lifetime + manager.status() # lazy activity schedules renewal + assert wait_for(lambda: transport.session_renewals) + assert transport.session_renewals[0] == 1 + assert wait_for(lambda: manager._session.expires_at > time.time() + 100) + assert (manager.capture_session_id, manager.correlation_nonce) == (sid, nonce) + body = json.loads(manager._session.request) + assert body["capture_session_id"] == sid and body["correlation_nonce"] == nonce + finally: + manager.shutdown(1) + + +def test_renewal_scope_change_invalidates(transport): + """T-RN-02.""" + transport.session_ttl = 30 + transport.renew_scope = "00000000-0000-4000-8000-0000000000ff" + manager = make_manager(transport) + try: + manager.status() + assert wait_for(lambda: manager.status().state == "scope_unresolved") + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="mixed").admission == "scope_unresolved" + finally: + manager.shutdown(1) + + +def test_renewal_tighter_policy_drops_queued(transport): + """T-RN-03.""" + transport.session_ttl = 30 + transport.release.clear() + manager = make_manager(transport) + try: + first = manager.attach(CONTEXT, Bytes(b"one"), mime_type="audio/wav", direction="mixed") + assert transport.entered.wait(2) + transport.renew_policy = replace(transport.policy, enabled=False, version="v2") + manager.status() + assert wait_for(lambda: manager.status() and manager._session.policy.version == "v2") + transport.release.set() + assert first.result(3).status == "policy_denied" + assert manager.owned_bytes == 0 + finally: + transport.release.set() + manager.shutdown(1) + + +def test_renewal_failure_expires_without_new_session(transport): + """T-RN-04.""" + transport.session_ttl = 6 # expiring within the 5 s skew margin after ~1 s + transport.renew_result = "fail" + manager = make_manager(transport) + try: + sid = manager.capture_session_id + assert wait_for(lambda: manager.status().state == "expired", 5) + assert manager.attach(CONTEXT, Bytes(b"x"), mime_type="audio/wav", direction="mixed").admission == "expired" + assert manager.capture_session_id == sid and transport.bootstraps == 1 + finally: + manager.shutdown(1) + + +def test_capability_renewed_before_use(manager, transport): + """T-RN-05: an expiring capability is replayed with the byte-identical init body.""" + original = transport.initialize + + def short(session, body, **kw): + upload = original(session, body, **kw) + return Upload(upload.upload_id, time.time() + 1, upload.capability, upload.reserved_bytes) + transport.initialize = short + handle = manager.attach(CONTEXT, Bytes(b"payload"), mime_type="audio/wav", direction="mixed") + assert handle.result(3).status == "validating" + assert transport.renewals and transport.renewals[0] == json.dumps(transport.requests[0], separators=(",", ":")).encode() + caps = {cap for kind, cap in transport.capability_used} + assert len(caps) == 1 # only the fresh capability was used + key = [k for k in transport.keys if k.startswith("up-")][0] + assert key == "up-" + uuid.UUID(handle.occurrence_id).hex + + +def test_stale_capability_on_replay_expires(manager, transport): + """T-RN-06.""" + transport.renew_result = "same" + transport.failures = [TransferError("credential_scope_unsupported", http_status=401)] + handle = manager.attach(CONTEXT, Bytes(b"payload"), mime_type="audio/wav", direction="mixed") + assert handle.result(3).status == "expired" + assert transport.aborts and len(transport.requests) == 1 + + +def test_401_renews_once(manager, transport): + """T-RN-07.""" + transport.failures = [TransferError("credential_scope_unsupported", http_status=401)] + assert manager.attach(CONTEXT, Bytes(b"a"), mime_type="audio/wav", direction="mixed").result(3).status == "validating" + transport.failures = [TransferError("credential_scope_unsupported", http_status=401)] * 2 + assert manager.attach(CONTEXT, Bytes(b"b"), mime_type="audio/wav", + direction="mixed").result(3).status == "credential_scope_unsupported" + + +def test_capability_never_leaks(manager, transport, caplog): + """T-RN-08: canary scan of logs, reprs, status and span attributes.""" + caplog.set_level(logging.DEBUG) + handle = manager.attach(CONTEXT, Bytes(b"payload"), mime_type="audio/wav", direction="mixed") + assert handle.result(3).status == "validating" + writer = manager.start_recording(CONTEXT, RecordingOptions(PcmFormat(24000), "mixed", + (TrackSpec((0,), "mixed", "unknown"),), + "observe_consumed")) + writer.try_write(b"\x00\x00" * 24000) + writer.finish(5) + surfaces = caplog.text + repr(handle) + repr(manager.status()) + repr(writer) + repr(writer.status()) + surfaces += repr(manager._session) + for _, cap in transport.capability_used: + assert cap not in surfaces + for upload in transport.uploads.values(): + assert upload.capability not in repr(upload) diff --git a/python/tests/attachments/test_sources.py b/python/tests/attachments/test_sources.py index 076c65761..97694f206 100644 --- a/python/tests/attachments/test_sources.py +++ b/python/tests/attachments/test_sources.py @@ -90,3 +90,193 @@ def test_directory_symlink_and_implicit_permission_rejected(tmp_path): RecordingFileScope(str(link), enabled=True) with pytest.raises(ValueError): RecordingFileScope(str(target)) + + +# ---- T-LS: owned-recording tiers and leases (design section 4) ---- +import hashlib +import struct +import time + +from fi_instrumentation.attachments import FileIdentity, TrackSpec +from fi_instrumentation.attachments.protocol import Limits, wire_valid +from fi_instrumentation.attachments.sources import parse_wav, wav_header + +from conftest import TransportDouble, make_manager + +MiB = 1024 * 1024 + + +def big_manager(**limits): + transport = TransportDouble(limits=Limits(max_upload_bytes=50 * MiB, **limits)) + return transport, make_manager(transport) + + +def write_wav(path, channels, rate, frames, pattern=b"\x01\x02"): + with open(path, "wb") as handle: + handle.write(wav_header(channels, rate, frames)) + chunk = pattern * channels * 65536 + remaining = frames * channels * 2 + while remaining: + part = chunk[:min(len(chunk), remaining)] + handle.write(part) + remaining -= len(part) + + +def test_identify_uses_opened_file(tmp_path): + scope, _, path = make_source(tmp_path) + try: + identity = scope.identify(path.name) + info = path.stat() + assert identity == FileIdentity(info.st_dev, info.st_ino, info.st_size) + finally: + scope.close() + + +def test_symlinked_intermediate_directory(tmp_path): + """T-LS-03.""" + real = tmp_path / "real" + real.mkdir() + (real / "a.wav").write_bytes(b"x") + (tmp_path / "link").symlink_to(real, target_is_directory=True) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + with pytest.raises(TransferError): + scope.identify("link/a.wav") + finally: + scope.close() + + +def test_modified_during_transfer(tmp_path): + """T-LS-01.""" + transport, manager = big_manager() + path = tmp_path / "r.ogg" + path.write_bytes(b"o" * (600 * 1024)) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + original = transport.put_content + + def mutate(session, upload, source, **kw): + with open(path, "ab") as handle: + handle.write(b"tamper") + return original(session, upload, source, **kw) + transport.put_content = mutate + source = scope.source(path.name, scope.identify(path.name)) + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/ogg", direction="mixed") + assert handle.tier == "single" and handle.result(3).status == "source_unavailable" + assert transport.aborts + finally: + scope.close() + manager.shutdown(1) + + +def test_single_tier_streams_from_lease(tmp_path): + """T-LS-06: 12 MiB OGG uploads directly from the file within one slice of owned memory.""" + transport, manager = big_manager() + path = tmp_path / "r.ogg" + path.write_bytes(b"\x4f" * (12 * MiB)) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + source = scope.source(path.name, scope.identify(path.name)) + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/ogg", direction="mixed") + assert handle.tier == "single" + assert manager.owned_bytes <= manager.config.chunk_bytes + assert handle.result(10).status == "validating" + assert len(transport.payloads[0]) == 12 * MiB + assert "recording_id" not in transport.requests[0] + finally: + scope.close() + manager.shutdown(1) + + +def test_encoded_over_cap_too_large(tmp_path, monkeypatch): + """T-LS-07: 70 MiB OGG is refused with zero bytes read.""" + transport, manager = big_manager() + path = tmp_path / "big.ogg" + with open(path, "wb") as handle: + handle.truncate(70 * MiB) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + source = scope.source(path.name, scope.identify(path.name)) + monkeypatch.setattr(scope, "_open", lambda s: pytest.fail("opened")) + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/ogg", direction="mixed") + assert (handle.tier, handle.reason) == ("denied", "too_large") + finally: + scope.close() + manager.shutdown(1) + + +def test_large_wav_becomes_segmented_recording(tmp_path): + """T-LS-08: >50 MiB 24 kHz stereo WAV with roles -> stereo manifest from lease ranges.""" + transport, manager = big_manager() + frames = (52 * MiB) // 4 + path = tmp_path / "call.wav" + write_wav(path, 2, 24000, frames) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + source = scope.source(path.name, scope.identify(path.name)) + tracks = (TrackSpec((0,), "input", "user"), TrackSpec((1,), "output", "assistant")) + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/wav", direction="mixed", + wav_tracks=tracks) + assert handle.tier == "wav_recording" and handle.recording_id + assert manager.owned_bytes <= manager.config.chunk_bytes + assert handle.result(60).status == "validating" + manifest = transport.manifests[-1][1] + assert wire_valid("RecordingManifest", manifest) and manifest["layout"] == "stereo" + assert [t["role"] for t in manifest["tracks"]] == ["user", "assistant"] and manifest["capture_complete"] + data = path.read_bytes()[44:] + decoded = b"".join(p[44:] for p in transport.payloads) + assert hashlib.sha256(decoded).digest() == hashlib.sha256(data).digest() + assert all(len(p) <= 8 * MiB for p in transport.payloads) + assert all(r["recording_id"] == handle.recording_id for r in transport.requests) + finally: + scope.close() + manager.shutdown(1) + + +@pytest.mark.parametrize("kind", ["bad-length", "float", "24-bit"]) +def test_unsupported_wav_falls_back(tmp_path, kind): + """T-LS-09: tier single when within the cap; refused above it.""" + transport, manager = big_manager() + header = bytearray(wav_header(1, 16000, 1000)) + if kind == "bad-length": + struct.pack_into(" None: def attachment_status() -> dict: """Content-free setup status, never an integrated recording-ready claim.""" manager = getattr(_tracer_provider, "attachment_manager", None) - return {"runtime": manager.status if manager is not None else "uninitialized", + return {"runtime": manager.status().state if manager is not None else "uninitialized", "adapters": dict(_adapter_status)} diff --git a/python/traceai/tests/test_attachments.py b/python/traceai/tests/test_attachments.py index 4211f3f74..864355abe 100644 --- a/python/traceai/tests/test_attachments.py +++ b/python/traceai/tests/test_attachments.py @@ -7,7 +7,7 @@ def test_provider_policy_manager_propagation_and_idempotence(monkeypatch): - manager = SimpleNamespace(policy=object(), status="disabled") + manager = SimpleNamespace(policy=object(), status=lambda: SimpleNamespace(state="disabled")) config = TraceConfig(hide_inputs=True) provider = SimpleNamespace(attachment_manager=manager, trace_config=config) register = Mock(return_value=provider) @@ -35,7 +35,7 @@ def test_voice_registration_does_not_claim_recording_or_mutate_global_provider(m def test_explicit_session_binding_uses_shared_manager_without_recording_permission(monkeypatch): - manager = SimpleNamespace(status="ready") + manager = SimpleNamespace(status=lambda: SimpleNamespace(state="ready")) monkeypatch.setattr(traceai, "_tracer_provider", SimpleNamespace(attachment_manager=manager)) binder = Mock(return_value=object()) monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=SimpleNamespace(bind_session=binder))) @@ -48,10 +48,26 @@ def test_explicit_session_binding_uses_shared_manager_without_recording_permissi def test_old_optional_adapter_reports_unsupported_without_exception_body(monkeypatch, capsys): - monkeypatch.setattr(traceai, "_tracer_provider", SimpleNamespace(attachment_manager=SimpleNamespace(status="ready"))) + monkeypatch.setattr(traceai, "_tracer_provider", SimpleNamespace(attachment_manager=SimpleNamespace(status=lambda: SimpleNamespace(state="ready")))) monkeypatch.setattr(traceai.importlib, "import_module", Mock(return_value=SimpleNamespace())) assert traceai.bind_pipecat_audio_processor(object(), object()) is None assert traceai.attachment_status()["adapters"]["pipecat"] == "unsupported_version" monkeypatch.setattr(traceai.importlib, "import_module", Mock(side_effect=RuntimeError("SYNTHETIC_SECRET"))) assert not traceai._instrument_library("openai") assert "SYNTHETIC_SECRET" not in capsys.readouterr().out + + +def test_disabled_init_is_strict_noop(monkeypatch): + """Auto module: attachments OFF by default; the null object is shared, nothing starts.""" + import threading + + from fi_instrumentation.attachments import DisabledAttachmentManager + + before = {t.ident for t in threading.enumerate()} + provider = traceai.init(project_name="synthetic", project_type="observe", verbose=False, set_global_tracer_provider=False) + try: + assert isinstance(provider.attachment_manager, DisabledAttachmentManager) + assert traceai.attachment_status()["runtime"] == "disabled" + assert {t.ident for t in threading.enumerate()} == before + finally: + provider.shutdown() From 7b03f8d32f568e25d2ed67ed7edab0809dfee6fd Mon Sep 17 00:00:00 2001 From: Nikhil Pareek Date: Tue, 10 Nov 2026 22:56:35 -0800 Subject: [PATCH 3/4] fix(python): settle a recording segment before scheduling the next one The worker released a recording lane before the writer recorded the segment's result, so the next segment could read a stale index and finish() could build the final manifest early. The lane now stays busy until the writer callback has run. Co-Authored-By: Claude Opus 5.5 --- python/fi_instrumentation/attachments/manager.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/python/fi_instrumentation/attachments/manager.py b/python/fi_instrumentation/attachments/manager.py index 54ff94284..9327ab9c3 100644 --- a/python/fi_instrumentation/attachments/manager.py +++ b/python/fi_instrumentation/attachments/manager.py @@ -1056,9 +1056,6 @@ def _worker(self) -> None: self._inflight.discard(job) if job.handle is not None: self._running.pop(id(job.handle), None) - if job.lane is not None: - job.lane.busy = False - self._active_jobs.pop(id(job.lane), None) self._finish_job(job, status) def _finish_job(self, job: _Job, status: str, notify_lane: bool = True) -> None: @@ -1071,8 +1068,6 @@ def _finish_job(self, job: _Job, status: str, notify_lane: bool = True) -> None: if status not in ("validating", "importing"): self._dropped += 1 job.payload = None - if notify_lane and job.lane is not None: - self._schedule_lane(job.lane) self._cond.notify_all() if job.kind == "segment": job.lane.writer._segment_done(job.entry, status, job.upload if status == "validating" else None, @@ -1088,6 +1083,14 @@ def _finish_job(self, job: _Job, status: str, notify_lane: bool = True) -> None: else: job.handle._finish(status) job.upload = None + if notify_lane and job.lane is not None: + # The lane stays busy until the writer has recorded this result, so the + # next segment reads the right index and finish() never sees a gap. + with self._cond: + job.lane.busy = False + self._active_jobs.pop(id(job.lane), None) + self._schedule_lane(job.lane) + self._cond.notify_all() def _ctl(self) -> float: return time.monotonic() + self.config.request_timeout From 5a7e11057f964f17bd86eb3aac24db8bf713dcb0 Mon Sep 17 00:00:00 2001 From: Nikhil Pareek <8347993+nik13@users.noreply.github.com> Date: Wed, 11 Nov 2026 05:03:48 -0800 Subject: [PATCH 4/4] fix(python): enforce mixed admission for owned WAV, cumulative recording cap, old-core traceai import - attach_owned_recording: the wav_recording tier admits and re-checks every chunk as `mixed`, matching the wire (every segment is sent as `mixed`), so a hide flag on either side denies the whole file. The caller's label is kept only for the unparseable-header fallback to tier `single`. - RecordingWriter: limits.recording_bytes now caps the cumulative bytes sealed into segments (44-byte headers included), not the bytes still buffered, so a drained recording is truncated at the negotiated total. - traceai: import fi_instrumentation.attachments guarded; on a core without it, `import traceai` and plain init() work, attachment options raise a clear error, and session binding reports unsupported_version. - Regression tests for each, including live stereo with one side hidden. Co-Authored-By: Claude Opus 5.5 --- .../fi_instrumentation/attachments/manager.py | 17 ++- .../attachments/recording.py | 29 ++++- python/tests/attachments/test_recording.py | 103 ++++++++++++++++++ python/tests/attachments/test_sources.py | 89 +++++++++++++++ python/traceai/__init__.py | 43 ++++++-- python/traceai/tests/test_attachments.py | 46 ++++++++ 6 files changed, 311 insertions(+), 16 deletions(-) diff --git a/python/fi_instrumentation/attachments/manager.py b/python/fi_instrumentation/attachments/manager.py index 9327ab9c3..5312c0e92 100644 --- a/python/fi_instrumentation/attachments/manager.py +++ b/python/fi_instrumentation/attachments/manager.py @@ -819,7 +819,15 @@ def attach_owned_recording(self, target, source, *, mime_type: str, direction: s operation="observe_consumed") if len(tracks) not in (1, 2) or validate_options(options): return OwnedRecordingHandle("denied", "policy_denied") - ticket = self.preflight(target, mime_type=mime_type, direction=direction, max_bytes=source.size, + if direction not in ("input", "output", "mixed"): + return OwnedRecordingHandle("denied", "policy_denied") + # Every wav_recording segment goes on the wire as ``mixed``: a stereo file + # carries both sides in every byte, and its segments carry no track_id + # (design 2.4, 2.6 and 7). Admission and every per-chunk re-check must + # therefore evaluate ``mixed`` too, so a hide flag on EITHER side denies the + # whole file. The caller's label is kept only for the unparseable-header + # fallback to tier ``single``, whose wire direction is "as given". + ticket = self.preflight(target, mime_type=mime_type, direction="mixed", max_bytes=source.size, operation="import_existing", source_kind="OwnedRecordingFile", purpose=purpose, capture_policy=capture_policy, _skip_cap=True) if not ticket.admitted: @@ -834,7 +842,7 @@ def attach_owned_recording(self, target, source, *, mime_type: str, direction: s job = _Job("owned_wav", handle=handle, payload=source, spec=ticket._spec, epoch=self._epoch, nbytes=reservation.nbytes, descriptors=1, extra={"tracks": wav_tracks, "recording_id": recording_id, "correlation": ticket.correlation, - "conversation_id": conversation_id}) + "conversation_id": conversation_id, "caller_direction": direction}) handle._job = job with self._cond: if self._stopped or self._stopping: @@ -1403,7 +1411,7 @@ def _run_owned_wav(self, job: _Job) -> str: index = len(completed) request = self._upload_request( extra["correlation"], attachment_id=str(uuid.uuid4()), occurrence_id=part.occurrence_id, - mime_type="audio/wav", direction="mixed" if layout == "mixed" else job.spec[1], + mime_type="audio/wav", direction="mixed", source_kind="OwnedRecordingFile", purpose=job.spec[4], declared_bytes=len(source), fields={"conversation_id": extra["conversation_id"]} if extra["conversation_id"] else None, recording_id=extra["recording_id"], segment_index=index) @@ -1443,7 +1451,8 @@ def _owned_single(self, job: _Job) -> str: extra = job.extra request = self._upload_request( extra["correlation"], attachment_id=str(uuid.uuid4()), occurrence_id=str(uuid.uuid4()), - mime_type="audio/wav", direction=job.spec[1], source_kind="OwnedRecordingFile", purpose=job.spec[4], + mime_type="audio/wav", direction=extra["caller_direction"], source_kind="OwnedRecordingFile", + purpose=job.spec[4], declared_bytes=job.payload.size, fields={"conversation_id": extra["conversation_id"]} if extra["conversation_id"] else None) single = _Job("upload", body=self._p.encode(request), spec=job.spec, epoch=job.epoch, diff --git a/python/fi_instrumentation/attachments/recording.py b/python/fi_instrumentation/attachments/recording.py index 3d5f8c4dd..75b4380f8 100644 --- a/python/fi_instrumentation/attachments/recording.py +++ b/python/fi_instrumentation/attachments/recording.py @@ -228,6 +228,10 @@ def __init__(self, manager=None, options: Optional[RecordingOptions] = None, rea self._window = _Window(0, self._frames) self._windows: List[_Window] = [] self._retained = 0 + # Cumulative bytes this recording has sealed into segments, 44-byte WAV + # headers included. Unlike _retained (memory still held), it never goes + # down when a segment uploads: it is what the recording_bytes cap limits. + self._sealed_bytes = 0 self._completed = 0 self._published_prefix = 0 # frames covered by the last successful manifest self._revision = 0 @@ -331,6 +335,7 @@ def _seal(self, final_end: Optional[int] = None) -> None: entry = _Entry(interval[1], interval[2], stream.track_id, SegmentSource(header, interval[3]), len(interval[3])) window.entries.append(entry) + self._sealed_bytes += 44 + len(interval[3]) else: window.gaps.append((interval[1], interval[2], interval[3], stream.track_id)) self._windows.append(window) @@ -338,6 +343,28 @@ def _seal(self, final_end: Optional[int] = None) -> None: self._manager._enqueue_segment(self, entry) self._window = _Window(end, end + self._frames) + def _projected_bytes(self, stream: _Stream, nbytes: int, frames: int) -> int: + """Total recording bytes if ``nbytes`` more were accepted on ``stream``. + + Sealed segments plus every unsealed data run (each will become a segment + with its own 44-byte header), plus a header for each new segment the part + would start: one when the stream has no open run, and one per window + boundary the part crosses. + """ + total = self._sealed_bytes + nbytes + for s in self._streams: + if s.run_start is not None: + total += 44 + len(s.run) + for interval in s.intervals: + if interval[0] == "data": + total += 44 + len(interval[3]) + if stream.run_start is None: + total += 44 + beyond = stream.cursor + frames - self._window.f1 + if beyond > 0 and self._frames: + total += 44 * (-(-beyond // self._frames)) + return total + def _pending_segments(self) -> int: return sum(1 for w in self._windows for e in w.entries if e.state == "pending") @@ -455,7 +482,7 @@ def _accept(self, stream: _Stream, part: memoryview) -> bool: if reason == "denied": return False if reason is None and (stream.cursor + frames > self._max_frames - or self._retained + len(part) + 44 > self._max_bytes): + or self._projected_bytes(stream, len(part), frames) > self._max_bytes): self._truncated = True for s in self._streams: self._close_run(s) diff --git a/python/tests/attachments/test_recording.py b/python/tests/attachments/test_recording.py index 298ff3abf..a53d7cd58 100644 --- a/python/tests/attachments/test_recording.py +++ b/python/tests/attachments/test_recording.py @@ -405,3 +405,106 @@ def test_partial_frames_carry(manager, transport): assert writer.try_write(data[:3]) and writer.try_write(data[3:]) writer.finish(5) assert len(transport.payloads[0]) == 44 + 2000 + + +# --- Review finding (P1): a stereo recording carries both sides in every byte --- +STEREO = (TrackSpec((0,), "input", "user"), TrackSpec((1,), "output", "assistant")) + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_outputs"]) +def test_live_stereo_one_side_hidden_denies_whole_recording(transport, flag): + """Design 2.4: stereo is evaluated as ``mixed``; hiding one channel is not removal.""" + from fi_instrumentation.attachments import AttachmentPolicy + from fi_instrumentation.instrumentation.config import TraceConfig + + manager = make_manager(transport) + manager.policy = AttachmentPolicy(manager.config, TraceConfig(**{flag: True})) + try: + writer = manager.start_recording(CONTEXT, options(layout="stereo", tracks=STEREO)) + assert writer.reason == "policy_denied" + assert writer.try_write(pcm(2400, 2)) is False + assert writer.finish(2).state == "denied" + assert not transport.requests and not transport.payloads and not transport.manifests + assert manager.owned_bytes == 0 + # Control: separate tracks keep the visible side and drop only the hidden one. + separate = manager.start_recording(CONTEXT, options(layout="separate_tracks", tracks=STEREO)) + assert separate.reason == "queued" + separate.abort() + finally: + manager.shutdown(1) + + +# --- Review finding (P1): recording_bytes caps the TOTAL uploaded, not what is buffered --- +def test_recording_bytes_cap_is_cumulative(transport): + """Design 0.7/2.6: ``truncated`` once the total reaches min(limits.recording_bytes, 1 GiB), + even when earlier segments have already uploaded and released their memory.""" + limit = 3_000_000 + transport.limits = Limits(recording_bytes=limit) + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options()) + accepted = 0 + for _ in range(120): # 120 s of 24 kHz mono, 48 000 B/s + if writer.try_write(pcm(24000)): + accepted += 48000 + deadline = time.monotonic() + 5 + while writer.status().segments_pending and time.monotonic() < deadline: + time.sleep(0.01) # drain: the old check only saw buffered bytes + assert writer.status().state == "truncated" + result = writer.finish(15) + manifest = last_manifest(transport) + uploaded = sum(len(p) for p in transport.payloads) + assert uploaded <= limit, uploaded + assert accepted <= limit + assert uploaded >= 2 * 1440044 # two full 30 s segments fit under 3 MB + assert not manifest["capture_complete"] and manifest["gaps"][-1]["reason"] == "truncated" + assert manifest["duration_ms"] == 120000 + assert result.state == "partial" + finally: + manager.shutdown(1) + + +def test_recording_bytes_cap_counts_every_track(transport): + """Separate tracks share one recording total: headers and both tracks' bytes count.""" + limit = 2_000_000 + transport.limits = Limits(recording_bytes=limit, segment_duration_ms=5000) + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options(layout="separate_tracks", tracks=STEREO)) + assert writer.reason == "queued" + for _ in range(60): + writer.try_write(pcm(24000), track=0) + writer.try_write(pcm(24000), track=1) + deadline = time.monotonic() + 5 + while writer.status().segments_pending and time.monotonic() < deadline: + time.sleep(0.01) + writer.finish(15) + assert sum(len(p) for p in transport.payloads) <= limit + assert any(g["reason"] == "truncated" for g in last_manifest(transport)["gaps"]) + finally: + manager.shutdown(1) + + +def test_recording_bytes_cap_counts_segment_headers(): + """Every sealed segment's 44-byte header counts toward recording_bytes. + + 1 s segments of 24 kHz mono are 48 044 bytes. Counting the two sealed headers + (96 088 bytes sealed), a third segment fits its own header and 4 writes of 960 + bytes under this limit; ignoring them (96 000 bytes) would admit a 5th write + and upload 48 bytes past the cap. + """ + full = 44 + 48000 + limit = 2 * 48000 + 44 + 5 * 960 + 40 # 100 884 + transport = TransportDouble(limits=Limits(segment_duration_ms=1000, recording_bytes=limit)) + manager = make_manager(transport) + try: + writer = manager.start_recording(CONTEXT, options()) + feed(writer, 24000 * 3, step=480) + assert writer.status().state == "truncated" + writer.finish(15) + sizes = [len(p) for p in transport.payloads] + assert sizes == [full, full, 44 + 4 * 960], sizes + assert sum(sizes) <= limit + assert last_manifest(transport)["gaps"][-1]["reason"] == "truncated" + finally: + manager.shutdown(1) diff --git a/python/tests/attachments/test_sources.py b/python/tests/attachments/test_sources.py index 97694f206..907eeff85 100644 --- a/python/tests/attachments/test_sources.py +++ b/python/tests/attachments/test_sources.py @@ -280,3 +280,92 @@ def test_finalization_deadline(tmp_path): transport.release.set() scope.close() manager.shutdown(1) + + +# --- Review finding (P1): owned WAV admission must match the wire direction --- +# Every wav_recording segment is sent as ``mixed`` (design 2.4/2.6/7), so a hide +# flag on EITHER side must deny the whole file whatever label the caller passed. +STEREO_ROLES = (TrackSpec((0,), "input", "user"), TrackSpec((1,), "output", "assistant")) + + +def _owned(tmp_path, channels, *, trace_config=None, direction, wav_tracks): + from fi_instrumentation.attachments import AttachmentPolicy + + transport, manager = big_manager() + if trace_config is not None: + manager.policy = AttachmentPolicy(manager.config, trace_config) + path = tmp_path / "call.wav" + write_wav(path, channels, 24000, 24000 * 2) + scope = RecordingFileScope(str(tmp_path), enabled=True) + source = scope.source(path.name, scope.identify(path.name)) + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/wav", direction=direction, + wav_tracks=wav_tracks) + return transport, manager, scope, handle + + +@pytest.mark.parametrize("flag", ["hide_inputs", "hide_outputs"]) +@pytest.mark.parametrize("direction", ["input", "output", "mixed"]) +@pytest.mark.parametrize("channels,tracks", [(2, STEREO_ROLES), (1, (TrackSpec((0,), "mixed", "user"),))]) +def test_owned_wav_one_side_hidden_denies_whole_file(tmp_path, monkeypatch, flag, direction, channels, tracks): + from fi_instrumentation.instrumentation.config import TraceConfig + + transport, manager, scope, handle = _owned(tmp_path, channels, trace_config=TraceConfig(**{flag: True}), + direction=direction, wav_tracks=tracks) + try: + assert (handle.tier, handle.reason) == ("denied", "policy_denied") + assert not transport.requests and not transport.payloads and not transport.manifests + assert manager.owned_bytes == 0 + finally: + scope.close() + manager.shutdown(1) + + +@pytest.mark.parametrize("direction", ["input", "output", "mixed"]) +def test_owned_stereo_wav_wire_direction_is_mixed(tmp_path, direction): + transport, manager, scope, handle = _owned(tmp_path, 2, direction=direction, wav_tracks=STEREO_ROLES) + try: + assert handle.tier == "wav_recording" + assert handle.result(20).status == "validating" + assert transport.requests and {r["direction"] for r in transport.requests} == {"mixed"} + manifest = transport.manifests[-1][1] + assert manifest["layout"] == "stereo" + assert [t["direction"] for t in manifest["tracks"]] == ["input", "output"] + finally: + scope.close() + manager.shutdown(1) + + +def test_owned_wav_invalid_direction_denied(tmp_path): + transport, manager, scope, handle = _owned(tmp_path, 2, direction="left", wav_tracks=STEREO_ROLES) + try: + assert (handle.tier, handle.reason) == ("denied", "policy_denied") + assert not transport.requests + finally: + scope.close() + manager.shutdown(1) + + +def test_owned_wav_policy_tightening_mid_file_stops_upload(tmp_path): + """Per-chunk re-checks evaluate ``mixed`` too: hiding one side mid-file stops the rest.""" + from fi_instrumentation.attachments import AttachmentPolicy + from fi_instrumentation.instrumentation.config import TraceConfig + + transport, manager = big_manager(segment_duration_ms=1000) + path = tmp_path / "call.wav" + write_wav(path, 2, 24000, 24000 * 4) + scope = RecordingFileScope(str(tmp_path), enabled=True) + try: + source = scope.source(path.name, scope.identify(path.name)) + transport.release.clear() + handle = manager.attach_owned_recording(CONTEXT, source, mime_type="audio/wav", direction="input", + wav_tracks=STEREO_ROLES) + assert handle.tier == "wav_recording" + assert transport.entered.wait(5) + manager.policy = AttachmentPolicy(manager.config, TraceConfig(hide_outputs=True)) + transport.release.set() + assert handle.result(20).status != "validating" + assert len(transport.payloads) == 0 + finally: + transport.release.set() + scope.close() + manager.shutdown(1) diff --git a/python/traceai/__init__.py b/python/traceai/__init__.py index d9a729424..4888b539d 100644 --- a/python/traceai/__init__.py +++ b/python/traceai/__init__.py @@ -22,9 +22,23 @@ register, ) from fi_instrumentation.fi_types import ProjectType -from fi_instrumentation.attachments import AttachmentConfig from fi_instrumentation.instrumentation.config import TraceConfig +# traceai's floor still admits fi-instrumentation-otel releases without the +# attachments package (it can move only once a core release ships it). On such a +# core, importing traceai and plain init() keep working; asking for attachments +# raises a clear error instead. +try: + from fi_instrumentation.attachments import AttachmentConfig + + _ATTACHMENTS_SUPPORTED = True +except ImportError: # pragma: no cover - exercised in a subprocess test + AttachmentConfig = None + _ATTACHMENTS_SUPPORTED = False + +_CORE_TOO_OLD = ("attachment_config and trace_config need a fi-instrumentation-otel release that " + "includes fi_instrumentation.attachments; upgrade fi-instrumentation-otel") + # Registry of available instrumentors _INSTRUMENTOR_REGISTRY: Dict[str, str] = { # LLM provider instrumentors @@ -96,7 +110,7 @@ def init( batch: bool = False, verbose: bool = True, set_global_tracer_provider: bool = True, - attachment_config: Optional[AttachmentConfig] = None, + attachment_config: Optional["AttachmentConfig"] = None, trace_config: Optional[TraceConfig] = None, ) -> TracerProvider: """ @@ -157,6 +171,11 @@ def init( semantic_convention_enum = SemanticConvention(semantic_convention.lower()) transport_enum = Transport(transport.lower()) + if not _ATTACHMENTS_SUPPORTED and (attachment_config is not None or trace_config is not None): + raise RuntimeError(_CORE_TOO_OLD) + # An older core's register() accepts neither keyword: pass them only when supported. + attachment_kwargs = (dict(attachment_config=attachment_config, trace_config=trace_config) + if _ATTACHMENTS_SUPPORTED else {}) options = (project_name, project_type, project_version_name, semantic_convention, transport, batch, set_global_tracer_provider, attachment_config, trace_config) with _init_lock: @@ -174,8 +193,7 @@ def init( verbose=verbose, transport=transport_enum, semantic_convention=semantic_convention_enum, - attachment_config=attachment_config, - trace_config=trace_config, + **attachment_kwargs, ) _tracer_provider = provider _init_options = options @@ -225,13 +243,11 @@ def _instrument_library(lib_name: str, verbose: bool = True) -> bool: instrumentor_class = getattr(module, _ENTRY_POINTS[instrumentor_module]) instrumentor = instrumentor_class() provider = _tracer_provider - manager = getattr(provider, "attachment_manager", None) - instrumentor.instrument( - tracer_provider=provider, - config=getattr(provider, "trace_config", None), - attachment_manager=manager, - attachment_policy=getattr(manager, "policy", None), - ) + kwargs = dict(tracer_provider=provider, config=getattr(provider, "trace_config", None)) + if _ATTACHMENTS_SUPPORTED: + manager = getattr(provider, "attachment_manager", None) + kwargs.update(attachment_manager=manager, attachment_policy=getattr(manager, "policy", None)) + instrumentor.instrument(**kwargs) _instrumented.add(instrumentor_module) _adapter_status[lib_name_lower] = "registered" @@ -276,12 +292,17 @@ def instrument(*libraries: str, verbose: bool = True) -> None: def attachment_status() -> dict: """Content-free setup status, never an integrated recording-ready claim.""" + if not _ATTACHMENTS_SUPPORTED: + return {"runtime": "unsupported_version", "adapters": dict(_adapter_status)} manager = getattr(_tracer_provider, "attachment_manager", None) return {"runtime": manager.status().state if manager is not None else "uninitialized", "adapters": dict(_adapter_status)} def _bind(library: str, entry_point: str, *args, **kwargs): + if not _ATTACHMENTS_SUPPORTED: + _adapter_status[library] = "unsupported_version" + return None manager = getattr(_tracer_provider, "attachment_manager", None) if manager is None: raise RuntimeError("initialize traceai before binding a session") diff --git a/python/traceai/tests/test_attachments.py b/python/traceai/tests/test_attachments.py index 864355abe..b4e18e306 100644 --- a/python/traceai/tests/test_attachments.py +++ b/python/traceai/tests/test_attachments.py @@ -71,3 +71,49 @@ def test_disabled_init_is_strict_noop(monkeypatch): assert {t.ident for t in threading.enumerate()} == before finally: provider.shutdown() + + +_OLD_CORE_PROBE = r''' +import sys +# A core release without the attachments package (e.g. fi-instrumentation-otel 1.3.1). +sys.modules["fi_instrumentation.attachments"] = None +import fi_instrumentation + +calls = [] + +def old_register(*, project_name=None, project_type=None, project_version_name=None, batch=True, + set_global_tracer_provider=False, verbose=True, transport=None, semantic_convention=None): + calls.append(project_name) + return object() + +import traceai +assert traceai.AttachmentConfig is None +traceai.register = old_register +assert traceai.attachment_status()["runtime"] == "unsupported_version" +provider = traceai.init(project_name="synthetic", verbose=False, set_global_tracer_provider=False) +assert calls == ["synthetic"], calls +assert traceai.bind_livekit_session(object(), object()) is None +assert traceai.attachment_status()["adapters"]["livekit"] == "unsupported_version" +traceai._tracer_provider = None +try: + traceai.init(project_name="other", verbose=False, trace_config=object()) +except RuntimeError as error: + assert "fi-instrumentation-otel" in str(error) +else: + raise AssertionError("trace_config accepted on a core without attachments") +assert calls == ["synthetic"], calls +print("OLD_CORE_OK") +''' + + +def test_import_and_init_on_core_without_attachments(): + """Review finding (P1): traceai must not crash on a core that predates attachments.""" + import os + import subprocess + import sys + + env = dict(os.environ) + result = subprocess.run([sys.executable, "-c", _OLD_CORE_PROBE], capture_output=True, text=True, + timeout=120, env=env) + assert result.returncode == 0, result.stderr[-2000:] + assert "OLD_CORE_OK" in result.stdout