Openai

@OpenAIEndpoint.llmeter_invoke
def invoke(self, payload: CompletionCreateParamsNonStreaming) -> ChatCompletion:
    """Invoke the OpenAI chat completion API."""
    client_response: ChatCompletion = self._client.chat.completions.create(
        **payload
    )
    return client_response

def prepare_payload(self, payload):
    """Ensure payload specifies correct model ID and streaming disabled"""
    return {
        **payload,
        "model": self.model_id,
        "stream": False,
    }

@OpenAIEndpoint.llmeter_invoke
def invoke(self, payload: CompletionCreateParamsStreaming):
    """Invoke the OpenAI streaming chat completion API."""
    client_response = self._client.chat.completions.create(**payload)
    return client_response

def prepare_payload(self, payload):
    """Ensure payload specifies correct model ID and streaming settings"""
    payload = {
        **payload,
        "model": self.model_id,
        "stream": True,
    }
    if not payload.get("stream_options"):
        payload["stream_options"] = {"include_usage": True}
    return payload

def process_raw_response(
    self,
    raw_response: Iterable[ChatCompletionChunk],
    start_t: float,
    response: InvocationResponse,
) -> None:
    """Parse the streaming API response from OpenAI chat completion API."""
    got_chunk_id = False
    for chunk in raw_response:
        now = time.perf_counter()

        if not got_chunk_id and chunk.id is not None:
            response.id = chunk.id
            got_chunk_id = True

        if chunk.choices:
            content = chunk.choices[0].delta.content
            if content:
                if response.response_text is None:
                    response.time_to_first_token = now - start_t
                    response.response_text = content
                else:
                    response.response_text += content
                response.time_to_last_token = now - start_t

        if chunk.usage is not None:
            response.num_tokens_input = chunk.usage.prompt_tokens
            response.num_tokens_output = chunk.usage.completion_tokens
            if chunk.usage.prompt_tokens_details:
                response.num_tokens_input_cached = getattr(
                    chunk.usage.prompt_tokens_details, "cached_tokens", None
                )
            if chunk.usage.completion_tokens_details:
                response.num_tokens_output_reasoning = getattr(
                    chunk.usage.completion_tokens_details,
                    "reasoning_tokens",
                    None,
                )

@staticmethod
def create_payload(
    user_message: str | list[ContentItem], max_tokens: int = 256, **kwargs: Any
) -> CompletionCreateParams:
    """Create a payload for the OpenAI Chat Completions API request.

    This is a convenience helper. You can also build the payload directly
    using ``openai.types.chat.CompletionCreateParams`` (though the `model`
    field is optional).

    Args:
        user_message: A single text string, or an ordered list mixing strings
            and :class:`~llmeter.prompt_utils.MediaContent` objects.
        max_tokens: Maximum tokens in response. Defaults to 256.
        **kwargs: Additional payload parameters.

    Returns:
        dict: Formatted OpenAI CompletionCreateParams input payload

    Examples:
        Text only::

            create_payload("Hello")

        Image with text::

            create_payload([
                ImageContent.from_path("photo.jpg"),
                "What's in this image?",
            ])

    """
    if not isinstance(max_tokens, int) or max_tokens <= 0:
        raise ValueError("max_tokens must be a positive integer")

    if isinstance(user_message, str):
        items: list[ContentItem] = [user_message]
    elif isinstance(user_message, list):
        items = user_message
    else:
        raise TypeError(
            "user_message must be a str or list of str/MediaContent, "
            f"got {type(user_message).__name__}"
        )

    if not items:
        raise ValueError("user_message must not be empty")

    # Text-only shortcut: single string → simple content field
    if len(items) == 1 and isinstance(items[0], str):
        payload = {
            "messages": [{"role": "user", "content": items[0]}],
            "max_tokens": max_tokens,
        }
    else:
        content_blocks = _build_content_blocks_openai(items)
        payload = {
            "messages": [{"role": "user", "content": content_blocks}],
            "max_tokens": max_tokens,
        }
    payload.update(kwargs)
    return cast(CompletionCreateParams, payload)