feat: wrap /v1/messages/count_tokens (regenerate core + ergonomic method)

The gateway spec gained POST /v1/messages/count_tokens, which the
endpoint-coverage drift gate flagged as unaccounted-for (CI red on main).

This regenerates the client core to include the count_tokens operation
(absorbs the open codegen PR) and adds a hand-written count_tokens()
ergonomic method to the sync and async shells, mirroring message(). It
returns a typed CountTokensResponse and omits max_tokens, since the
endpoint only counts input tokens. The endpoint is listed under
[covered] in sdk-endpoints.txt and covered by sync + async unit tests.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: njbrake

sdk-endpoints.txt

@@ -16,6 +16,7 @@
 POST /v1/chat/completions
 POST /v1/responses
 POST /v1/messages
+POST /v1/messages/count_tokens
 POST /v1/embeddings
 POST /v1/moderations
 POST /v1/rerank

src/otari/async_client.py

@@ -43,6 +43,7 @@
 from otari._client.api.responses_api import ResponsesApi
 from otari._client.exceptions import ApiException
 from otari._client.models.chat_completion_request import ChatCompletionRequest
+from otari._client.models.count_tokens_request import CountTokensRequest
 from otari._client.models.create_batch_request import CreateBatchRequest
 from otari._client.models.embedding_request import EmbeddingRequest
 from otari._client.models.messages_request import MessagesRequest
@@ -57,6 +58,7 @@
 
     from otari._client.models.chat_completion import ChatCompletion
     from otari._client.models.chat_completion_chunk import ChatCompletionChunk
+    from otari._client.models.count_tokens_response import CountTokensResponse
     from otari._client.models.create_embedding_response import CreateEmbeddingResponse
     from otari._client.models.model_object import ModelObject
     from otari._client.models.moderation_response import ModerationResponse
@@ -231,6 +233,25 @@ async def message(
         request = build_request(MessagesRequest, body)
         return await self._call(lambda: self._messages.create_message_v1_messages_post(request))
 
+    async def count_tokens(
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> CountTokensResponse:
+        """Count input tokens for an Anthropic-style message request.
+
+        Calls the gateway ``/v1/messages/count_tokens`` endpoint, which counts
+        the tokens a ``/messages`` request would consume without generating a
+        response. Returns a typed ``CountTokensResponse``.
+        """
+        request = build_request(CountTokensRequest, {"model": model, "messages": messages, **kwargs})
+        result = await self._call(
+            lambda: self._messages.count_message_tokens_v1_messages_count_tokens_post(request)
+        )
+        return cast("CountTokensResponse", result)
+
     # -- Embeddings ---------------------------------------------------------
 
     async def embedding(

src/otari/client.py

@@ -43,6 +43,7 @@
 from otari._client.api.responses_api import ResponsesApi
 from otari._client.exceptions import ApiException
 from otari._client.models.chat_completion_request import ChatCompletionRequest
+from otari._client.models.count_tokens_request import CountTokensRequest
 from otari._client.models.create_batch_request import CreateBatchRequest
 from otari._client.models.embedding_request import EmbeddingRequest
 from otari._client.models.messages_request import MessagesRequest
@@ -57,6 +58,7 @@
 
     from otari._client.models.chat_completion import ChatCompletion
     from otari._client.models.chat_completion_chunk import ChatCompletionChunk
+    from otari._client.models.count_tokens_response import CountTokensResponse
     from otari._client.models.create_embedding_response import CreateEmbeddingResponse
     from otari._client.models.model_object import ModelObject
     from otari._client.models.moderation_response import ModerationResponse
@@ -254,6 +256,32 @@ def message(
         request = build_request(MessagesRequest, body)
         return self._call(lambda: self._messages.create_message_v1_messages_post(request))
 
+    def count_tokens(
+        self,
+        *,
+        model: str,
+        messages: list[dict[str, Any]],
+        **kwargs: Any,
+    ) -> CountTokensResponse:
+        """Count input tokens for an Anthropic-style message request.
+
+        Calls the gateway ``/v1/messages/count_tokens`` endpoint, which counts
+        the tokens a ``/messages`` request would consume without generating a
+        response. Returns a typed
+        :class:`~otari._client.models.count_tokens_response.CountTokensResponse`.
+
+        Args:
+            model: Model identifier (e.g. ``"anthropic:claude-3-5-sonnet"``).
+            messages: Anthropic-style message list.
+            **kwargs: Additional count-tokens parameters (``system``, ``tools``,
+                ``tool_choice``, ``thinking``, ...).
+        """
+        request = build_request(CountTokensRequest, {"model": model, "messages": messages, **kwargs})
+        result = self._call(
+            lambda: self._messages.count_message_tokens_v1_messages_count_tokens_post(request),
+        )
+        return cast("CountTokensResponse", result)
+
     # -- Embeddings ---------------------------------------------------------
 
     def embedding(

tests/unit/test_async_client.py

@@ -28,6 +28,7 @@
 )
 from tests.unit.test_client import (
     CHAT_RESPONSE,
+    COUNT_TOKENS_RESPONSE,
     EMBEDDING_RESPONSE,
     MESSAGE_RESPONSE,
     MODELS_RESPONSE,
@@ -87,6 +88,15 @@ async def test_message_returns_typed(self, mock_rest: Any) -> None:
         assert result.id == "msg-1"
         assert mock.last.url.endswith("/v1/messages")
 
+    async def test_count_tokens_returns_typed(self, mock_rest: Any) -> None:
+        mock = mock_rest(status=200, body=COUNT_TOKENS_RESPONSE)
+        client = AsyncOtariClient(api_base="http://localhost:8000", api_key="vk")
+        result = await client.count_tokens(
+            model="anthropic:claude", messages=[{"role": "user", "content": "Hi"}]
+        )
+        assert result.input_tokens == 42
+        assert mock.last.url.endswith("/v1/messages/count_tokens")
+
     async def test_list_models_returns_typed(self, mock_rest: Any) -> None:
         mock_rest(status=200, body=MODELS_RESPONSE)
         client = AsyncOtariClient(api_base="http://localhost:8000", api_key="vk")

tests/unit/test_client.py

@@ -64,6 +64,8 @@
     "usage": {"input_tokens": 1, "output_tokens": 1},
 }
 
+COUNT_TOKENS_RESPONSE: dict[str, Any] = {"input_tokens": 42}
+
 MODERATION_RESPONSE: dict[str, Any] = {
     "id": "modr-1",
     "model": "openai:omni-moderation-latest",
@@ -213,6 +215,19 @@ def test_returns_typed_message_response(self, mock_rest: Any) -> None:
         assert body["max_tokens"] == 64
         assert body["model"] == "anthropic:claude-3-5-sonnet"
 
+    def test_count_tokens_returns_typed_response(self, mock_rest: Any) -> None:
+        mock = mock_rest(status=200, body=COUNT_TOKENS_RESPONSE)
+        client = OtariClient(api_base="http://localhost:8000", api_key="vk")
+        result = client.count_tokens(
+            model="anthropic:claude-3-5-sonnet",
+            messages=[{"role": "user", "content": "Hi"}],
+        )
+        assert result.input_tokens == 42
+        assert mock.last.url.endswith("/v1/messages/count_tokens")
+        body = mock.last.json_body
+        assert body["model"] == "anthropic:claude-3-5-sonnet"
+        assert "max_tokens" not in body
+
 
 class TestModeration:
     def test_returns_typed_moderation(self, mock_rest: Any) -> None: