viio-sync-api-sdk 0.1.0__py3-none-any.whl

viio_sync_api/__init__.py

@@ -0,0 +1,27 @@
+"""Async Python SDK for the Viio Sync API."""
+
+from ._auth import BearerTokenProvider, SyncApiAuthentication
+from ._client import SyncApiBatch, SyncApiClient
+from ._errors import (
+    SyncApiAuthenticationError,
+    SyncApiBatchAlreadyInProgressError,
+    SyncApiBatchStateError,
+    SyncApiClosedError,
+    SyncApiError,
+    SyncApiProtocolError,
+)
+from ._options import SyncApiClientOptions
+
+__all__ = [
+    "BearerTokenProvider",
+    "SyncApiAuthentication",
+    "SyncApiAuthenticationError",
+    "SyncApiBatch",
+    "SyncApiBatchAlreadyInProgressError",
+    "SyncApiBatchStateError",
+    "SyncApiClient",
+    "SyncApiClientOptions",
+    "SyncApiClosedError",
+    "SyncApiError",
+    "SyncApiProtocolError",
+]

viio_sync_api/_auth.py

@@ -0,0 +1,88 @@
+"""Authentication modes shared by high-level and generated client calls."""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass
+from typing import Protocol
+
+from ._errors import SyncApiAuthenticationError
+
+BearerTokenProvider = Callable[[], Awaitable[str]]
+AuthorizationMetadata = tuple[str, str]
+
+
+class _AuthorizationProvider(Protocol):
+    async def get_authorization(self) -> AuthorizationMetadata: ...
+
+    async def close(self) -> None: ...
+
+
+class SyncApiAuthentication(ABC):
+    """Defines exactly one authentication mode for a client."""
+
+    @staticmethod
+    def api_key(api_key: str) -> SyncApiAuthentication:
+        """Use a fixed API key sent with the ``ApiKey`` authorization scheme."""
+        if not isinstance(api_key, str) or not api_key.strip():
+            raise ValueError("api_key cannot be empty")
+        return _ProviderAuthentication("ApiKey", lambda: _completed(api_key))
+
+    @staticmethod
+    def bearer_token(token_provider: BearerTokenProvider) -> SyncApiAuthentication:
+        """Use an asynchronous bearer provider owned by a Viio-managed caller."""
+        if not callable(token_provider):
+            raise TypeError("token_provider must be callable")
+        return _ProviderAuthentication("Bearer", token_provider)
+
+    @abstractmethod
+    def _create_provider(self) -> _AuthorizationProvider:
+        raise NotImplementedError
+
+
+async def _completed(value: str) -> str:
+    return value
+
+
+@dataclass(frozen=True, slots=True, repr=False)
+class _ProviderAuthentication(SyncApiAuthentication):
+    scheme: str
+    value_provider: BearerTokenProvider
+
+    def _create_provider(self) -> _AuthorizationProvider:
+        return _DelegateAuthorizationProvider(self.scheme, self.value_provider)
+
+    def __repr__(self) -> str:
+        return f"SyncApiAuthentication({self.scheme})"
+
+
+@dataclass(slots=True)
+class _DelegateAuthorizationProvider:
+    scheme: str
+    value_provider: BearerTokenProvider
+
+    async def get_authorization(self) -> AuthorizationMetadata:
+        try:
+            value_awaitable = self.value_provider()
+        except Exception:
+            raise SyncApiAuthenticationError("The authentication provider failed to provide a credential") from None
+
+        if not inspect.isawaitable(value_awaitable):
+            raise SyncApiAuthenticationError("The authentication provider returned no awaitable credential")
+
+        try:
+            value = await value_awaitable
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            raise SyncApiAuthenticationError("The authentication provider failed to provide a credential") from None
+
+        if not isinstance(value, str) or not value.strip():
+            raise SyncApiAuthenticationError("The authentication provider returned an empty credential")
+        return "authorization", f"{self.scheme} {value}"
+
+    async def close(self) -> None:
+        return None

viio_sync_api/_client.py

