diff --git a/.github/workflows/attachments-python-tests.yml b/.github/workflows/attachments-python-tests.yml new file mode 100644 index 000000000..67ec912ab --- /dev/null +++ b/.github/workflows/attachments-python-tests.yml @@ -0,0 +1,46 @@ +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: + 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', '3.14'] + steps: + - 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>=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 + # 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 new file mode 100644 index 000000000..fb03031a6 --- /dev/null +++ b/python/fi_instrumentation/attachments/__init__.py @@ -0,0 +1,37 @@ +"""Opt-in, provider-owned attachments (audio, images, documents, files). + +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 ._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 .recording import PcmFormat, RecordingOptions, RecordingResult, RecordingStatus, RecordingWriter, TrackSpec +from .sources import FileIdentity, OwnedRecordingFile, RecordingFileScope +from .stream import AttachmentStream, StreamOptions +from .types import ( + AttachmentHandle, AttachmentStatus, Bytes, Completion, CorrelationHandle, FlushResult, + LocalFile, ProviderFile, RemoteUrl, +) + +__all__ = [ + "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 new file mode 100644 index 000000000..7287fbc44 --- /dev/null +++ b/python/fi_instrumentation/attachments/_protocol_schema.json @@ -0,0 +1,2215 @@ +{ + "$schema": "https://json-schema.org/draft/2020-12/schema", + "$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" + ], + "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": { + "track_id": { + "$ref": "#/$defs/UUID" + }, + "channels": { + "type": "array", + "minItems": 1, + "maxItems": 32, + "uniqueItems": true, + "items": { + "type": "integer", + "minimum": 0, + "maximum": 31 + } + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "role": { + "enum": [ + "user", + "assistant", + "mixed", + "unknown" + ] + } + } + }, + "Segment": { + "type": "object", + "additionalProperties": false, + "required": [ + "occurrence_id", + "index", + "start_ms", + "duration_ms" + ], + "properties": { + "occurrence_id": { + "$ref": "#/$defs/UUID" + }, + "index": { + "type": "integer", + "minimum": 0, + "maximum": 65535 + }, + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 + }, + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 30000 + }, + "track_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "Gap": { + "type": "object", + "additionalProperties": false, + "required": [ + "start_ms", + "duration_ms", + "reason" + ], + "properties": { + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 + }, + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + }, + "reason": { + "enum": [ + "queue_full", + "bootstrap_pending", + "source_unavailable", + "policy_denied", + "truncated", + "incomplete" + ] + }, + "track_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "PlayoutInterval": { + "type": "object", + "additionalProperties": false, + "required": [ + "start_ms", + "duration_ms", + "evidence" + ], + "properties": { + "start_ms": { + "type": "integer", + "minimum": 0, + "maximum": 7200000 + }, + "duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + }, + "evidence": { + "enum": [ + "generated", + "played", + "unknown", + "truncated" + ] + } + } + }, + "RecordingManifest": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "recording_id", + "timebase", + "sample_format", + "sample_rate_hz", + "channels", + "codec", + "container", + "layout", + "tracks", + "segments", + "gaps", + "playout", + "capture_complete", + "duration_ms" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "timebase": { + "const": "session_relative_ms" + }, + "sample_format": { + "enum": [ + "s16le", + "s24le", + "s32le", + "f32le", + "encoded" + ] + }, + "sample_rate_hz": { + "type": "integer", + "minimum": 8000, + "maximum": 192000 + }, + "channels": { + "type": "integer", + "minimum": 1, + "maximum": 32 + }, + "codec": { + "enum": [ + "pcm", + "opus", + "mp3", + "aac", + "flac" + ] + }, + "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": 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 + }, + "language": { + "enum": [ + "python", + "typescript" + ] + }, + "operation": { + "$ref": "#/$defs/Token" + }, + "upstream_version": { + "oneOf": [ + { + "type": "null" + }, + { + "type": "string", + "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+([.-][a-zA-Z0-9.]+)?$", + "maxLength": 64 + } + ] + }, + "source_kind": { + "$ref": "#/$defs/SourceKind" + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "lifecycle": { + "enum": [ + "application_consumed", + "explicit_session_binding", + "completed_provider_output" + ] + }, + "span_capability": { + "enum": [ + "native", + "instrumented", + "unsupported", + "unqualified" + ] + }, + "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" + ] + } + }, + "component_test_state": { + "enum": [ + "not_run", + "passed", + "failed", + "blocked" + ] + }, + "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" + ] + } + } + } + } + ] + }, + "Error": { + "type": "object", + "additionalProperties": false, + "required": [ + "code", + "request_id" + ], + "properties": { + "code": { + "$ref": "#/$defs/Reason" + }, + "request_id": { + "$ref": "#/$defs/UUID" + } + } + }, + "AttachmentMetadata": { + "type": "object", + "additionalProperties": false, + "required": [ + "attachment_id", + "modality", + "source_kind", + "provider", + "purpose", + "policy_version", + "state", + "created_at" + ], + "properties": { + "attachment_id": { + "$ref": "#/$defs/UUID" + }, + "modality": { + "$ref": "#/$defs/Modality" + }, + "source_kind": { + "$ref": "#/$defs/SourceKind" + }, + "provider": { + "enum": [ + "pipecat", + "livekit", + "unknown" + ] + }, + "purpose": { + "$ref": "#/$defs/Purpose" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "state": { + "$ref": "#/$defs/Status" + }, + "created_at": { + "$ref": "#/$defs/Timestamp" + }, + "completed_at": { + "$ref": "#/$defs/Timestamp" + } + } + }, + "CanonicalParent": { + "type": "object", + "additionalProperties": false, + "required": [ + "trace_id", + "span_id" + ], + "properties": { + "trace_id": { + "$ref": "#/$defs/UUID" + }, + "span_id": { + "$ref": "#/$defs/SpanID" + } + } + }, + "CanonicalAssociation": { + "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/CanonicalParent" + } + } + }, + "SingleAttachmentImportRequest": { + "type": "object", + "additionalProperties": false, + "required": [ + "upload", + "source" + ], + "properties": { + "upload": { + "$ref": "#/$defs/UploadRequest" + }, + "source": { + "$ref": "#/$defs/ImportSource" + } + } + }, + "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" + } + } + }, + "CompletedRecordingImport": { + "type": "object", + "additionalProperties": false, + "required": [ + "schema_version", + "association", + "policy_version", + "deletion_generation", + "mime_type", + "direction", + "source_kind", + "recording_id", + "modality", + "declared_bytes", + "declared_duration_ms" + ], + "properties": { + "schema_version": { + "const": 1 + }, + "association": { + "$ref": "#/$defs/Association" + }, + "policy_version": { + "$ref": "#/$defs/Token" + }, + "deletion_generation": { + "$ref": "#/$defs/SafeInteger" + }, + "mime_type": { + "enum": [ + "audio/wav", + "audio/ogg", + "audio/mpeg", + "audio/mp4", + "audio/webm", + "audio/flac", + "audio/L16" + ] + }, + "direction": { + "$ref": "#/$defs/Direction" + }, + "source_kind": { + "enum": [ + "ProviderFile", + "RemoteUrl" + ] + }, + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "modality": { + "const": "audio" + }, + "declared_bytes": { + "type": "integer", + "minimum": 1, + "maximum": 1073741824 + }, + "declared_duration_ms": { + "type": "integer", + "minimum": 1, + "maximum": 7200000 + } + }, + "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" + }, + "recording": { + "$ref": "#/$defs/CompletedRecordingImport" + }, + "source": { + "$ref": "#/$defs/ImportSource" + } + } + }, + "RecordingImportResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "mode", + "job_id", + "recording_id", + "state" + ], + "properties": { + "mode": { + "const": "completed_recording" + }, + "job_id": { + "$ref": "#/$defs/UUID" + }, + "recording_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "const": "importing" + } + } + }, + "ImportStatusResponse": { + "type": "object", + "additionalProperties": false, + "required": [ + "job_id", + "state", + "reason" + ], + "properties": { + "job_id": { + "$ref": "#/$defs/UUID" + }, + "state": { + "$ref": "#/$defs/Status" + }, + "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 new file mode 100644 index 000000000..5312c0e92 --- /dev/null +++ b/python/fi_instrumentation/attachments/manager.py @@ -0,0 +1,1674 @@ +"""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 re +import threading +import time +import uuid +import weakref +from collections import deque +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 fi_instrumentation.instrumentation.config import TraceConfig + +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 + + +class _Job: + __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. + + 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, + 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._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: + initial = "scope_unresolved" + elif transport is None: + try: + 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: + 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: 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 _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 + 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: + 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._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_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: + 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) + + 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._cond: + return self._bytes + + # ------------------------------------------------------------- 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: + """``preflight(max_bytes=len(source))`` followed by ``ticket.attach``. Never raises.""" + try: + 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 + # not fail inference or reach a logger with their repr/exception. + return AttachmentHandle("source_unavailable") + + 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: + 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(fallback) + + @staticmethod + 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] = value + for key in ("message_index", "part_index", "channel"): + 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 = fields.get(key) + if value is not None: + if not isinstance(value, str) or not TOKEN.fullmatch(value): + raise ValueError("invalid opaque correlation") + result[key] = value + return result + + 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 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.encode()) > 16384: + return + references = json.loads(raw) + if not isinstance(references, list): + return + 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 + + # -------------------------------------------------------------- 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 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") + 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: + 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, "caller_direction": direction}) + 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: + 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 _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 == self._p.ATTEMPTS - 1: + raise + 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: + self._maybe_renew() + with self._cond: + while not self._ready_q and not self._stopped: + self._cond.wait(WAIT_SLICE) + if self._stopped: + return + 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" + try: + status = self._run(job) + except TransferError as error: + status = error.reason + except Exception: + status = "incomplete" + finally: + 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) + 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 + 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 + 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 + + 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", + 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=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, + 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: + """Re-evaluate admitted work. Tightening discards; loosening affects only new admissions. + + Only the control-plane owner should call this with a negotiated policy. + In-flight I/O re-checks before the next bounded chunk; bytes already + sent cannot be recalled locally. + """ + if not self._enabled: + return + dropped = [] + with self._cond: + self._epoch += 1 + if self._session is not None: + old = self._session + 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: + 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: + """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): + """Provider wiring only: flush/shutdown. No span is stamped at start (0.8).""" + + def __init__(self, manager): + self.manager = manager + + def on_start(self, span, parent_context=None): + pass + + 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..afaef4d9b --- /dev/null +++ b/python/fi_instrumentation/attachments/policy.py @@ -0,0 +1,281 @@ +"""Attachment admission is independent of span masking and always deny-wins. + +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) + 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") + + +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 * 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"): + 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")) + 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 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 F01 ``Policy``; an unknown policy is never permissive.""" + + enabled: bool = False + credential_write: bool = False + 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: + """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 media 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 + # 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, 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 direction not in ("input", "output", "mixed") or (purpose is not None and purpose not in PURPOSES): + return "policy_denied" + if mime_type not in MIME_MODALITIES: + return "source_unavailable" + 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 new file mode 100644 index 000000000..b6cb0d634 --- /dev/null +++ b/python/fi_instrumentation/attachments/protocol.py @@ -0,0 +1,590 @@ +"""The ONE versioned fi.attachments.v1 wire adapter (design section 9). + +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 dataclasses import dataclass, field +from datetime import datetime +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") + +# 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) +class Session: + project_id: str + capture_session_id: str + policy: ServerPolicy + expires_at: float + 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) +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() + + +@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: + 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 - SKEW_SECONDS <= time.time(): + raise TransferError("expired") + return timestamp + + +def _uuid(value) -> str: + if canonical_uuid(value) is None: + raise TransferError("unsupported_version") + return value + + +def safe_headers(headers: Mapping[str, str]) -> dict: + result = {} + 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 + + +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, 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 = 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 + + # ------------------------------------------------------------------ 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() + 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, skip_accept_encoding=True) + for name, value in headers.items(): + connection.putheader(name, value) + connection.endheaders() + 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() + arm(self._timeout) + connection.send(chunk) + del chunk + source.check() + check() + arm(max(self._timeout, deadline - time.monotonic())) + response = connection.getresponse() + 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 + 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 _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") + 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" + + 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 renew_upload(self, session: Session, upload: Upload, body: bytes, *, deadline: float) -> Upload: + request = strict_json(body) + try: + 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 + 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 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 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..75b4380f8 --- /dev/null +++ b/python/fi_instrumentation/attachments/recording.py @@ -0,0 +1,748 @@ +"""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 + # 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 + 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) + self._sealed_bytes += 44 + len(interval[3]) + 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 _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") + + 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._projected_bytes(stream, len(part), frames) > 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 new file mode 100644 index 000000000..714aca725 --- /dev/null +++ b/python/fi_instrumentation/attachments/sources.py @@ -0,0 +1,275 @@ +"""Explicit session-owned file leases (design section 4). Arbitrary LocalFile stays disabled. + +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 .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: + """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 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: + 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 __enter__(self) -> "RecordingFileScope": + return self + + 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 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(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: + self._forget_after_fork() + 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: + """Internal: obtained by the worker, never by adapters. ``pread`` only.""" + + 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: + 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) != ( + 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: + 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 new file mode 100644 index 000000000..766f0d7d5 --- /dev/null +++ b/python/fi_instrumentation/attachments/types.py @@ -0,0 +1,189 @@ +"""Content-free handles, shared vocabulary and typed 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 + +# 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: + 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. + # "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: + """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, 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 + 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 + + @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: + 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: + unfinished: int + dropped: int diff --git a/python/fi_instrumentation/otel.py b/python/fi_instrumentation/otel.py index 7e4f5b2b3..75df92b8c 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,21 @@ 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 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() + 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) if attachment_config.enabled else None, + ) + if tracer_provider.attachment_manager.status().state != "disabled": + 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..b3a44043a --- /dev/null +++ b/python/tests/attachments/conftest.py @@ -0,0 +1,188 @@ +import json +import os +import sys +import threading +import time +import uuid +from pathlib import Path + +import pytest +from fi_instrumentation.attachments import AttachmentConfig, AttachmentManager, ServerPolicy +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) +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) + + +def capability(): + return "cap_" + uuid.uuid4().hex + + +class TransportDouble: + """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", "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.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, body, *, key, deadline): + self.bootstraps += 1 + 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, body, *, key, deadline, check): + check() + 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 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() + 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) + 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, *, 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, *, 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 = 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 new file mode 100644 index 000000000..13302c31a --- /dev/null +++ b/python/tests/attachments/test_http_contract.py @@ -0,0 +1,255 @@ +"""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": 600} + 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, {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"]), + "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, {"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, {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, {"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) + 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 "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) + + +@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().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) + + +@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"}) + + +@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 new file mode 100644 index 000000000..794cbd96f --- /dev/null +++ b/python/tests/attachments/test_policy_runtime.py @@ -0,0 +1,276 @@ +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): + manager = AttachmentManager(project_name="synthetic") + assert attach(manager).admission == "disabled" + assert manager.owned_bytes == 0 + assert not manager._threads and manager._transport is None and manager._p is None + 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 manager.status().queued == 0 + 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, **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 manager.status().queued == 0 + 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 manager.status().queued == 0 + + +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_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): + 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.27 and result.unfinished == 1 + assert signal.getsignal(signal.SIGTERM) == handler + transport.release.set() + assert handle.result(2).status == "incomplete" + assert manager.shutdown(0) == result + + +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 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..a53d7cd58 --- /dev/null +++ b/python/tests/attachments/test_recording.py @@ -0,0 +1,510 @@ +"""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 + + +# --- 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_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 new file mode 100644 index 000000000..907eeff85 --- /dev/null +++ b/python/tests/attachments/test_sources.py @@ -0,0 +1,371 @@ +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)) + + +# ---- 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(" TracerProvider: """ Initialize TraceAI with a simple one-liner. @@ -120,7 +161,7 @@ def init( verbose=False, ) """ - global _tracer_provider + global _tracer_provider, _init_options # Convert string enums to enum types project_type_enum = ( @@ -130,17 +171,34 @@ 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, - ) + 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: + 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_kwargs, + ) + _tracer_provider = provider + _init_options = options + _instrumented.clear() + _adapter_status.clear() # Auto-instrument specified libraries if auto_instrument: @@ -174,34 +232,39 @@ 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 + 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" 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 +290,58 @@ 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.""" + 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") + 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..b4e18e306 --- /dev/null +++ b/python/traceai/tests/test_attachments.py @@ -0,0 +1,119 @@ +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=lambda: SimpleNamespace(state="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=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))) + 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=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() + + +_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