ogx_open_client 1.0.3.dev0__py3-none-any.whl

ogx_client/models/open_ai_chat_completion_custom_tool_call_function.py

@@ -0,0 +1,121 @@
+# 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
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List
+from typing import Any, ClassVar
+from typing_extensions import Self
+
+class OpenAIChatCompletionCustomToolCallFunction(BaseModel):
+    """
+    Custom tool call details for OpenAI-compatible tool calls.
+    """ # noqa: E501
+    name: StrictStr = Field(description="The name of the custom tool to call.")
+    input: StrictStr = Field(description="The input for the custom tool call generated by the model.")
+    __properties: ClassVar[list[str]] = ["name", "input"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+
+    def __getattribute__(self, name):
+        """Override to automatically unwrap OneOf/AnyOf instances."""
+        value = super().__getattribute__(name)
+
+        # Unwrap OneOf/AnyOf wrappers directly
+        if hasattr(value, 'actual_instance') and value.actual_instance is not None:
+            return value.actual_instance
+
+        # If the value is a dict, unwrap any OneOf instances in its values
+        if isinstance(value, dict):
+            unwrapped = {}
+            for k, v in value.items():
+                # Check if this is a OneOf wrapper with actual_instance
+                if hasattr(v, 'actual_instance') and v.actual_instance is not None:
+                    unwrapped[k] = v.actual_instance
+                else:
+                    unwrapped[k] = v
+            return unwrapped
+
+        return value
+
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self | None:
+        """Create an instance of OpenAIChatCompletionCustomToolCallFunction from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, Any] | None) -> Self | None:
+        """Create an instance of OpenAIChatCompletionCustomToolCallFunction from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            k: v for k, v in {
+            "name": obj.get("name"),
+            "input": obj.get("input"),
+            }.items() if k in obj
+        })
+        return _obj
+
+

ogx_client/models/open_ai_chat_completion_request_with_extra_body.py

