Anthropic messages

@AnthropicMessagesEndpoint.llmeter_invoke
def invoke(self, payload: MessageCreateParams) -> Message:
    """Invoke the Anthropic Messages API (non-streaming)."""
    client_response = self._client.messages.create(**payload)
    return client_response

def process_raw_response(
    self,
    raw_response: Message,
    start_t: float,
    response: InvocationResponse,
) -> None:
    """Parse a non-streaming Anthropic Messages API response.

    Only `text` content blocks are extracted into `response_text`. `thinking` and
    `redacted_thinking` blocks are skipped.

    Args:
        raw_response: The `Message` object returned by the API.
        start_t: Start time of the API call.
        response: The LLMeter response object to be populated in-place.
    """
    response.time_to_last_token = time.perf_counter() - start_t
    response.id = raw_response.id

    # Extract text from content blocks (skip thinking/redacted_thinking)
    response_text = ""
    for block in raw_response.content:
        if block.type == "text":
            response_text += block.text
    response.response_text = response_text

    usage = raw_response.usage
    if usage:
        response.num_tokens_input = getattr(usage, "input_tokens", None)
        response.num_tokens_output = getattr(usage, "output_tokens", None)
        response.num_tokens_input_cached = getattr(
            usage, "cache_read_input_tokens", None
        )

@staticmethod
def create_payload(
    user_message: str,
    max_tokens: int = 256,
    thinking: dict | None = None,
    **kwargs: Any,
) -> MessageCreateParams:
    """Create a payload for the Anthropic Messages API.

    This is a convenience helper.  You can also build the payload dict directly following the
    [Anthropic Messages API reference](https://docs.anthropic.com/en/api/messages)

    Args:
        user_message: The user message text.
        max_tokens: Maximum tokens to generate.  Defaults to 256.
        thinking: Extended thinking configuration.  Common values:

            * ``{"type": "adaptive"}`` -- adaptive thinking
              (recommended for Claude Opus 4.6 / Sonnet 4.6 and later).
            * ``{"type": "enabled", "budget_tokens": 10000}`` -- manual
              thinking budget (deprecated on Claude 4.6+, unsupported on
              Opus 4.7+).
            * ``{"type": "disabled"}`` -- explicitly disable thinking.
            * ``None`` (default) -- omit the parameter, letting the API
              use its default behavior.

            The ``display`` key controls how thinking content is returned
            in streaming responses:

            * ``"summarized"`` (default on most models) -- thinking
              blocks contain summarized text; ``thinking_delta`` events
              stream before the visible text.
            * ``"omitted"`` (default on Opus 4.7 / Mythos) -- thinking
              blocks have an empty ``thinking`` field; no
              ``thinking_delta`` events are emitted, only a
              ``signature_delta``.  This reduces time-to-first-text-token
              when streaming.

            Example with display:

            ```python
            create_payload(
                "Solve this problem",
                max_tokens=16000,
                thinking={
                    "type": "enabled",
                    "budget_tokens": 10000,
                    "display": "omitted",
                },
            )
            ```

        **kwargs: Additional payload parameters (``system``,
            ``temperature``, ``top_p``, ``top_k``, ``stop_sequences``,
            etc.).

    Returns:
        dict: Formatted payload for the Anthropic Messages API.

    Raises:
        ValueError: If ``max_tokens`` is not a positive integer.
        TypeError: If ``user_message`` is not a string.

    Examples:
        Text only:

        ```python
        create_payload("Hello, Claude!")
        ```

        With system prompt:

        ```python
        create_payload(
            "Explain quantum computing",
            system="You are a physics professor.",
            max_tokens=1024,
        )
        ```

        With adaptive thinking:

        ```python
        create_payload(
            "Prove that there are infinitely many primes.",
            max_tokens=16000,
            thinking={"type": "adaptive"},
        )
        ```

        With thinking explicitly disabled:

        ```python
        create_payload(
            "Hello!",
            thinking={"type": "disabled"},
        )
        ```
    """
    if not isinstance(user_message, str):
        raise TypeError(
            f"user_message must be a str, got {type(user_message).__name__}"
        )
    if not isinstance(max_tokens, int) or max_tokens <= 0:
        raise ValueError("max_tokens must be a positive integer")

    payload: dict = {
        "messages": [{"role": "user", "content": user_message}],
        "max_tokens": max_tokens,
    }
    if thinking is not None:
        payload["thinking"] = thinking
    payload.update(kwargs)
    return payload  # type: ignore[return-value]

@AnthropicMessagesEndpoint.llmeter_invoke
def invoke(self, payload: MessageCreateParams) -> Iterable[RawMessageStreamEvent]:
    """Invoke the Anthropic Messages API with streaming."""
    client_response = self._client.messages.create(**payload)
    return client_response

def process_raw_response(
    self,
    raw_response: Iterable[RawMessageStreamEvent],
    start_t: float,
    response: InvocationResponse,
) -> None:
    """Parse a streaming Anthropic Messages API response.

    Processes SSE events to extract text, token counts, and timing.

    Only `text_delta` events contribute to `response_text`. `thinking_delta` and
    `signature_delta` events are used solely for TTFT measurement when
    `ttft_visible_tokens_only` is `False`.

    Args:
        raw_response: The streaming iterator of SSE events.
        start_t: Start time of the API call.
        response: The LLMeter response object to be populated in-place.
    """
    _THINKING_DELTA_TYPES = frozenset(("thinking_delta", "signature_delta"))

    for event in raw_response:
        now = time.perf_counter()
        event_type = event.type

        if event_type == "message_start":
            response.id = event.message.id
            if event.message.usage:
                response.num_tokens_input = getattr(
                    event.message.usage, "input_tokens", None
                )
                response.num_tokens_input_cached = getattr(
                    event.message.usage, "cache_read_input_tokens", None
                )

        elif event_type == "content_block_delta":
            delta = event.delta
            delta_type = getattr(delta, "type", None)

            if delta_type in _THINKING_DELTA_TYPES:
                if (
                    not self.ttft_visible_tokens_only
                    and response.time_to_first_token is None
                ):
                    response.time_to_first_token = now - start_t

            elif delta_type == "text_delta":
                text = getattr(delta, "text", "")
                if text:
                    if response.time_to_first_token is None:
                        response.time_to_first_token = now - start_t
                    if response.response_text is None:
                        response.response_text = text
                    else:
                        response.response_text += text
                    response.time_to_last_token = now - start_t

        elif event_type == "message_delta":
            if event.usage:
                response.num_tokens_output = getattr(
                    event.usage, "output_tokens", None
                )