@@ -0,0 +1,192 @@
+"""High-level AsyncIO client and explicit batch lifecycle."""
+
+from __future__ import annotations
+
+import asyncio
+from enum import Enum
+from types import TracebackType
+
+from ._errors import (
+    SyncApiBatchAlreadyInProgressError,
+    SyncApiBatchStateError,
+    SyncApiClosedError,
+    SyncApiProtocolError,
+)
+from ._options import SyncApiClientOptions
+from ._transport import _GrpcSyncApiTransport, _SyncApiTransport
+from .v1 import (
+    SYNC_ERROR_CODE_SYNC_ALREADY_IN_PROGRESS,
+    AbortSyncBatchRequest,
+    CompleteSyncBatchRequest,
+    StartSyncBatchRequest,
+    SyncRecordsRequest,
+    SyncServiceStub,
+)
+
+_TYPED_WRAPPERS = (
+    "accounts",
+    "licenses",
+    "plans",
+    "usage",
+    "employees",
+    "groups",
+    "group_members",
+    "externally_discovered_usage",
+    "devices",
+    "audit_logs",
+    "ai_usage",
+    "ai_costs",
+)
+
+
+class SyncApiClient:
+    """Supported AsyncIO client for authenticated Sync API batch operations."""
+
+    def __init__(
+        self,
+        options: SyncApiClientOptions,
+        *,
+        _transport: _SyncApiTransport | None = None,
+    ) -> None:
+        if not isinstance(options, SyncApiClientOptions):
+            raise TypeError("options must be a SyncApiClientOptions")
+        options.validate()
+        self._transport = _transport or _GrpcSyncApiTransport(options)
+        self._closed = False
+
+    @property
+    def grpc_client(self) -> SyncServiceStub:
+        """The authenticated generated v1 stub for advanced calls."""
+        self._ensure_open()
+        return self._transport.grpc_client
+
+    async def start_batch(
+        self,
+        direct_integration_installation_id: str,
+    ) -> SyncApiBatch:
+        """Start a server-owned batch and return its lifecycle-aware handle."""
+        self._ensure_open()
+        if not isinstance(direct_integration_installation_id, str) or not direct_integration_installation_id.strip():
+            raise ValueError("direct_integration_installation_id cannot be empty")
+
+        response = await self._transport.start(
+            StartSyncBatchRequest(direct_integration_installation_id=direct_integration_installation_id)
+        )
+        if not response.success:
+            if response.error_code == SYNC_ERROR_CODE_SYNC_ALREADY_IN_PROGRESS:
+                raise SyncApiBatchAlreadyInProgressError(response.message)
+            raise SyncApiProtocolError("StartBatch", response.message)
+        if not response.batch_id.strip():
+            raise SyncApiProtocolError(
+                "StartBatch",
+                "The server returned an empty batch ID.",
+            )
+        return SyncApiBatch(self, response.batch_id)
+
+    async def _write(self, batch_id: str, request: SyncRecordsRequest) -> None:
+        self._ensure_open()
+        if not isinstance(request, SyncRecordsRequest):
+            raise TypeError("request must be a SyncRecordsRequest")
+        wrapper_count = sum(request.HasField(field) for field in _TYPED_WRAPPERS)
+        if wrapper_count != 1:
+            raise ValueError("A write request must contain exactly one typed records wrapper")
+
+        request_with_batch_id = SyncRecordsRequest()
+        request_with_batch_id.CopyFrom(request)
+        request_with_batch_id.batch_id = batch_id
+        response = await self._transport.write(request_with_batch_id)
+        if not response.success:
+            raise SyncApiProtocolError("Write", response.message)
+
+    async def _complete(self, batch_id: str) -> None:
+        self._ensure_open()
+        response = await self._transport.complete(CompleteSyncBatchRequest(batch_id=batch_id))
+        if not response.success:
+            raise SyncApiProtocolError("CompleteBatch", response.message)
+
+    async def _abort(self, batch_id: str) -> None:
+        self._ensure_open()
+        response = await self._transport.abort(AbortSyncBatchRequest(batch_id=batch_id))
+        if not response.success:
+            raise SyncApiProtocolError("AbortBatch", response.message)
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise SyncApiClosedError("The Sync API client is closed")
+
+    async def close(self) -> None:
+        """Release SDK-owned channel and authentication resources."""
+        if self._closed:
+            return
+        self._closed = True
+        await self._transport.close()
+
+    async def __aenter__(self) -> SyncApiClient:
+        self._ensure_open()
+        return self
+
+    async def __aexit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        del exception_type, exception, traceback
+        await self.close()
+
+
+class SyncApiBatch:
+    """One explicit Sync API batch with serialized local lifecycle checks."""
+
+    def __init__(self, client: SyncApiClient, batch_id: str) -> None:
+        self._client = client
+        self._batch_id = batch_id
+        self._operation_lock = asyncio.Lock()
+        self._state = _BatchState.ACTIVE
+        self._closed = False
+
+    @property
+    def batch_id(self) -> str:
+        """The server-generated batch identifier."""
+        return self._batch_id
+
+    async def write(self, request: SyncRecordsRequest) -> None:
+        """Write one typed wrapper; concurrent batch operations are serialized."""
+        self._ensure_open()
+        async with self._operation_lock:
+            self._ensure_active()
+            await self._client._write(self._batch_id, request)
+
+    async def complete(self) -> None:
+        """Complete the batch and reject future operations after success."""
+        self._ensure_open()
+        async with self._operation_lock:
+            self._ensure_active()
+            await self._client._complete(self._batch_id)
+            self._state = _BatchState.COMPLETED
+
+    async def abort(self) -> None:
+        """Abort the batch and reject future operations after success."""
+        self._ensure_open()
+        async with self._operation_lock:
+            self._ensure_active()
+            await self._client._abort(self._batch_id)
+            self._state = _BatchState.ABORTED
+
+    def close(self) -> None:
+        """Release local state without completing or aborting the remote batch."""
+        self._closed = True
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise SyncApiClosedError("The Sync API batch is closed")
+
+    def _ensure_active(self) -> None:
+        if self._state is not _BatchState.ACTIVE:
+            raise SyncApiBatchStateError(f"The batch has already been {self._state.value}")
+
+
+class _BatchState(Enum):
+    ACTIVE = "active"
+    COMPLETED = "completed"
+    ABORTED = "aborted"