@@ -0,0 +1,377 @@
+# 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
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictFloat, StrictInt, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing_extensions import Annotated
+from ogx_client.models.open_ai_response_format_text_open_ai_response_format_json_schema_open_ai_response_format_json_object import OpenAIResponseFormatTextOpenAIResponseFormatJSONSchemaOpenAIResponseFormatJSONObject
+from ogx_client.models.open_ai_user_message_param_input5_variants import OpenAIUserMessageParamInput5Variants
+from ogx_client.models.service_tier import ServiceTier
+from ogx_client.models.string_list_string import StringListString
+from ogx_client.models.string_object import StringObject
+from ogx_client.models.string_object1 import StringObject1
+from typing import Any, ClassVar
+from typing_extensions import Self
+
+class OpenAIChatCompletionRequestWithExtraBody(BaseModel):
+    """
+    Request parameters for OpenAI-compatible chat completion endpoint.
+    """ # noqa: E501
+    model: StrictStr = Field(description="The identifier of the model to use.")
+    messages: Annotated[List[OpenAIUserMessageParamInput5Variants], Field(min_length=1)] = Field(description="List of messages in the conversation.")
+    frequency_penalty: Optional[Union[Annotated[float, Field(le=2.0, strict=True, ge=-2.0)], Annotated[int, Field(le=2, strict=True, ge=-2)]]] = None
+    function_call: Optional[StringObject] = None
+    functions: Optional[List[Optional[Dict[str, Any]]]] = None
+    logit_bias: Optional[Dict[str, Union[StrictFloat, StrictInt]]] = None
+    logprobs: Optional[StrictBool] = None
+    max_completion_tokens: Optional[Annotated[int, Field(strict=True, ge=1)]] = None
+    max_tokens: Optional[Annotated[int, Field(strict=True, ge=1)]] = None
+    n: Optional[Annotated[int, Field(strict=True, ge=1)]] = None
+    parallel_tool_calls: Optional[StrictBool] = None
+    presence_penalty: Optional[Union[Annotated[float, Field(le=2.0, strict=True, ge=-2.0)], Annotated[int, Field(le=2, strict=True, ge=-2)]]] = None
+    response_format: Optional[OpenAIResponseFormatTextOpenAIResponseFormatJSONSchemaOpenAIResponseFormatJSONObject] = None
+    seed: Optional[StrictInt] = None
+    stop: Optional[StringListString] = None
+    stream: Optional[StrictBool] = None
+    stream_options: Optional[Dict[str, Any]] = None
+    temperature: Optional[Union[Annotated[float, Field(le=2.0, strict=True, ge=0.0)], Annotated[int, Field(le=2, strict=True, ge=0)]]] = None
+    tool_choice: Optional[StringObject1] = None
+    tools: Optional[List[Dict[str, Any]]] = None
+    top_logprobs: Optional[Annotated[int, Field(le=20, strict=True, ge=0)]] = None
+    top_p: Optional[Union[Annotated[float, Field(le=1.0, strict=True, ge=0.0)], Annotated[int, Field(le=1, strict=True, ge=0)]]] = None
+    user: Optional[StrictStr] = None
+    service_tier: Optional[ServiceTier] = None
+    reasoning_effort: Optional[StrictStr] = None
+    prompt_cache_key: Optional[Annotated[str, Field(strict=True, max_length=64)]] = None
+    additional_properties: dict[str, Any] = {}
+    __properties: ClassVar[list[str]] = ["model", "messages", "frequency_penalty", "function_call", "functions", "logit_bias", "logprobs", "max_completion_tokens", "max_tokens", "n", "parallel_tool_calls", "presence_penalty", "response_format", "seed", "stop", "stream", "stream_options", "temperature", "tool_choice", "tools", "top_logprobs", "top_p", "user", "service_tier", "reasoning_effort", "prompt_cache_key"]
+
+    @field_validator('reasoning_effort')
+    def reasoning_effort_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']):
+            raise ValueError("must be one of enum values ('none', 'minimal', 'low', 'medium', 'high', 'xhigh')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+
+    def __getattribute__(self, name):
+        """Override to automatically unwrap OneOf/AnyOf instances."""
+        value = super().__getattribute__(name)
+
+        # Unwrap OneOf/AnyOf wrappers directly
+        if hasattr(value, 'actual_instance') and value.actual_instance is not None:
+            return value.actual_instance
+
+        # If the value is a dict, unwrap any OneOf instances in its values
+        if isinstance(value, dict):
+            unwrapped = {}
+            for k, v in value.items():
+                # Check if this is a OneOf wrapper with actual_instance
+                if hasattr(v, 'actual_instance') and v.actual_instance is not None:
+                    unwrapped[k] = v.actual_instance
+                else:
+                    unwrapped[k] = v
+            return unwrapped
+
+        return value
+
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self | None:
+        """Create an instance of OpenAIChatCompletionRequestWithExtraBody from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        * Fields in `self.additional_properties` are added to the output dict.
+        """
+        excluded_fields: set[str] = set([
+            "additional_properties",
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in messages (list)
+        _items = []
+        if self.messages:
+            for _item_messages in self.messages:
+                if _item_messages:
+                    if hasattr(_item_messages, 'to_dict'):
+                        _items.append(_item_messages.to_dict())
+                    else:
+                        _items.append(_item_messages)
+            _dict['messages'] = _items
+        # override the default output from pydantic by calling `to_dict()` of function_call
+        if self.function_call:
+            if hasattr(self.function_call, 'to_dict'):
+                _dict_value = self.function_call.to_dict()
+                # Only include if to_dict() returns a non-None value (handles oneOf wrappers with actual_instance=None)
+                if _dict_value is not None:
+                    _dict['function_call'] = _dict_value
+                elif 'function_call' in _dict:
+                    # Remove from dict if to_dict() returned None (oneOf wrapper with no actual instance)
+                    del _dict['function_call']
+            else:
+                _dict['function_call'] = self.function_call
+        # override the default output from pydantic by calling `to_dict()` of response_format
+        if self.response_format:
+            if hasattr(self.response_format, 'to_dict'):
+                _dict_value = self.response_format.to_dict()
+                # Only include if to_dict() returns a non-None value (handles oneOf wrappers with actual_instance=None)
+                if _dict_value is not None:
+                    _dict['response_format'] = _dict_value
+                elif 'response_format' in _dict:
+                    # Remove from dict if to_dict() returned None (oneOf wrapper with no actual instance)
+                    del _dict['response_format']
+            else:
+                _dict['response_format'] = self.response_format
+        # override the default output from pydantic by calling `to_dict()` of stop
+        if self.stop:
+            if hasattr(self.stop, 'to_dict'):
+                _dict_value = self.stop.to_dict()
+                # Only include if to_dict() returns a non-None value (handles oneOf wrappers with actual_instance=None)
+                if _dict_value is not None:
+                    _dict['stop'] = _dict_value
+                elif 'stop' in _dict:
+                    # Remove from dict if to_dict() returned None (oneOf wrapper with no actual instance)
+                    del _dict['stop']
+            else:
+                _dict['stop'] = self.stop
+        # override the default output from pydantic by calling `to_dict()` of tool_choice
+        if self.tool_choice:
+            if hasattr(self.tool_choice, 'to_dict'):
+                _dict_value = self.tool_choice.to_dict()
+                # Only include if to_dict() returns a non-None value (handles oneOf wrappers with actual_instance=None)
+                if _dict_value is not None:
+                    _dict['tool_choice'] = _dict_value
+                elif 'tool_choice' in _dict:
+                    # Remove from dict if to_dict() returned None (oneOf wrapper with no actual instance)
+                    del _dict['tool_choice']
+            else:
+                _dict['tool_choice'] = self.tool_choice
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        # set to None if frequency_penalty (nullable) is None
+        # and model_fields_set contains the field
+        if self.frequency_penalty is None and "frequency_penalty" in self.model_fields_set:
+            _dict['frequency_penalty'] = None
+
+        # set to None if function_call (nullable) is None
+        # and model_fields_set contains the field
+        if self.function_call is None and "function_call" in self.model_fields_set:
+            _dict['function_call'] = None
+
+        # set to None if functions (nullable) is None
+        # and model_fields_set contains the field
+        if self.functions is None and "functions" in self.model_fields_set:
+            _dict['functions'] = None
+
+        # set to None if logit_bias (nullable) is None
+        # and model_fields_set contains the field
+        if self.logit_bias is None and "logit_bias" in self.model_fields_set:
+            _dict['logit_bias'] = None
+
+        # set to None if logprobs (nullable) is None
+        # and model_fields_set contains the field
+        if self.logprobs is None and "logprobs" in self.model_fields_set:
+            _dict['logprobs'] = None
+
+        # set to None if max_completion_tokens (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_completion_tokens is None and "max_completion_tokens" in self.model_fields_set:
+            _dict['max_completion_tokens'] = None
+
+        # set to None if max_tokens (nullable) is None
+        # and model_fields_set contains the field
+        if self.max_tokens is None and "max_tokens" in self.model_fields_set:
+            _dict['max_tokens'] = None
+
+        # set to None if n (nullable) is None
+        # and model_fields_set contains the field
+        if self.n is None and "n" in self.model_fields_set:
+            _dict['n'] = None
+
+        # set to None if parallel_tool_calls (nullable) is None
+        # and model_fields_set contains the field
+        if self.parallel_tool_calls is None and "parallel_tool_calls" in self.model_fields_set:
+            _dict['parallel_tool_calls'] = None
+
+        # set to None if presence_penalty (nullable) is None
+        # and model_fields_set contains the field
+        if self.presence_penalty is None and "presence_penalty" in self.model_fields_set:
+            _dict['presence_penalty'] = None
+
+        # set to None if response_format (nullable) is None
+        # and model_fields_set contains the field
+        if self.response_format is None and "response_format" in self.model_fields_set:
+            _dict['response_format'] = None
+
+        # set to None if seed (nullable) is None
+        # and model_fields_set contains the field
+        if self.seed is None and "seed" in self.model_fields_set:
+            _dict['seed'] = None
+
+        # set to None if stop (nullable) is None
+        # and model_fields_set contains the field
+        if self.stop is None and "stop" in self.model_fields_set:
+            _dict['stop'] = None
+
+        # set to None if stream (nullable) is None
+        # and model_fields_set contains the field
+        if self.stream is None and "stream" in self.model_fields_set:
+            _dict['stream'] = None
+
+        # set to None if stream_options (nullable) is None
+        # and model_fields_set contains the field
+        if self.stream_options is None and "stream_options" in self.model_fields_set:
+            _dict['stream_options'] = None
+
+        # set to None if temperature (nullable) is None
+        # and model_fields_set contains the field
+        if self.temperature is None and "temperature" in self.model_fields_set:
+            _dict['temperature'] = None
+
+        # set to None if tool_choice (nullable) is None
+        # and model_fields_set contains the field
+        if self.tool_choice is None and "tool_choice" in self.model_fields_set:
+            _dict['tool_choice'] = None
+
+        # set to None if tools (nullable) is None
+        # and model_fields_set contains the field
+        if self.tools is None and "tools" in self.model_fields_set:
+            _dict['tools'] = None
+
+        # set to None if top_logprobs (nullable) is None
+        # and model_fields_set contains the field
+        if self.top_logprobs is None and "top_logprobs" in self.model_fields_set:
+            _dict['top_logprobs'] = None
+
+        # set to None if top_p (nullable) is None
+        # and model_fields_set contains the field
+        if self.top_p is None and "top_p" in self.model_fields_set:
+            _dict['top_p'] = None
+
+        # set to None if user (nullable) is None
+        # and model_fields_set contains the field
+        if self.user is None and "user" in self.model_fields_set:
+            _dict['user'] = None
+
+        # set to None if service_tier (nullable) is None
+        # and model_fields_set contains the field
+        if self.service_tier is None and "service_tier" in self.model_fields_set:
+            _dict['service_tier'] = None
+
+        # set to None if reasoning_effort (nullable) is None
+        # and model_fields_set contains the field
+        if self.reasoning_effort is None and "reasoning_effort" in self.model_fields_set:
+            _dict['reasoning_effort'] = None
+
+        # set to None if prompt_cache_key (nullable) is None
+        # and model_fields_set contains the field
+        if self.prompt_cache_key is None and "prompt_cache_key" in self.model_fields_set:
+            _dict['prompt_cache_key'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, Any] | None) -> Self | None:
+        """Create an instance of OpenAIChatCompletionRequestWithExtraBody from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            k: v for k, v in {
+            "model": obj.get("model"),
+            "messages": [OpenAIUserMessageParamInput5Variants.from_dict(_item) for _item in obj["messages"]] if obj.get("messages") is not None else None,
+            "frequency_penalty": obj.get("frequency_penalty"),
+            "function_call": StringObject.from_dict(obj["function_call"]) if obj.get("function_call") is not None else None,
+            "functions": obj.get("functions"),
+            "logit_bias": obj.get("logit_bias"),
+            "logprobs": obj.get("logprobs"),
+            "max_completion_tokens": obj.get("max_completion_tokens"),
+            "max_tokens": obj.get("max_tokens"),
+            "n": obj.get("n"),
+            "parallel_tool_calls": obj.get("parallel_tool_calls"),
+            "presence_penalty": obj.get("presence_penalty"),
+            "response_format": OpenAIResponseFormatTextOpenAIResponseFormatJSONSchemaOpenAIResponseFormatJSONObject.from_dict(obj["response_format"]) if obj.get("response_format") is not None else None,
+            "seed": obj.get("seed"),
+            "stop": StringListString.from_dict(obj["stop"]) if obj.get("stop") is not None else None,
+            "stream": obj.get("stream"),
+            "stream_options": obj.get("stream_options"),
+            "temperature": obj.get("temperature"),
+            "tool_choice": StringObject1.from_dict(obj["tool_choice"]) if obj.get("tool_choice") is not None else None,
+            "tools": obj.get("tools"),
+            "top_logprobs": obj.get("top_logprobs"),
+            "top_p": obj.get("top_p"),
+            "user": obj.get("user"),
+            "service_tier": obj.get("service_tier"),
+            "reasoning_effort": obj.get("reasoning_effort"),
+            "prompt_cache_key": obj.get("prompt_cache_key"),
+            }.items() if k in obj
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj
+
+

ogx_client/models/open_ai_chat_completion_response_message.py

@@ -0,0 +1,180 @@
+# 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
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr, field_validator
+from typing import Any, ClassVar, Dict, List, Optional
+from ogx_client.models.chat_completion_message_function_call import ChatCompletionMessageFunctionCall
+from ogx_client.models.chat_completion_message_tool_call_chat_completion_message_custom_tool_call1 import ChatCompletionMessageToolCallChatCompletionMessageCustomToolCall1
+from typing import Any, ClassVar
+from typing_extensions import Self
+
+class OpenAIChatCompletionResponseMessage(BaseModel):
+    """
+    An assistant message returned in a chat completion response.
+    """ # noqa: E501
+    role: Optional[StrictStr] = Field(default=None, description="The role of the message author, always 'assistant' in responses.")
+    content: Optional[StrictStr] = None
+    tool_calls: Optional[List[ChatCompletionMessageToolCallChatCompletionMessageCustomToolCall1]] = Field(default=None, description="The tool calls generated by the model.")
+    refusal: Optional[StrictStr] = None
+    function_call: Optional[ChatCompletionMessageFunctionCall] = None
+    annotations: Optional[List[Optional[Dict[str, Any]]]] = Field(default=None, description="Annotations for the message, when applicable.")
+    audio: Optional[Dict[str, Any]] = None
+    __properties: ClassVar[list[str]] = ["role", "content", "tool_calls", "refusal", "function_call", "annotations", "audio"]
+
+    @field_validator('role')
+    def role_validate_enum(cls, value):
+        """Validates the enum"""
+        if value is None:
+            return value
+
+        if value not in set(['assistant']):
+            raise ValueError("must be one of enum values ('assistant')")
+        return value
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+
+    def __getattribute__(self, name):
+        """Override to automatically unwrap OneOf/AnyOf instances."""
+        value = super().__getattribute__(name)
+
+        # Unwrap OneOf/AnyOf wrappers directly
+        if hasattr(value, 'actual_instance') and value.actual_instance is not None:
+            return value.actual_instance
+
+        # If the value is a dict, unwrap any OneOf instances in its values
+        if isinstance(value, dict):
+            unwrapped = {}
+            for k, v in value.items():
+                # Check if this is a OneOf wrapper with actual_instance
+                if hasattr(v, 'actual_instance') and v.actual_instance is not None:
+                    unwrapped[k] = v.actual_instance
+                else:
+                    unwrapped[k] = v
+            return unwrapped
+
+        return value
+
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Self | None:
+        """Create an instance of OpenAIChatCompletionResponseMessage from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in tool_calls (list)
+        _items = []
+        if self.tool_calls:
+            for _item_tool_calls in self.tool_calls:
+                if _item_tool_calls:
+                    if hasattr(_item_tool_calls, 'to_dict'):
+                        _items.append(_item_tool_calls.to_dict())
+                    else:
+                        _items.append(_item_tool_calls)
+            _dict['tool_calls'] = _items
+        # override the default output from pydantic by calling `to_dict()` of function_call
+        if self.function_call:
+            if hasattr(self.function_call, 'to_dict'):
+                _dict_value = self.function_call.to_dict()
+                # Only include if to_dict() returns a non-None value (handles oneOf wrappers with actual_instance=None)
+                if _dict_value is not None:
+                    _dict['function_call'] = _dict_value
+                elif 'function_call' in _dict:
+                    # Remove from dict if to_dict() returned None (oneOf wrapper with no actual instance)
+                    del _dict['function_call']
+            else:
+                _dict['function_call'] = self.function_call
+        # set to None if content (nullable) is None
+        # and model_fields_set contains the field
+        if self.content is None and "content" in self.model_fields_set:
+            _dict['content'] = None
+
+        # set to None if refusal (nullable) is None
+        # and model_fields_set contains the field
+        if self.refusal is None and "refusal" in self.model_fields_set:
+            _dict['refusal'] = None
+
+        # set to None if audio (nullable) is None
+        # and model_fields_set contains the field
+        if self.audio is None and "audio" in self.model_fields_set:
+            _dict['audio'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict[str, Any] | None) -> Self | None:
+        """Create an instance of OpenAIChatCompletionResponseMessage from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            k: v for k, v in {
+            "role": obj.get("role"),
+            "content": obj.get("content"),
+            "tool_calls": [ChatCompletionMessageToolCallChatCompletionMessageCustomToolCall1.from_dict(_item) for _item in obj["tool_calls"]] if obj.get("tool_calls") is not None else None,
+            "refusal": obj.get("refusal"),
+            "function_call": ChatCompletionMessageFunctionCall.from_dict(obj["function_call"]) if obj.get("function_call") is not None else None,
+            "annotations": obj.get("annotations"),
+            "audio": obj.get("audio"),
+            }.items() if k in obj
+        })
+        return _obj
+
+