ogx_open_client 1.0.3.dev0__py3-none-any.whl

ogx_client/api/responses_api.py

@@ -0,0 +1,1876 @@
+# coding: utf-8
+
+# Copyright (c) The OGX Contributors.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+"""
+    OGX Specification - Stable & Experimental APIs
+
+    This is the specification of the OGX that provides                     a set of endpoints and their corresponding interfaces that are     tailored to                     best leverage Llama Models.      **🔗 COMBINED**: This specification includes both stable production-ready APIs     and experimental pre-release APIs. Use stable APIs for production deployments     and experimental APIs for testing new features.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+import importlib
+import json
+import logging
+import re
+import sys
+import warnings
+
+from pydantic import validate_call, Field, SkipValidation, StrictFloat, StrictStr, StrictInt
+from typing import Any
+from typing_extensions import Annotated
+
+from pydantic import Field, StrictInt, StrictStr
+from typing import Any, Optional
+from typing_extensions import Annotated
+from ogx_client.models.compact_response_request import CompactResponseRequest
+from ogx_client.models.create_response_request import CreateResponseRequest
+from ogx_client.models.list_open_ai_response_object import ListOpenAIResponseObject
+from ogx_client.models.open_ai_compacted_response import OpenAICompactedResponse
+from ogx_client.models.open_ai_delete_response_object import OpenAIDeleteResponseObject
+from ogx_client.models.open_ai_response_object import OpenAIResponseObject
+
+from ogx_client.api_client import ApiClient, RequestSerialized
+from ogx_client.api_response import ApiResponse
+from ogx_client.rest import RESTResponseType
+from ogx_client.stream import Stream
+from ogx_client.lib._utils import pascal_to_snake_case
+from ogx_client.api.input_items_api import InputItemsApi
+
+
+class ResponsesApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+        self.input_items: Optional[InputItemsApi] = None
+        self.logger = logging.getLogger(ResponsesApi.__name__)
+
+        # Child API attributes (set by OgxClient based on x-nesting-path)
+
+
+    def _create_event_stream(self, response_data: RESTResponseType, stream_type_name: str) -> Stream[Any]:
+        """Create a typed event stream from an SSE response.
+
+        Args:
+            response_data: The raw HTTP response containing the SSE stream.
+            stream_type_name: The schema name for the streaming response type
+                (e.g., 'OpenAIChatCompletionChunk', 'OpenAIResponseObjectStream').
+        """
+        # Import the stream type class once
+        stream_class = None
+        discriminator_map = None
+        discriminator_property = None
+        try:
+            module_name = pascal_to_snake_case(stream_type_name)
+            model_module = importlib.import_module('ogx_client.models.' + module_name)
+            stream_class = getattr(model_module, stream_type_name)
+            # Check if the stream type has a discriminator (e.g., oneOf with propertyName)
+            discriminator_map = getattr(stream_class, 'discriminator_value_class_map', None)
+            discriminator_property = getattr(stream_class, 'discriminator_property_name', None)
+        except (ImportError, ModuleNotFoundError, AttributeError) as e:
+            self.logger.debug(f"Could not import stream type {stream_type_name}: {e}")
+
+        def stream_decoder(data_str: str) -> Any:
+            if not data_str:
+                return None
+            try:
+                data = json.loads(data_str)
+            except json.JSONDecodeError:
+                return data_str
+
+            # If we have a discriminator, resolve the specific variant class
+            if discriminator_map and discriminator_property:
+                disc_value = data.get(discriminator_property, '')
+                variant_class_name = discriminator_map.get(disc_value)
+                if variant_class_name:
+                    try:
+                        variant_module_name = pascal_to_snake_case(variant_class_name)
+                        variant_module = importlib.import_module('ogx_client.models.' + variant_module_name)
+                        variant_class = getattr(variant_module, variant_class_name)
+                        return variant_class.from_dict(data)
+                    except Exception as e:
+                        self.logger.debug(f"Failed to deserialize as {variant_class_name}: {e}")
+
+            # Non-discriminated: deserialize as stream type directly
+            if stream_class is not None:
+                try:
+                    result = stream_class.from_dict(data)
+                    # Unwrap oneOf/anyOf wrappers
+                    if hasattr(result, 'actual_instance') and result.actual_instance is not None:
+                        return result.actual_instance
+                    return result
+                except Exception as e:
+                    self.logger.debug(f"Failed to deserialize as {stream_type_name}: {e}")
+
+            # Final fallback: return raw dict
+            return data
+
+        return Stream(
+            response=response_data.response,
+            client=self.api_client,
+            decoder=stream_decoder,
+        )
+
+
+    @validate_call
+    def compact(
+        self,
+        compact_response_request: CompactResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> OpenAICompactedResponse:
+        """Compact a conversation. [alpha]
+
+        **[alpha]** Compresses conversation history into a smaller representation while preserving context. This endpoint is in alpha and may change without notice.
+
+        :param compact_response_request: (required)
+        :type compact_response_request: CompactResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if compact_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                compact_response_request = CompactResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                compact_response_request = CompactResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._compact_serialize(
+            compact_response_request=compact_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAICompactedResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def compact_with_http_info(
+        self,
+        compact_response_request: CompactResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> ApiResponse[OpenAICompactedResponse]:
+        """Compact a conversation. [alpha]
+
+        **[alpha]** Compresses conversation history into a smaller representation while preserving context. This endpoint is in alpha and may change without notice.
+
+        :param compact_response_request: (required)
+        :type compact_response_request: CompactResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if compact_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                compact_response_request = CompactResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                compact_response_request = CompactResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._compact_serialize(
+            compact_response_request=compact_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAICompactedResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def compact_without_preload_content(
+        self,
+        compact_response_request: CompactResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> RESTResponseType:
+        """Compact a conversation. [alpha]
+
+        **[alpha]** Compresses conversation history into a smaller representation while preserving context. This endpoint is in alpha and may change without notice.
+
+        :param compact_response_request: (required)
+        :type compact_response_request: CompactResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if compact_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                compact_response_request = CompactResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                compact_response_request = CompactResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._compact_serialize(
+            compact_response_request=compact_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAICompactedResponse",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _compact_serialize(
+        self,
+        compact_response_request,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if compact_response_request is not None:
+            _body_params = compact_response_request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'application/x-www-form-urlencoded'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/responses/compact',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def create(
+        self,
+        create_response_request: CreateResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> OpenAIResponseObject | Stream[OpenAIResponseObject]:
+        """Create a model response.
+
+        Create a model response.
+
+        :param create_response_request: (required)
+        :type create_response_request: CreateResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_response_request = CreateResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_response_request = CreateResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_response_request=create_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "OpenAIResponseObjectStream")
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def create_with_http_info(
+        self,
+        create_response_request: CreateResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> ApiResponse[OpenAIResponseObject] | Stream[OpenAIResponseObject]:
+        """Create a model response.
+
+        Create a model response.
+
+        :param create_response_request: (required)
+        :type create_response_request: CreateResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_response_request = CreateResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_response_request = CreateResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_response_request=create_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        # Check if this is a streaming response
+        content_type = response_data.response.headers.get('Content-Type', '')
+        if 'text/event-stream' in content_type:
+            return self._create_event_stream(response_data, "OpenAIResponseObjectStream")
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def create_without_preload_content(
+        self,
+        create_response_request: CreateResponseRequest | None = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+        **kwargs: Any
+    ) -> RESTResponseType:
+        """Create a model response.
+
+        Create a model response.
+
+        :param create_response_request: (required)
+        :type create_response_request: CreateResponseRequest
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+        # If body param not provided, construct from kwargs
+        if create_response_request is None and kwargs:
+            try:
+                # Try proper type conversion via from_json
+                create_response_request = CreateResponseRequest.from_json(json.dumps(kwargs))
+            except Exception:
+                # Fall back to lenient construction for complex/flexible types
+                # Server will still validate the final request
+                create_response_request = CreateResponseRequest.model_construct(**kwargs)
+        
+
+        _param = self._create_serialize(
+            create_response_request=create_response_request,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _create_serialize(
+        self,
+        create_response_request,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if create_response_request is not None:
+            _body_params = create_response_request
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json', 
+                    'text/event-stream'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json', 
+                        'application/x-www-form-urlencoded'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/responses',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def openai_response_v1_responses_response_id_cancel_post(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> OpenAIResponseObject:
+        """Cancel a background response that is in progress.
+
+        Cancel a background response that is queued or in progress. Only responses created with background=true can be cancelled.
+
+        :param response_id: The ID of the OpenAI response to cancel. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._openai_response_v1_responses_response_id_cancel_post_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '404': None,
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def openai_response_v1_responses_response_id_cancel_post_with_http_info(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[OpenAIResponseObject]:
+        """Cancel a background response that is in progress.
+
+        Cancel a background response that is queued or in progress. Only responses created with background=true can be cancelled.
+
+        :param response_id: The ID of the OpenAI response to cancel. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._openai_response_v1_responses_response_id_cancel_post_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '404': None,
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def openai_response_v1_responses_response_id_cancel_post_without_preload_content(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to cancel.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """Cancel a background response that is in progress.
+
+        Cancel a background response that is queued or in progress. Only responses created with background=true can be cancelled.
+
+        :param response_id: The ID of the OpenAI response to cancel. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._openai_response_v1_responses_response_id_cancel_post_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+            '404': None,
+            '409': None,
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _openai_response_v1_responses_response_id_cancel_post_serialize(
+        self,
+        response_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        if response_id is not None:
+            _path_params['response_id'] = response_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/responses/{response_id}/cancel',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def delete(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to delete.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> OpenAIDeleteResponseObject:
+        """Delete a response.
+
+        Delete a response.
+
+        :param response_id: The ID of the OpenAI response to delete. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._delete_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIDeleteResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def delete_with_http_info(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to delete.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[OpenAIDeleteResponseObject]:
+        """Delete a response.
+
+        Delete a response.
+
+        :param response_id: The ID of the OpenAI response to delete. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._delete_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIDeleteResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def delete_without_preload_content(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to delete.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """Delete a response.
+
+        Delete a response.
+
+        :param response_id: The ID of the OpenAI response to delete. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._delete_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIDeleteResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _delete_serialize(
+        self,
+        response_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        if response_id is not None:
+            _path_params['response_id'] = response_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='DELETE',
+            resource_path='/v1/responses/{response_id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def retrieve(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> OpenAIResponseObject:
+        """Get a model response.
+
+        Get a model response.
+
+        :param response_id: The ID of the OpenAI response to retrieve. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def retrieve_with_http_info(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[OpenAIResponseObject]:
+        """Get a model response.
+
+        Get a model response.
+
+        :param response_id: The ID of the OpenAI response to retrieve. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def retrieve_without_preload_content(
+        self,
+        response_id: Annotated[StrictStr, Field(description="The ID of the OpenAI response to retrieve.")],
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """Get a model response.
+
+        Get a model response.
+
+        :param response_id: The ID of the OpenAI response to retrieve. (required)
+        :type response_id: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._retrieve_serialize(
+            response_id=response_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "OpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _retrieve_serialize(
+        self,
+        response_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        if response_id is not None:
+            _path_params['response_id'] = response_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/responses/{response_id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+    @validate_call
+    def list(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="The ID of the last response to return.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="The number of responses to return.")] = None,
+        model: Annotated[Optional[StrictStr], Field(description="The model to filter responses by.")] = None,
+        order: Annotated[Optional[Any], Field(description="The order to sort responses by when sorted by created_at ('asc' or 'desc').")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ListOpenAIResponseObject:
+        """List all responses.
+
+        List all responses.
+
+        :param after: The ID of the last response to return.
+        :type after: str
+        :param limit: The number of responses to return.
+        :type limit: int
+        :param model: The model to filter responses by.
+        :type model: str
+        :param order: The order to sort responses by when sorted by created_at ('asc' or 'desc').
+        :type order: Order
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            model=model,
+            order=order,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListOpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        _deserialized = self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+        # Unwrap List*Response wrappers to return the data field directly
+        return _deserialized
+
+    @validate_call
+    def list_with_http_info(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="The ID of the last response to return.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="The number of responses to return.")] = None,
+        model: Annotated[Optional[StrictStr], Field(description="The model to filter responses by.")] = None,
+        order: Annotated[Optional[Any], Field(description="The order to sort responses by when sorted by created_at ('asc' or 'desc').")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> ApiResponse[ListOpenAIResponseObject]:
+        """List all responses.
+
+        List all responses.
+
+        :param after: The ID of the last response to return.
+        :type after: str
+        :param limit: The number of responses to return.
+        :type limit: int
+        :param model: The model to filter responses by.
+        :type model: str
+        :param order: The order to sort responses by when sorted by created_at ('asc' or 'desc').
+        :type order: Order
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            model=model,
+            order=order,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListOpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+    @validate_call
+    def list_without_preload_content(
+        self,
+        after: Annotated[Optional[StrictStr], Field(description="The ID of the last response to return.")] = None,
+        limit: Annotated[Optional[StrictInt], Field(description="The number of responses to return.")] = None,
+        model: Annotated[Optional[StrictStr], Field(description="The model to filter responses by.")] = None,
+        order: Annotated[Optional[Any], Field(description="The order to sort responses by when sorted by created_at ('asc' or 'desc').")] = None,
+        _request_timeout: Annotated[StrictFloat, Field(gt=0)] | tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ] | None = None,
+        _request_auth: dict[StrictStr, Any] | None = None,
+        _content_type: StrictStr | None = None,
+        _headers: dict[StrictStr, Any] | None = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0
+    ) -> RESTResponseType:
+        """List all responses.
+
+        List all responses.
+
+        :param after: The ID of the last response to return.
+        :type after: str
+        :param limit: The number of responses to return.
+        :type limit: int
+        :param model: The model to filter responses by.
+        :type model: str
+        :param order: The order to sort responses by when sorted by created_at ('asc' or 'desc').
+        :type order: Order
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        
+
+        _param = self._list_serialize(
+            after=after,
+            limit=limit,
+            model=model,
+            order=order,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: dict[str, str | None] = {
+            '200': "ListOpenAIResponseObject",
+            '400': "Error",
+            '429': "Error",
+            '500': "Error",
+        }
+
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _list_serialize(
+        self,
+        after,
+        limit,
+        model,
+        order,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: dict[str, str] = {
+        }
+
+        _path_params: dict[str, str] = {}
+        _query_params: list[tuple[str, str]] = []
+        _header_params: dict[str, str | None] = _headers or {}
+        _form_params: list[tuple[str, str]] = []
+        _files: dict[
+            str, str | bytes | list[str] | list[bytes] | list[tuple[str, bytes]]
+        ] = {}
+        _body_params: bytes | None = None
+
+        # process the path parameters
+        # process the query parameters
+        if after is not None:
+            
+            _query_params.append(('after', after))
+            
+        if limit is not None:
+            
+            _query_params.append(('limit', limit))
+            
+        if model is not None:
+            
+            _query_params.append(('model', model))
+            
+        if order is not None:
+            
+            _query_params.append(('order', order.value))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: list[str] = [
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/responses',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+