viio_sync_api/_endpoint.py

@@ -0,0 +1,61 @@
+"""Validate a Sync API URL and translate it to a Python gRPC target."""
+
+from __future__ import annotations
+
+import ipaddress
+from dataclasses import dataclass
+from urllib.parse import SplitResult, urlsplit
+
+
+@dataclass(frozen=True, slots=True)
+class ParsedEndpoint:
+    secure: bool
+    target: str
+
+
+def parse_endpoint(value: str) -> ParsedEndpoint:
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError("endpoint cannot be empty")
+
+    try:
+        parsed = urlsplit(value)
+        port = parsed.port
+    except ValueError as error:
+        raise ValueError("endpoint must be a valid absolute URL") from error
+
+    if (
+        parsed.scheme not in {"https", "http"}
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+        or parsed.query
+        or parsed.fragment
+    ):
+        raise ValueError(
+            "endpoint must be an absolute HTTPS URL, or an HTTP loopback URL, without embedded credentials"
+        )
+
+    if parsed.path not in {"", "/"}:
+        raise ValueError("endpoint cannot contain a path")
+
+    secure = parsed.scheme == "https"
+    if not secure and not _is_loopback(parsed):
+        raise ValueError("endpoint must use HTTPS unless it targets a loopback host")
+
+    endpoint_port = port or (443 if secure else 80)
+    host = parsed.hostname
+    assert host is not None
+    target_host = f"[{host}]" if ":" in host else host
+    return ParsedEndpoint(secure=secure, target=f"{target_host}:{endpoint_port}")
+
+
+def _is_loopback(parsed: SplitResult) -> bool:
+    hostname = parsed.hostname
+    if hostname is None:
+        return False
+    if hostname.lower() == "localhost":
+        return True
+    try:
+        return ipaddress.ip_address(hostname).is_loopback
+    except ValueError:
+        return False

