Openai response

@staticmethod
def create_payload(
    user_message: str | Sequence[str],
    max_output_tokens: int = 256,
    instructions: str | None = None,
    **kwargs,
) -> ResponseCreateParams:
    """Create a payload for the Responses API request.

    This is a convenience helper. You can also build the payload directly
    using ``openai.types.responses.ResponseCreateParams``.

    Args:
        user_message: User message(s) to send (can be string or array of messages)
        max_output_tokens: Maximum tokens in response (default: 256)
        instructions: Optional system-level instructions
        **kwargs: Additional payload parameters (temperature, top_p, text.format, etc.)

    Returns:
        ResponseCreateParams formatted for Responses API
    """
    if isinstance(user_message, str):
        input_value: str | list[dict] = user_message
    else:
        input_value = [{"role": "user", "content": msg} for msg in user_message]

    payload: dict = {
        "input": input_value,
        "max_output_tokens": max_output_tokens,
    }

    if instructions:
        payload["instructions"] = instructions

    payload.update(kwargs)
    return cast(ResponseCreateParams, payload)

@OpenAIEndpointBase.llmeter_invoke
def invoke(self, payload: ResponseCreateParamsNonStreaming) -> Response:
    """Invoke the Responses API."""
    client_response = self._client.responses.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,
    }

@OpenAIEndpointBase.llmeter_invoke
def invoke(self, payload: ResponseCreateParamsStreaming):
    """Invoke the Responses API with streaming."""
    client_response = self._client.responses.create(**payload)
    return client_response

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

def process_raw_response(
    self,
    raw_response: Iterable[ResponseStreamEvent],
    start_t: float,
    response: InvocationResponse,
) -> None:
    """Parse streaming Response API output into InvocationResponse.

    Processes typed events from the stream:

    - `ResponseCreatedEvent`: captures `response.id`
    - `ResponseTextDeltaEvent`: accumulates text deltas, records TTFT
    - `ResponseCompletedEvent`: extracts usage from `response.usage`
    - `ResponseFailedEvent`: captures API-level errors
    - Reasoning events (`response.reasoning_summary_text.delta`,
      `response.reasoning_text.delta`): when `ttft_visible_tokens_only` is ``False``, these set
      TTFT on the first reasoning token.
    """
    _REASONING_DELTA_TYPES = frozenset((
        "response.reasoning_summary_text.delta",
        "response.reasoning_text.delta",
    ))

    for event in raw_response:
        now = time.perf_counter()
        if event.type == "response.created":
            response.id = event.response.id

        elif event.type == "response.output_text.delta":
            if response.response_text is None:
                response.response_text = event.delta
                if response.time_to_first_token is None:
                    response.time_to_first_token = now - start_t
            else:
                response.response_text += event.delta
            response.time_to_last_token = now - start_t

        elif (
            not self.ttft_visible_tokens_only
            and event.type in _REASONING_DELTA_TYPES
        ):
            if response.time_to_first_token is None:
                response.time_to_first_token = now - start_t

        elif event.type == "response.completed":
            usage = event.response.usage
            if usage is not None:
                response.num_tokens_input = usage.input_tokens
                response.num_tokens_output = usage.output_tokens
                details = getattr(usage, "input_tokens_details", None)
                if details:
                    response.num_tokens_input_cached = getattr(
                        details, "cached_tokens", None
                    )
                output_details = getattr(usage, "output_tokens_details", None)
                if output_details:
                    response.num_tokens_output_reasoning = getattr(
                        output_details, "reasoning_tokens", None
                    )

        elif event.type == "response.failed":
            error_obj = getattr(event.response, "error", None)
            if error_obj is not None:
                error_msg = (
                    getattr(error_obj, "message", None) or str(error_obj)
                )
                error_code = getattr(error_obj, "code", None)
                if error_code:
                    error_msg = f"{error_code}: {error_msg}"
            else:
                error_msg = "Response API request failed"
            response.error = error_msg
            response.time_to_last_token = now - start_t