superwise-api 4.17.0__tar.gz → 4.18.0__tar.gz

{superwise_api-4.17.0 → superwise_api-4.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: superwise-api
-Version: 4.17.0
+Version: 4.18.0
 Summary: Superwise SDK for Python
 License: MIT
 Keywords: OpenAPI,SuperwiseSDK
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Pillow (>=10.0.0,<11.0.0)
 Requires-Dist: aenum (>=3.1.11)
+Requires-Dist: aiohttp (==3.13.5)
 Requires-Dist: jsonschema (>=4.26.0,<5.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.7.0,<3.0.0)

{superwise_api-4.17.0 → superwise_api-4.18.0}/pyproject.toml

@@ -1,10 +1,11 @@
 [tool.poetry]
 packages = [{ include = "superwise_api", from = "." }]
-version = "4.17.0"
+version = "4.18.0"
 include = ["superwise_api/client/py.typed"]
 
 [tool.poetry.dependencies]
 urllib3 = ">= 1.25.3"
+aiohttp = "= 3.13.5"
 python-dateutil = ">=2.8.2"
 pydantic = "^2.10.4"
 aenum = ">=3.1.11"

superwise_api-4.18.0/superwise_api/async_client/__init__.py

@@ -0,0 +1,3 @@
+from superwise_api.async_client.client import AsyncSuperwiseClient
+
+__all__ = ["AsyncSuperwiseClient"]

superwise_api-4.18.0/superwise_api/async_client/client.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import aiohttp
+
+from superwise_api.auth import fetch_token_async
+from superwise_api.config import Settings
+from superwise_api.async_client.entities.dataset import AsyncDatasetAPI
+from superwise_api.async_client.entities.sentinel import AsyncSentinelAPI
+from superwise_api.async_client.transport import AiohttpTransport
+
+
+class AsyncSuperwiseClient:
+    """Async Superwise client.
+
+    Two usage patterns:
+
+        # Context manager:
+        async with AsyncSuperwiseClient(client_id="...", client_secret="...") as client:
+            await client.dataset.log_record(...)
+
+        # Caller-supplied session:
+        async with aiohttp.ClientSession() as session:
+            client = AsyncSuperwiseClient(..., session=session)
+            await client.dataset.log_record(...)
+    """
+
+    def __init__(
+        self,
+        client_id: str | None = None,
+        client_secret: str | None = None,
+        auth_host: str | None = None,
+        api_host: str | None = None,
+        use_hosted_auth: bool | None = None,
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        settings = Settings(
+            **{
+                k: v
+                for k, v in dict(
+                    client_id=client_id,
+                    client_secret=client_secret,
+                    auth_host=auth_host,
+                    api_host=api_host,
+                    use_hosted_auth=use_hosted_auth,
+                ).items()
+                if v is not None
+            }
+        )
+
+        async def _token_factory() -> str:
+            return await fetch_token_async(settings.auth_url, settings.client_id, settings.client_secret)
+
+        self._transport = AiohttpTransport(
+            base_url=settings.api_host,
+            token_factory=_token_factory,
+            session=session,
+        )
+        self._dataset = AsyncDatasetAPI(self._transport)
+        self._sentinel = AsyncSentinelAPI(self._transport)
+
+    async def __aenter__(self) -> AsyncSuperwiseClient:
+        await self._transport.__aenter__()
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self._transport.__aexit__()
+
+    @property
+    def dataset(self) -> AsyncDatasetAPI:
+        return self._dataset
+
+    @property
+    def sentinel(self) -> AsyncSentinelAPI:
+        return self._sentinel

superwise_api-4.18.0/superwise_api/async_client/entities/__init__.py

@@ -0,0 +1,4 @@
+from superwise_api.async_client.entities.dataset import AsyncDatasetAPI
+from superwise_api.async_client.entities.sentinel import AsyncSentinelAPI
+
+__all__ = ["AsyncDatasetAPI", "AsyncSentinelAPI"]

superwise_api-4.18.0/superwise_api/async_client/entities/dataset.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from superwise_api.request_builders.dataset_request_builder import (
+    parse_log_batch_response,
+    parse_log_record_response,
+    prepare_log_batch_request,
+    prepare_log_record_request,
+)
+from superwise_api.async_client.transport import AsyncTransport
+
+
+class AsyncDatasetAPI:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def log_record(
+        self,
+        dataset_id: str,
+        data: dict,
+        images: dict[str, tuple[bytes, str]] | None = None,
+    ) -> None:
+        req = prepare_log_record_request(dataset_id, data, images)
+        status, body = await self._transport.execute(req)
+        return parse_log_record_response(status, body)
+
+    async def log_batch(self, dataset_id: str, records: list[dict]) -> dict | None:
+        req = prepare_log_batch_request(dataset_id, records)
+        status, body = await self._transport.execute(req)
+        return parse_log_batch_response(status, body)

superwise_api-4.18.0/superwise_api/async_client/entities/sentinel.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from superwise_api.async_client.transport import AsyncTransport
+from superwise_api.request_builders.sentinel_request_builder import (
+    parse_delete_sentinel_response,
+    parse_sentinel_response,
+    parse_sentinels_response,
+    prepare_create_sentinel_request,
+    prepare_delete_sentinel_request,
+    prepare_get_sentinel_request,
+    prepare_get_sentinels_request,
+    prepare_heartbeat_sentinel_request,
+    prepare_search_sentinels_request,
+    prepare_update_sentinel_request,
+)
+from superwise_api.models.sentinel.sentinel import Sentinel
+
+
+class AsyncSentinelAPI:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._transport = transport
+
+    async def create(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        location: str | None = None,
+        local_guardrail_config: dict[str, Any] | None = None,
+        remote_guardrail_versions: list[str] | None = None,
+    ) -> Sentinel:
+        req = prepare_create_sentinel_request(
+            name, description, location, local_guardrail_config, remote_guardrail_versions
+        )
+        status, body = await self._transport.execute(req)
+        return parse_sentinel_response(status, body)
+
+    async def get(self, page: int | None = None, size: int | None = None) -> list[Sentinel]:
+        req = prepare_get_sentinels_request(page, size)
+        status, body = await self._transport.execute(req)
+        return parse_sentinels_response(status, body)
+
+    async def get_by_id(self, sentinel_id: str) -> Sentinel:
+        req = prepare_get_sentinel_request(sentinel_id)
+        status, body = await self._transport.execute(req)
+        return parse_sentinel_response(status, body)
+
+    async def search(
+        self,
+        filters: list[Any] | None = None,
+        search: list[str] | str | None = None,
+        sort_by: str = "updated_at",
+        sort_direction: str = "desc",
+    ) -> list[Sentinel]:
+        req = prepare_search_sentinels_request(filters, search, sort_by, sort_direction)
+        status, body = await self._transport.execute(req)
+        return parse_sentinels_response(status, body)
+
+    async def update(
+        self,
+        sentinel_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        location: str | None = None,
+        local_guardrail_config: dict[str, Any] | None = None,
+        remote_guardrail_versions: list[str] | None = None,
+    ) -> Sentinel:
+        req = prepare_update_sentinel_request(
+            sentinel_id, name, description, location, local_guardrail_config, remote_guardrail_versions
+        )
+        status, body = await self._transport.execute(req)
+        return parse_sentinel_response(status, body)
+
+    async def heartbeat(self, sentinel_id: str) -> Sentinel:
+        req = prepare_heartbeat_sentinel_request(sentinel_id)
+        status, body = await self._transport.execute(req)
+        return parse_sentinel_response(status, body)
+
+    async def delete(self, sentinel_id: str) -> None:
+        req = prepare_delete_sentinel_request(sentinel_id)
+        status, body = await self._transport.execute(req)
+        return parse_delete_sentinel_response(status, body)

superwise_api-4.18.0/superwise_api/async_client/transport.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Protocol
+
+import aiohttp
+
+from superwise_api.request_builders.requests import PreparedRequest, MultipartRequest
+
+
+class AsyncTransport(Protocol):
+    async def execute(self, req: PreparedRequest) -> tuple[int, bytes]: ...
+
+
+class AiohttpTransport:
+    def __init__(
+        self,
+        base_url: str,
+        token_factory: Callable[[], Awaitable[str]],
+        session: aiohttp.ClientSession | None = None,
+    ) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._token_factory = token_factory
+        self._token: str | None = None
+        self._token_lock = asyncio.Lock()
+        self._session = session
+        self._owns_session = session is None
+
+    async def close(self) -> None:
+        if self._owns_session and self._session is not None:
+            await self._session.__aexit__(None, None, None)
+            self._session = None
+            self._owns_session = False
+
+    async def __aenter__(self) -> AiohttpTransport:
+        if self._session is None:
+            self._session = await aiohttp.ClientSession().__aenter__()
+            self._owns_session = True
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.close()
+
+    async def execute(self, req: PreparedRequest) -> tuple[int, bytes]:
+        if self._token is None:
+            async with self._token_lock:
+                if self._token is None:
+                    self._token = await self._token_factory()
+        status, body = await self._execute(req)
+        if status == 401:
+            stale_token = self._token
+            async with self._token_lock:
+                if self._token == stale_token:
+                    self._token = await self._token_factory()
+            status, body = await self._execute(req)
+        return status, body
+
+    async def _execute(self, req: PreparedRequest) -> tuple[int, bytes]:
+        url = self._base_url + req.path
+        headers = {**req.headers, "Authorization": f"Bearer {self._token}"}
+        body_kwargs = {"data": self._build_form(req)} if req.is_multipart() else req.body_kwargs()
+        async with self._session.request(req.method, url, headers=headers, **body_kwargs) as resp:
+            return resp.status, await resp.read()
+
+    @staticmethod
+    def _build_form(req: MultipartRequest) -> aiohttp.FormData:
+        form = aiohttp.FormData()
+        for f in req.fields:
+            kwargs = {}
+            if f.content_type is not None:
+                kwargs["content_type"] = f.content_type
+            if f.filename is not None:
+                kwargs["filename"] = f.filename
+            form.add_field(f.name, f.data, **kwargs)
+        return form

superwise_api-4.18.0/superwise_api/auth.py

@@ -0,0 +1,40 @@
+import json
+import requests
+import aiohttp
+from dataclasses import dataclass
+
+from superwise_api.client.exceptions import UnauthorizedException
+
+
+@dataclass
+class TokenRequest:
+    url: str
+    headers: dict[str, str]
+    body: dict
+
+
+def prepare_token_request(auth_url: str, client_id: str, client_secret: str) -> TokenRequest:
+    return TokenRequest(
+        url=auth_url,
+        headers={"accept": "application/json", "content-type": "application/json"},
+        body={"clientId": client_id, "secret": client_secret},
+    )
+
+
+def parse_token_response(status_code: int, body: bytes) -> str:
+    if status_code != 200:
+        raise UnauthorizedException(status=status_code, reason=body.decode("utf-8") if body else "")
+    return json.loads(body)["accessToken"]
+
+
+def fetch_token(auth_url: str, client_id: str, client_secret: str) -> str:
+    req = prepare_token_request(auth_url, client_id, client_secret)
+    resp = requests.post(req.url, json=req.body, headers=req.headers)
+    return parse_token_response(resp.status_code, resp.content)
+
+
+async def fetch_token_async(auth_url: str, client_id: str, client_secret: str) -> str:
+    req = prepare_token_request(auth_url, client_id, client_secret)
+    async with aiohttp.ClientSession() as session:
+        async with session.post(req.url, json=req.body, headers=req.headers) as resp:
+            return parse_token_response(resp.status, await resp.read())

{superwise_api-4.17.0 → superwise_api-4.18.0}/superwise_api/entities/dataset.py

@@ -1,12 +1,15 @@
-import json
 from typing import Optional
 
 from pydantic import conint
 
 from superwise_api.client.models.page import Page
 from superwise_api.entities.base import BaseApi, CoreEntitiyApi
+from superwise_api.request_builders.dataset_request_builder import (
+    prepare_log_batch_request,
+    prepare_log_record_request,
+)
+from superwise_api.request_builders.requests import JsonRequest
 from superwise_api.models.dataset.dataset import Dataset, NaturalLanguageQueryResponse, SqlQueryResponse
-from superwise_api.models.dataset.dataset_schema import RecordLogMessage
 from superwise_api.models.dataset_source.dataset_source import DatasetSource
 from superwise_api.models.dataset_source.dataset_source import IngestType
 
@@ -140,7 +143,7 @@ class DatasetApi(CoreEntitiyApi):
             dataset_id (str): The id of the dataset to update.
             name (str, optional): The new name of the dataset.
             description (str, optional): The new description of the dataset.
-            schema (dict, optional): The new schema of the dataset.
+            schema (dict, optional): The schema patch. key_field cannot be changed after creation.
             **kwargs: Arbitrary keyword arguments.
 
         Returns:
@@ -230,37 +233,15 @@ class DatasetApi(CoreEntitiyApi):
         images: dict[str, tuple[bytes, str]] | None = None,
         **kwargs,
     ):
-        """Log a record to a dataset.
-
-        Args:
-            dataset_id: The dataset id.
-            data: Record data as a dict.
-            images: Optional image uploads keyed by schema field name.
-                Each value is a ``(image_bytes, content_type)`` tuple,
-                e.g. ``{"photo": (raw_bytes, "image/jpeg")}``.
-        """
-        if images:
-            return self._log_record_with_images(dataset_id, data, images, **kwargs)
-        return self.api_client.post(
-            resource_path=f"{self._resource_path}/{dataset_id}/log",
-            data=RecordLogMessage(record=data).model_dump(),
-            **kwargs,
-        )
-
-    def _log_record_with_images(
-        self,
-        dataset_id: str,
-        data: dict,
-        images: dict[str, tuple[bytes, str]],
-        **kwargs,
-    ):
-        """Send a multipart/form-data log request with embedded images."""
-        post_params = [("record", json.dumps(data))]
-        for field_name, (image_bytes, content_type) in images.items():
-            post_params.append((field_name, (field_name, image_bytes, content_type)))
-
+        req = prepare_log_record_request(dataset_id, data, images)
+        if isinstance(req, JsonRequest):
+            return self.api_client.post(resource_path=req.path, data=req.body, **kwargs)
+        post_params = [
+            (f.name, (f.filename or f.name, f.data, f.content_type)) if f.content_type else (f.name, f.data)
+            for f in req.fields
+        ]
         return self.api_client.call_api(
-            f"{self._resource_path}/{dataset_id}/log",
+            req.path,
             "POST",
             header_params={"Content-Type": "multipart/form-data"},
             post_params=post_params,
@@ -271,17 +252,12 @@ class DatasetApi(CoreEntitiyApi):
         )
 
     def log_batch_to_dataset(self, dataset_id: str, records: list[dict]) -> dict:
-        """Log multiple records via ``POST /v1/datasets/log-batch`` (JSON body, ``x-dataset-id`` header).
-
-        Each item in ``records`` is the inner record dict (field names → values), e.g. for ``image_link``
-        fields use ``{"type": "image_link", "url": "https://..."}`` per schema.
-        """
-        body = [RecordLogMessage(record=r).model_dump() for r in records]
+        req = prepare_log_batch_request(dataset_id, records)
         return self.api_client.call_api(
-            f"{self._resource_path}/log-batch",
+            req.path,
             "POST",
             header_params={"x-dataset-id": dataset_id},
-            body=body,
+            body=req.body,
             response_types_map={"202": object},
             auth_settings=["implicit"],
             _return_http_data_only=True,
@@ -308,7 +284,7 @@ class DatasetApi(CoreEntitiyApi):
             ``(content_type, image_bytes)`` tuple,
             e.g. ``("image/jpeg", b"\\xff\\xd8...")``.
         """
-        payload = {"dataset_id": dataset_id, "image_id": image_id, "thumbnail": thumbnail}
+        payload = {"image_id": image_id, "thumbnail_size": "small" if thumbnail else None}
 
         response = self.api_client.call_api(
             f"{self._resource_path}/get-media",

{superwise_api-4.17.0 → superwise_api-4.18.0}/superwise_api/entities/destination.py

@@ -7,6 +7,7 @@ from superwise_api.models.destination.destination import (
     TeamsDestinationTestRequest,
     SlackDestinationTestRequest,
     EmailDestinationTestRequest,
+    WebhookDestinationTestRequest,
     DestinationParams,
     DestinationType,
 )
@@ -66,6 +67,7 @@ class DestinationApi(BaseApi):
             integration_type (str): The type of the integration.
             params (DestinationParams): The parameters of the destination.
             integration_id (str | None): The id of the integration. Required for Slack destinations.
+                Omit for Teams, Email, and Webhook (self-serve integration types).
             **kwargs: Arbitrary keyword arguments.
 
         Returns:
@@ -129,14 +131,21 @@ class DestinationApi(BaseApi):
 
     def test_connection(
         self,
-        request: TeamsDestinationTestRequest | SlackDestinationTestRequest | EmailDestinationTestRequest,
+        request: (
+            TeamsDestinationTestRequest
+            | SlackDestinationTestRequest
+            | EmailDestinationTestRequest
+            | WebhookDestinationTestRequest
+        ),
         **kwargs,
     ) -> None:
         """
-        Test a webhook connection by sending a test notification.
+        Test a destination by sending a test notification.
 
         Args:
-            request (TeamsDestinationTestRequest | SlackDestinationTestRequest | EmailDestinationTestRequest): The test connection request payload.
+            request: The test connection request payload. One of
+                ``TeamsDestinationTestRequest``, ``SlackDestinationTestRequest``,
+                ``EmailDestinationTestRequest``, or ``WebhookDestinationTestRequest``.
             **kwargs: Arbitrary keyword arguments.
         """
         self.api_client.post(

superwise_api-4.18.0/superwise_api/entities/sentinel.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Any
+
+from superwise_api.client.models.page import Page
+from superwise_api.entities.base import BaseApi
+from superwise_api.request_builders.sentinel_request_builder import (
+    prepare_delete_sentinel_request,
+    prepare_get_sentinel_request,
+    prepare_get_sentinels_request,
+    prepare_heartbeat_sentinel_request,
+    prepare_search_sentinels_request,
+    prepare_create_sentinel_request,
+    prepare_update_sentinel_request,
+)
+from superwise_api.models.sentinel.sentinel import Sentinel
+
+
+class SentinelApi(BaseApi):
+    _model_name = "sentinel"
+    _resource_path = "/v1/sentinels"
+    _model_class = Sentinel
+
+    def create(
+        self,
+        name: str | None = None,
+        description: str | None = None,
+        location: str | None = None,
+        local_guardrail_config: dict[str, Any] | None = None,
+        remote_guardrail_versions: list[str] | None = None,
+    ) -> Sentinel:
+        req = prepare_create_sentinel_request(
+            name, description, location, local_guardrail_config, remote_guardrail_versions
+        )
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=req.body,
+            response_types_map={"201": Sentinel, "401": None, "422": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    def get(self, page: int | None = None, size: int | None = None) -> Page:
+        req = prepare_get_sentinels_request(page, size)
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            query_params=req.query_params,
+            body=None,
+            response_types_map={"200": Page.set_model(Sentinel), "422": None, "500": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    def get_by_id(self, sentinel_id: str, **kwargs) -> Sentinel:
+        req = prepare_get_sentinel_request(sentinel_id)
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=None,
+            response_types_map={"200": Sentinel, "404": None, "422": None, "500": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    @BaseApi.raise_exception
+    def search(
+        self,
+        filters: list[Any] | None = None,
+        search: list[str] | str | None = None,
+        sort_by: str = "updated_at",
+        sort_direction: str = "desc",
+    ) -> Page:
+        req = prepare_search_sentinels_request(filters, search, sort_by, sort_direction)
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=req.body,
+            response_types_map={"200": Page.set_model(Sentinel), "422": None, "500": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    def update(
+        self,
+        sentinel_id: str,
+        name: str | None = None,
+        description: str | None = None,
+        location: str | None = None,
+        local_guardrail_config: dict[str, Any] | None = None,
+        remote_guardrail_versions: list[str] | None = None,
+    ) -> Sentinel:
+        req = prepare_update_sentinel_request(
+            sentinel_id, name, description, location, local_guardrail_config, remote_guardrail_versions
+        )
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=req.body,
+            response_types_map={"200": Sentinel, "404": None, "422": None, "500": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    @BaseApi.raise_exception
+    def heartbeat(self, sentinel_id: str) -> Sentinel:
+        req = prepare_heartbeat_sentinel_request(sentinel_id)
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=req.body,
+            response_types_map={"200": Sentinel, "404": None, "500": None},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )
+
+    def delete(self, sentinel_id: str, **kwargs) -> None:
+        req = prepare_delete_sentinel_request(sentinel_id)
+        return self.api_client.call_api(
+            req.path,
+            req.method,
+            header_params=req.headers,
+            body=None,
+            response_types_map={},
+            auth_settings=["implicit"],
+            _return_http_data_only=True,
+            _preload_content=True,
+        )

{superwise_api-4.17.0 → superwise_api-4.18.0}/superwise_api/models/agent/agent.py

@@ -39,34 +39,38 @@ class OpenAIModelVersion(str, Enum):
     GPT_4_1 = "gpt-4.1"
     GPT_4_1_MINI = "gpt-4.1-mini"
     GPT_4_1_NANO = "gpt-4.1-nano"
-    CHATGPT_4O_LATEST = "chatgpt-4o-latest"
     O1 = "o1"
-    O3_MINI = "o3-mini"
     O3 = "o3"
-    GPT_5_2 = "gpt-5.2"
-    GPT_5_NANO = "gpt-5-nano"
+    O3_MINI = "o3-mini"
     GPT_5 = "gpt-5"
     GPT_5_MINI = "gpt-5-mini"
+    GPT_5_NANO = "gpt-5-nano"
+    GPT_5_1 = "gpt-5.1"
+    GPT_5_2 = "gpt-5.2"
+    GPT_5_4 = "gpt-5.4"
+    GPT_5_4_MINI = "gpt-5.4-mini"
+    GPT_5_4_NANO = "gpt-5.4-nano"
+    GPT_5_5 = "gpt-5.5"
 
 
 class GoogleModelVersion(str, Enum):
-    GEMINI_2_0_FLASH = "models/gemini-2.0-flash"
-    GEMINI_2_0_FLASH_LITE = "models/gemini-2.0-flash-lite"
-    GEMINI_2_0_FLASH_EXP = "models/gemini-2.0-flash-exp"
-    GEMINI_2_0_FLASH_THINKING_EXP = "models/gemini-2.0-flash-thinking-exp"
-    GEMINI_2_5_FLASH = "models/gemini-2.5-flash"
     GEMINI_2_5_PRO = "models/gemini-2.5-pro"
+    GEMINI_2_5_FLASH = "models/gemini-2.5-flash"
     GEMINI_2_5_FLASH_LITE = "models/gemini-2.5-flash-lite"
-    GEMINI_3_PRO = "models/gemini-3-pro-preview"
     GEMINI_3_FLASH = "models/gemini-3-flash-preview"
+    GEMINI_3_1_PRO = "models/gemini-3.1-pro-preview"
+    GEMINI_3_1_FLASH_LITE = "models/gemini-3.1-flash-lite"
+    GEMINI_3_5_FLASH = "models/gemini-3.5-flash"
 
 
 class AnthropicModelVersion(str, Enum):
-    CLAUDE_SONNET_4 = "claude-sonnet-4-0"
     CLAUDE_OPUS_4 = "claude-opus-4-0"
-    CLAUDE_OPUS_4_5 = "claude-opus-4-5"
     CLAUDE_OPUS_4_1 = "claude-opus-4-1"
+    CLAUDE_OPUS_4_5 = "claude-opus-4-5"
+    CLAUDE_OPUS_4_6 = "claude-opus-4-6"
+    CLAUDE_SONNET_4 = "claude-sonnet-4-0"
     CLAUDE_SONNET_4_5 = "claude-sonnet-4-5"
+    CLAUDE_SONNET_4_6 = "claude-sonnet-4-6"
     CLAUDE_HAIKU_4_5 = "claude-haiku-4-5"