viio_sync_api/_errors.py

@@ -0,0 +1,32 @@
+"""Public SDK-specific exceptions."""
+
+
+class SyncApiError(Exception):
+    """Base class for SDK-specific failures."""
+
+
+class SyncApiAuthenticationError(SyncApiError):
+    """Authentication could not produce a usable credential."""
+
+
+class SyncApiProtocolError(SyncApiError):
+    """The Sync API returned a valid response that reports failure."""
+
+    def __init__(self, operation: str, message: str) -> None:
+        super().__init__(f"Sync API operation {operation!r} failed: {message}")
+        self.operation = operation
+
+
+class SyncApiBatchAlreadyInProgressError(SyncApiProtocolError):
+    """A batch could not start because another sync is already in progress."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__("StartBatch", message)
+
+
+class SyncApiBatchStateError(SyncApiError):
+    """An operation is invalid for the batch's current local state."""
+
+
+class SyncApiClosedError(SyncApiError):
+    """An operation was attempted on a closed SDK resource."""

viio_sync_api/_options.py

@@ -0,0 +1,35 @@
+"""Sync API client options."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ._auth import SyncApiAuthentication
+from ._endpoint import ParsedEndpoint, parse_endpoint
+
+
+@dataclass(slots=True)
+class SyncApiClientOptions:
+    """Configures an authenticated AsyncIO Sync API client."""
+
+    endpoint: str
+    authentication: SyncApiAuthentication
+    # Maximum response-message size this client accepts. None uses gRPC's default.
+    max_receive_message_size: int | None = 16 * 1024 * 1024
+    # Maximum request-message size this client sends. None uses gRPC's default.
+    max_send_message_size: int | None = None
+    timeout: float = 100.0
+
+    def validate(self) -> ParsedEndpoint:
+        parsed = parse_endpoint(self.endpoint)
+        if not isinstance(self.authentication, SyncApiAuthentication):
+            raise TypeError("authentication must be a SyncApiAuthentication")
+        if self.max_receive_message_size is not None and self.max_receive_message_size <= 0:
+            raise ValueError("max_receive_message_size must be positive")
+        if self.max_send_message_size is not None and self.max_send_message_size <= 0:
+            raise ValueError("max_send_message_size must be positive")
+        if self.timeout <= 0:
+            raise ValueError("timeout must be positive and finite")
+        if self.timeout == float("inf"):
+            raise ValueError("timeout must be positive and finite")
+        return parsed

viio_sync_api/_transport.py

@@ -0,0 +1,154 @@
+"""Authenticated gRPC AsyncIO transport."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Awaitable, Callable
+from typing import Any, Protocol, cast
+
+import grpc
+
+from ._auth import _AuthorizationProvider
+from ._options import SyncApiClientOptions
+from .v1 import (
+    AbortSyncBatchRequest,
+    AbortSyncBatchResponse,
+    CompleteSyncBatchRequest,
+    CompleteSyncBatchResponse,
+    StartSyncBatchRequest,
+    StartSyncBatchResponse,
+    SyncRecordsRequest,
+    SyncRecordsResponse,
+    SyncServiceStub,
+)
+
+
+class _SyncApiTransport(Protocol):
+    @property
+    def grpc_client(self) -> SyncServiceStub: ...
+
+    async def start(self, request: StartSyncBatchRequest) -> StartSyncBatchResponse: ...
+
+    async def write(self, request: SyncRecordsRequest) -> SyncRecordsResponse: ...
+
+    async def complete(self, request: CompleteSyncBatchRequest) -> CompleteSyncBatchResponse: ...
+
+    async def abort(self, request: AbortSyncBatchRequest) -> AbortSyncBatchResponse: ...
+
+    async def close(self) -> None: ...
+
+
+class _AuthenticationInterceptor:
+    def __init__(self, authorization_provider: _AuthorizationProvider) -> None:
+        self._authorization_provider = authorization_provider
+
+    async def _authenticated_details(
+        self,
+        details: grpc.aio.ClientCallDetails,
+    ) -> grpc.aio.ClientCallDetails:
+        authorization = await self._authorization_provider.get_authorization()
+        metadata = grpc.aio.Metadata(*(item for item in (details.metadata or ()) if item[0].lower() != "authorization"))
+        metadata.add(*authorization)
+        return grpc.aio.ClientCallDetails(
+            method=details.method,
+            timeout=details.timeout,
+            metadata=metadata,
+            credentials=details.credentials,
+            wait_for_ready=details.wait_for_ready,
+        )
+
+
+class _UnaryUnaryAuthenticationInterceptor(
+    _AuthenticationInterceptor,
+    grpc.aio.UnaryUnaryClientInterceptor,
+):
+    async def intercept_unary_unary(
+        self,
+        continuation: Callable[[grpc.aio.ClientCallDetails, Any], Awaitable[Any]],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request: Any,
+    ) -> Any:
+        return await continuation(await self._authenticated_details(client_call_details), request)
+
+
+class _StreamUnaryAuthenticationInterceptor(
+    _AuthenticationInterceptor,
+    grpc.aio.StreamUnaryClientInterceptor,
+):
+    async def intercept_stream_unary(
+        self,
+        continuation: Callable[[grpc.aio.ClientCallDetails, Any], Awaitable[Any]],
+        client_call_details: grpc.aio.ClientCallDetails,
+        request_iterator: Any,
+    ) -> Any:
+        return await continuation(await self._authenticated_details(client_call_details), request_iterator)
+
+
+class _GrpcSyncApiTransport:
+    def __init__(self, options: SyncApiClientOptions) -> None:
+        endpoint = options.validate()
+        self._timeout = options.timeout
+        self._authorization_provider = options.authentication._create_provider()
+        interceptors: list[grpc.aio.ClientInterceptor] = [
+            _UnaryUnaryAuthenticationInterceptor(self._authorization_provider),
+            _StreamUnaryAuthenticationInterceptor(self._authorization_provider),
+        ]
+        channel_options: list[tuple[str, Any]] = []
+        if options.max_receive_message_size is not None:
+            channel_options.append(("grpc.max_receive_message_length", options.max_receive_message_size))
+        if options.max_send_message_size is not None:
+            channel_options.append(("grpc.max_send_message_length", options.max_send_message_size))
+
+        if endpoint.secure:
+            credentials = grpc.ssl_channel_credentials()
+            self._channel = grpc.aio.secure_channel(
+                endpoint.target,
+                credentials,
+                options=channel_options,
+                interceptors=interceptors,
+            )
+        else:
+            self._channel = grpc.aio.insecure_channel(
+                endpoint.target,
+                options=channel_options,
+                interceptors=interceptors,
+            )
+
+        self._grpc_client = SyncServiceStub(self._channel)  # type: ignore[no-untyped-call]
+        self._closed = False
+
+    @property
+    def grpc_client(self) -> SyncServiceStub:
+        return self._grpc_client
+
+    async def start(self, request: StartSyncBatchRequest) -> StartSyncBatchResponse:
+        response = await self._grpc_client.StartSyncBatch(request, timeout=self._timeout)
+        return cast(StartSyncBatchResponse, response)
+
+    async def write(self, request: SyncRecordsRequest) -> SyncRecordsResponse:
+        response = await self._grpc_client.SyncRecords(
+            _single_request(request),
+            timeout=self._timeout,
+        )
+        return cast(SyncRecordsResponse, response)
+
+    async def complete(
+        self,
+        request: CompleteSyncBatchRequest,
+    ) -> CompleteSyncBatchResponse:
+        response = await self._grpc_client.CompleteSyncBatch(request, timeout=self._timeout)
+        return cast(CompleteSyncBatchResponse, response)
+
+    async def abort(self, request: AbortSyncBatchRequest) -> AbortSyncBatchResponse:
+        response = await self._grpc_client.AbortSyncBatch(request, timeout=self._timeout)
+        return cast(AbortSyncBatchResponse, response)
+
+    async def close(self) -> None:
+        if self._closed:
+            return
+        self._closed = True
+        await self._channel.close()
+        await self._authorization_provider.close()
+
+
+async def _single_request(request: SyncRecordsRequest) -> AsyncIterator[SyncRecordsRequest]:
+    yield request

viio_sync_api/v1/__init__.py

@@ -0,0 +1,10 @@
+"""Generated ``viio.sync.v1`` protobuf messages and gRPC service types."""
+
+from .anthropic_pb2 import *  # noqa: F403
+from .bamboo_hr_pb2 import *  # noqa: F403
+from .contracts_pb2 import *  # noqa: F403
+from .contracts_pb2_grpc import SyncServiceStub as SyncServiceStub
+from .generic_pb2 import *  # noqa: F403
+from .google_pb2 import *  # noqa: F403
+from .microsoft_pb2 import *  # noqa: F403
+from .okta_pb2 import *  # noqa: F403

viio_sync_api/v1/anthropic_pb2.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: viio/sync/v1/anthropic.proto
+# Protobuf Python Version: 7.35.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    7,
+    35,
+    1,
+    '',
+    'viio/sync/v1/anthropic.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import timestamp_pb2 as google_dot_protobuf_dot_timestamp__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1cviio/sync/v1/anthropic.proto\x12\x0cviio.sync.v1\x1a\x1fgoogle/protobuf/timestamp.proto\"\xa4\x05\n\x12\x41nthropicChatUsage\x12/\n\x0bstarting_at\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12-\n\tending_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x17\n\naccount_id\x18\x03 \x01(\tH\x00\x88\x01\x01\x12\x17\n\napi_key_id\x18\x04 \x01(\tH\x01\x88\x01\x01\x12\x1f\n\x12service_account_id\x18\x05 \x01(\tH\x02\x88\x01\x01\x12\x19\n\x0cworkspace_id\x18\x06 \x01(\tH\x03\x88\x01\x01\x12\x12\n\x05model\x18\x07 \x01(\tH\x04\x88\x01\x01\x12\x19\n\x0cservice_tier\x18\x08 \x01(\tH\x05\x88\x01\x01\x12\x1b\n\x0e\x63ontext_window\x18\t \x01(\tH\x06\x88\x01\x01\x12\x1a\n\rinference_geo\x18\n \x01(\tH\x07\x88\x01\x01\x12\x1d\n\x15uncached_input_tokens\x18\x0b \x01(\x03\x12\x1f\n\x17\x63\x61\x63he_read_input_tokens\x18\x0c \x01(\x03\x12\x15\n\routput_tokens\x18\r \x01(\x03\x12<\n\x0e\x63\x61\x63he_creation\x18\x0e \x01(\x0b\x32$.viio.sync.v1.AnthropicCacheCreation\x12=\n\x0fserver_tool_use\x18\x0f \x01(\x0b\x32$.viio.sync.v1.AnthropicServerToolUseB\r\n\x0b_account_idB\r\n\x0b_api_key_idB\x15\n\x13_service_account_idB\x0f\n\r_workspace_idB\x08\n\x06_modelB\x0f\n\r_service_tierB\x11\n\x0f_context_windowB\x10\n\x0e_inference_geo\"^\n\x16\x41nthropicCacheCreation\x12!\n\x19\x65phemeral_1h_input_tokens\x18\x01 \x01(\x03\x12!\n\x19\x65phemeral_5m_input_tokens\x18\x02 \x01(\x03\"5\n\x16\x41nthropicServerToolUse\x12\x1b\n\x13web_search_requests\x18\x01 \x01(\x03\"\xdd\x03\n\rAnthropicCost\x12/\n\x0bstarting_at\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12-\n\tending_at\x18\x02 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x0e\n\x06\x61mount\x18\x03 \x01(\t\x12\x10\n\x08\x63urrency\x18\x04 \x01(\t\x12\x19\n\x0cworkspace_id\x18\x05 \x01(\tH\x00\x88\x01\x01\x12\x18\n\x0b\x64\x65scription\x18\x06 \x01(\tH\x01\x88\x01\x01\x12\x16\n\tcost_type\x18\x07 \x01(\tH\x02\x88\x01\x01\x12\x17\n\ntoken_type\x18\x08 \x01(\tH\x03\x88\x01\x01\x12\x12\n\x05model\x18\t \x01(\tH\x04\x88\x01\x01\x12\x19\n\x0cservice_tier\x18\n \x01(\tH\x05\x88\x01\x01\x12\x1b\n\x0e\x63ontext_window\x18\x0b \x01(\tH\x06\x88\x01\x01\x12\x1a\n\rinference_geo\x18\x0c \x01(\tH\x07\x88\x01\x01\x42\x0f\n\r_workspace_idB\x0e\n\x0c_descriptionB\x0c\n\n_cost_typeB\r\n\x0b_token_typeB\x08\n\x06_modelB\x0f\n\r_service_tierB\x11\n\x0f_context_windowB\x10\n\x0e_inference_geo\"\x92\x04\n\x18\x41nthropicClaudeCodeUsage\x12(\n\x04\x64\x61te\x18\x01 \x01(\x0b\x32\x1a.google.protobuf.Timestamp\x12\x35\n\x05\x61\x63tor\x18\x02 \x01(\x0b\x32&.viio.sync.v1.AnthropicClaudeCodeActor\x12\x1c\n\x0forganization_id\x18\x03 \x01(\tH\x00\x88\x01\x01\x12\x1a\n\rcustomer_type\x18\x04 \x01(\tH\x01\x88\x01\x01\x12\x1e\n\x11subscription_type\x18\x05 \x01(\tH\x02\x88\x01\x01\x12\x1a\n\rterminal_type\x18\x06 \x01(\tH\x03\x88\x01\x01\x12\x42\n\x0c\x63ore_metrics\x18\x07 \x01(\x0b\x32,.viio.sync.v1.AnthropicClaudeCodeCoreMetrics\x12\x42\n\x0ctool_actions\x18\x08 \x01(\x0b\x32,.viio.sync.v1.AnthropicClaudeCodeToolActions\x12I\n\x10model_breakdowns\x18\t \x03(\x0b\x32/.viio.sync.v1.AnthropicClaudeCodeModelBreakdownB\x12\n\x10_organization_idB\x10\n\x0e_customer_typeB\x14\n\x12_subscription_typeB\x10\n\x0e_terminal_type\"\x82\x01\n\x18\x41nthropicClaudeCodeActor\x12\x0c\n\x04type\x18\x01 \x01(\t\x12\x1a\n\remail_address\x18\x02 \x01(\tH\x00\x88\x01\x01\x12\x19\n\x0c\x61pi_key_name\x18\x03 \x01(\tH\x01\x88\x01\x01\x42\x10\n\x0e_email_addressB\x0f\n\r_api_key_name\"\xc1\x01\n\x1e\x41nthropicClaudeCodeCoreMetrics\x12\x14\n\x0cnum_sessions\x18\x01 \x01(\x03\x12\x43\n\rlines_of_code\x18\x02 \x01(\x0b\x32,.viio.sync.v1.AnthropicClaudeCodeLinesOfCode\x12\x1e\n\x16\x63ommits_by_claude_code\x18\x03 \x01(\x03\x12$\n\x1cpull_requests_by_claude_code\x18\x04 \x01(\x03\"@\n\x1e\x41nthropicClaudeCodeLinesOfCode\x12\r\n\x05\x61\x64\x64\x65\x64\x18\x01 \x01(\x03\x12\x0f\n\x07removed\x18\x02 \x01(\x03\"\xb0\x02\n\x1e\x41nthropicClaudeCodeToolActions\x12>\n\tedit_tool\x18\x01 \x01(\x0b\x32+.viio.sync.v1.AnthropicClaudeCodeToolAction\x12\x44\n\x0fmulti_edit_tool\x18\x02 \x01(\x0b\x32+.viio.sync.v1.AnthropicClaudeCodeToolAction\x12?\n\nwrite_tool\x18\x03 \x01(\x0b\x32+.viio.sync.v1.AnthropicClaudeCodeToolAction\x12G\n\x12notebook_edit_tool\x18\x04 \x01(\x0b\x32+.viio.sync.v1.AnthropicClaudeCodeToolAction\"C\n\x1d\x41nthropicClaudeCodeToolAction\x12\x10\n\x08\x61\x63\x63\x65pted\x18\x01 \x01(\x03\x12\x10\n\x08rejected\x18\x02 \x01(\x03\"\xb3\x01\n!AnthropicClaudeCodeModelBreakdown\x12\r\n\x05model\x18\x01 \x01(\t\x12\x37\n\x06tokens\x18\x02 \x01(\x0b\x32\'.viio.sync.v1.AnthropicClaudeCodeTokens\x12\x46\n\x0e\x65stimated_cost\x18\x03 \x01(\x0b\x32..viio.sync.v1.AnthropicClaudeCodeEstimatedCost\"f\n\x19\x41nthropicClaudeCodeTokens\x12\r\n\x05input\x18\x01 \x01(\x03\x12\x0e\n\x06output\x18\x02 \x01(\x03\x12\x12\n\ncache_read\x18\x03 \x01(\x03\x12\x16\n\x0e\x63\x61\x63he_creation\x18\x04 \x01(\x03\"D\n AnthropicClaudeCodeEstimatedCost\x12\x10\n\x08\x63urrency\x18\x01 \x01(\t\x12\x0e\n\x06\x61mount\x18\x02 \x01(\x03\x42\x1c\xaa\x02\x19Viio.SyncApi.V1.Contractsb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'viio.sync.v1.anthropic_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  _globals['DESCRIPTOR']._loaded_options = None
+  _globals['DESCRIPTOR']._serialized_options = b'\252\002\031Viio.SyncApi.V1.Contracts'
+  _globals['_ANTHROPICCHATUSAGE']._serialized_start=80
+  _globals['_ANTHROPICCHATUSAGE']._serialized_end=756
+  _globals['_ANTHROPICCACHECREATION']._serialized_start=758
+  _globals['_ANTHROPICCACHECREATION']._serialized_end=852
+  _globals['_ANTHROPICSERVERTOOLUSE']._serialized_start=854
+  _globals['_ANTHROPICSERVERTOOLUSE']._serialized_end=907
+  _globals['_ANTHROPICCOST']._serialized_start=910
+  _globals['_ANTHROPICCOST']._serialized_end=1387
+  _globals['_ANTHROPICCLAUDECODEUSAGE']._serialized_start=1390
+  _globals['_ANTHROPICCLAUDECODEUSAGE']._serialized_end=1920
+  _globals['_ANTHROPICCLAUDECODEACTOR']._serialized_start=1923
+  _globals['_ANTHROPICCLAUDECODEACTOR']._serialized_end=2053
+  _globals['_ANTHROPICCLAUDECODECOREMETRICS']._serialized_start=2056
+  _globals['_ANTHROPICCLAUDECODECOREMETRICS']._serialized_end=2249
+  _globals['_ANTHROPICCLAUDECODELINESOFCODE']._serialized_start=2251
+  _globals['_ANTHROPICCLAUDECODELINESOFCODE']._serialized_end=2315
+  _globals['_ANTHROPICCLAUDECODETOOLACTIONS']._serialized_start=2318
+  _globals['_ANTHROPICCLAUDECODETOOLACTIONS']._serialized_end=2622
+  _globals['_ANTHROPICCLAUDECODETOOLACTION']._serialized_start=2624
+  _globals['_ANTHROPICCLAUDECODETOOLACTION']._serialized_end=2691
+  _globals['_ANTHROPICCLAUDECODEMODELBREAKDOWN']._serialized_start=2694
+  _globals['_ANTHROPICCLAUDECODEMODELBREAKDOWN']._serialized_end=2873
+  _globals['_ANTHROPICCLAUDECODETOKENS']._serialized_start=2875
+  _globals['_ANTHROPICCLAUDECODETOKENS']._serialized_end=2977
+  _globals['_ANTHROPICCLAUDECODEESTIMATEDCOST']._serialized_start=2979
+  _globals['_ANTHROPICCLAUDECODEESTIMATEDCOST']._serialized_end=3047
+# @@protoc_insertion_point(module_scope)