orq-ai-sdk 4.2.0rc28__py3-none-any.whl → 4.3.0rc7__py3-none-any.whl

orq_ai_sdk/models/createpromptop.py

@@ -17,6 +17,14 @@ from .redactedreasoningpartschema import (
 )
 from .refusalpartschema import RefusalPartSchema, RefusalPartSchemaTypedDict
 from .textcontentpartschema import TextContentPartSchema, TextContentPartSchemaTypedDict
+from .thinkingconfigdisabledschema import (
+    ThinkingConfigDisabledSchema,
+    ThinkingConfigDisabledSchemaTypedDict,
+)
+from .thinkingconfigenabledschema import (
+    ThinkingConfigEnabledSchema,
+    ThinkingConfigEnabledSchemaTypedDict,
+)
 from orq_ai_sdk.types import (
     BaseModel,
     Nullable,
@@ -89,1284 +97,1348 @@ class CreatePromptMetadata(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["use_cases", "language"]
-        nullable_fields = ["language"]
-        null_default_fields = []
-
+        optional_fields = set(["use_cases", "language"])
+        nullable_fields = set(["language"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
 
-CreatePromptRole = Literal[
-    "system",
-    "assistant",
-    "user",
-    "exception",
-    "tool",
-    "prompt",
-    "correction",
-    "expected_output",
-]
-r"""The role of the prompt message"""
+CreatePromptMessagesPromptsRequestRequestBodyRole = Literal["tool",]
+r"""The role of the messages author, in this case tool."""
 
 
-CreatePrompt2PromptsRequestType = Literal["file",]
-r"""The type of the content part. Always `file`."""
+CreatePromptContentPromptsRequest2TypedDict = TextContentPartSchemaTypedDict
 
 
-class CreatePrompt2FileTypedDict(TypedDict):
-    file_data: NotRequired[str]
-    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
-    uri: NotRequired[str]
-    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
-    mime_type: NotRequired[str]
-    r"""MIME type of the file (e.g., application/pdf, image/png)"""
-    filename: NotRequired[str]
-    r"""The name of the file, used when passing the file to the model as a string."""
+CreatePromptContentPromptsRequest2 = TextContentPartSchema
 
 
-class CreatePrompt2File(BaseModel):
-    file_data: Optional[str] = None
-    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
+CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict",
+    Union[str, List[CreatePromptContentPromptsRequest2TypedDict]],
+)
+r"""The contents of the tool message."""
 
-    uri: Optional[str] = None
-    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
 
-    mime_type: Annotated[Optional[str], pydantic.Field(alias="mimeType")] = None
-    r"""MIME type of the file (e.g., application/pdf, image/png)"""
+CreatePromptMessagesPromptsRequestRequestBodyContent = TypeAliasType(
+    "CreatePromptMessagesPromptsRequestRequestBodyContent",
+    Union[str, List[CreatePromptContentPromptsRequest2]],
+)
+r"""The contents of the tool message."""
 
-    filename: Optional[str] = None
-    r"""The name of the file, used when passing the file to the model as a string."""
 
+CreatePromptMessagesPromptsType = Literal["ephemeral",]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
-class Two3TypedDict(TypedDict):
-    type: CreatePrompt2PromptsRequestType
-    r"""The type of the content part. Always `file`."""
-    file: CreatePrompt2FileTypedDict
 
+CreatePromptMessagesTTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
-class Two3(BaseModel):
-    type: CreatePrompt2PromptsRequestType
-    r"""The type of the content part. Always `file`."""
+- `5m`: 5 minutes
+- `1h`: 1 hour
 
-    file: CreatePrompt2File
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
 
 
-CreatePrompt2PromptsType = Literal["image_url",]
+class CreatePromptMessagesCacheControlTypedDict(TypedDict):
+    type: CreatePromptMessagesPromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[CreatePromptMessagesTTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
 
-class CreatePrompt2ImageURLTypedDict(TypedDict):
-    url: str
-    r"""Either a URL of the image or the base64 encoded data URI."""
-    detail: NotRequired[str]
-    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
 
 
-class CreatePrompt2ImageURL(BaseModel):
-    url: str
-    r"""Either a URL of the image or the base64 encoded data URI."""
+class CreatePromptMessagesCacheControl(BaseModel):
+    type: CreatePromptMessagesPromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
-    detail: Optional[str] = None
-    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+    ttl: Optional[CreatePromptMessagesTTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
 
-class CreatePrompt22TypedDict(TypedDict):
-    r"""The image part of the prompt message. Only supported with vision models."""
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
 
-    type: CreatePrompt2PromptsType
-    image_url: CreatePrompt2ImageURLTypedDict
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
 
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-class CreatePrompt22(BaseModel):
-    r"""The image part of the prompt message. Only supported with vision models."""
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    type: CreatePrompt2PromptsType
+        return m
 
-    image_url: CreatePrompt2ImageURL
 
+class CreatePromptMessagesToolMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsRequestRequestBodyRole
+    r"""The role of the messages author, in this case tool."""
+    content: CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict
+    r"""The contents of the tool message."""
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
+    cache_control: NotRequired[CreatePromptMessagesCacheControlTypedDict]
 
-CreatePrompt2Type = Literal["text",]
 
+class CreatePromptMessagesToolMessage(BaseModel):
+    role: CreatePromptMessagesPromptsRequestRequestBodyRole
+    r"""The role of the messages author, in this case tool."""
 
-class CreatePrompt21TypedDict(TypedDict):
-    r"""Text content part of a prompt message"""
+    content: CreatePromptMessagesPromptsRequestRequestBodyContent
+    r"""The contents of the tool message."""
 
-    type: CreatePrompt2Type
-    text: str
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
 
+    cache_control: Optional[CreatePromptMessagesCacheControl] = None
 
-class CreatePrompt21(BaseModel):
-    r"""Text content part of a prompt message"""
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cache_control"])
+        nullable_fields = set(["tool_call_id"])
+        serialized = handler(self)
+        m = {}
 
-    type: CreatePrompt2Type
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
-    text: str
+        return m
 
 
-CreatePromptContent2TypedDict = TypeAliasType(
-    "CreatePromptContent2TypedDict",
-    Union[CreatePrompt21TypedDict, CreatePrompt22TypedDict, Two3TypedDict],
+CreatePromptContentPrompts2TypedDict = TypeAliasType(
+    "CreatePromptContentPrompts2TypedDict",
+    Union[
+        RefusalPartSchemaTypedDict,
+        RedactedReasoningPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ReasoningPartSchemaTypedDict,
+    ],
 )
 
 
-CreatePromptContent2 = Annotated[
+CreatePromptContentPrompts2 = Annotated[
     Union[
-        Annotated[CreatePrompt21, Tag("text")],
-        Annotated[CreatePrompt22, Tag("image_url")],
-        Annotated[Two3, Tag("file")],
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[RefusalPartSchema, Tag("refusal")],
+        Annotated[ReasoningPartSchema, Tag("reasoning")],
+        Annotated[RedactedReasoningPartSchema, Tag("redacted_reasoning")],
     ],
     Discriminator(lambda m: get_discriminator(m, "type", "type")),
 ]
 
 
-CreatePromptContentTypedDict = TypeAliasType(
-    "CreatePromptContentTypedDict", Union[str, List[CreatePromptContent2TypedDict]]
+CreatePromptMessagesPromptsRequestContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsRequestContentTypedDict",
+    Union[str, List[CreatePromptContentPrompts2TypedDict]],
 )
-r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
 
-CreatePromptContent = TypeAliasType(
-    "CreatePromptContent", Union[str, List[CreatePromptContent2]]
+CreatePromptMessagesPromptsRequestContent = TypeAliasType(
+    "CreatePromptMessagesPromptsRequestContent",
+    Union[str, List[CreatePromptContentPrompts2]],
 )
-r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
 
-CreatePromptType = Literal["function",]
+CreatePromptMessagesPromptsRequestRole = Literal["assistant",]
+r"""The role of the messages author, in this case `assistant`."""
 
 
-class CreatePromptFunctionTypedDict(TypedDict):
-    name: str
-    arguments: str
-    r"""JSON string arguments for the functions"""
+class CreatePromptMessagesAudioTypedDict(TypedDict):
+    r"""Data about a previous audio response from the model."""
 
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
 
-class CreatePromptFunction(BaseModel):
-    name: str
 
-    arguments: str
-    r"""JSON string arguments for the functions"""
+class CreatePromptMessagesAudio(BaseModel):
+    r"""Data about a previous audio response from the model."""
 
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
 
-class CreatePromptToolCallsTypedDict(TypedDict):
-    type: CreatePromptType
-    function: CreatePromptFunctionTypedDict
-    id: NotRequired[str]
-    index: NotRequired[float]
+
+CreatePromptMessagesType = Literal["function",]
+r"""The type of the tool. Currently, only `function` is supported."""
 
 
-class CreatePromptToolCalls(BaseModel):
-    type: CreatePromptType
+class CreatePromptMessagesFunctionTypedDict(TypedDict):
+    name: NotRequired[str]
+    r"""The name of the function to call."""
+    arguments: NotRequired[str]
+    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
 
-    function: CreatePromptFunction
 
-    id: Optional[str] = None
+class CreatePromptMessagesFunction(BaseModel):
+    name: Optional[str] = None
+    r"""The name of the function to call."""
 
-    index: Optional[float] = None
+    arguments: Optional[str] = None
+    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name", "arguments"])
+        serialized = handler(self)
+        m = {}
 
-class CreatePromptMessagesTypedDict(TypedDict):
-    role: CreatePromptRole
-    r"""The role of the prompt message"""
-    content: Nullable[CreatePromptContentTypedDict]
-    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
-    tool_calls: NotRequired[List[CreatePromptToolCallsTypedDict]]
-    tool_call_id: NotRequired[Nullable[str]]
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-class CreatePromptMessages(BaseModel):
-    role: CreatePromptRole
-    r"""The role of the prompt message"""
+        return m
 
-    content: Nullable[CreatePromptContent]
-    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
 
-    tool_calls: Optional[List[CreatePromptToolCalls]] = None
+class CreatePromptMessagesToolCallsTypedDict(TypedDict):
+    id: str
+    r"""The ID of the tool call."""
+    type: CreatePromptMessagesType
+    r"""The type of the tool. Currently, only `function` is supported."""
+    function: CreatePromptMessagesFunctionTypedDict
+    thought_signature: NotRequired[str]
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
 
-    tool_call_id: OptionalNullable[str] = UNSET
+
+class CreatePromptMessagesToolCalls(BaseModel):
+    id: str
+    r"""The ID of the tool call."""
+
+    type: CreatePromptMessagesType
+    r"""The type of the tool. Currently, only `function` is supported."""
+
+    function: CreatePromptMessagesFunction
+
+    thought_signature: Optional[str] = None
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["tool_calls", "tool_call_id"]
-        nullable_fields = ["content", "tool_call_id"]
-        null_default_fields = []
-
+        optional_fields = set(["thought_signature"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
         return m
 
 
-CreatePromptFormat = Literal[
-    "url",
-    "b64_json",
-    "text",
-    "json_object",
-]
-r"""Only supported on `image` models."""
+class CreatePromptMessagesAssistantMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsRequestRole
+    r"""The role of the messages author, in this case `assistant`."""
+    content: NotRequired[Nullable[CreatePromptMessagesPromptsRequestContentTypedDict]]
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+    refusal: NotRequired[Nullable[str]]
+    r"""The refusal message by the assistant."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+    audio: NotRequired[Nullable[CreatePromptMessagesAudioTypedDict]]
+    r"""Data about a previous audio response from the model."""
+    tool_calls: NotRequired[List[CreatePromptMessagesToolCallsTypedDict]]
+    r"""The tool calls generated by the model, such as function calls."""
 
 
-Six = Literal[
-    "json",
-    "text",
-    "srt",
-    "verbose_json",
-    "vtt",
-]
+class CreatePromptMessagesAssistantMessage(BaseModel):
+    role: CreatePromptMessagesPromptsRequestRole
+    r"""The role of the messages author, in this case `assistant`."""
 
+    content: OptionalNullable[CreatePromptMessagesPromptsRequestContent] = UNSET
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
-Five = Literal[
-    "url",
-    "base64_json",
-]
+    refusal: OptionalNullable[str] = UNSET
+    r"""The refusal message by the assistant."""
 
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-ResponseFormat4 = Literal[
-    "mp3",
-    "opus",
-    "aac",
-    "flac",
-    "wav",
-    "pcm",
-]
+    audio: OptionalNullable[CreatePromptMessagesAudio] = UNSET
+    r"""Data about a previous audio response from the model."""
 
+    tool_calls: Optional[List[CreatePromptMessagesToolCalls]] = None
+    r"""The tool calls generated by the model, such as function calls."""
 
-CreatePromptResponseFormatPromptsRequestType = Literal["text",]
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["content", "refusal", "name", "audio", "tool_calls"])
+        nullable_fields = set(["content", "refusal", "audio"])
+        serialized = handler(self)
+        m = {}
 
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
-class ResponseFormat3TypedDict(TypedDict):
-    type: CreatePromptResponseFormatPromptsRequestType
+        return m
 
 
-class ResponseFormat3(BaseModel):
-    type: CreatePromptResponseFormatPromptsRequestType
+CreatePromptMessagesPromptsRole = Literal["user",]
+r"""The role of the messages author, in this case `user`."""
 
 
-CreatePromptResponseFormatPromptsType = Literal["json_object",]
+CreatePrompt2Type = Literal["file",]
+r"""The type of the content part. Always `file`."""
 
 
-class ResponseFormat2TypedDict(TypedDict):
-    type: CreatePromptResponseFormatPromptsType
+CreatePrompt2PromptsType = Literal["ephemeral",]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
 
-class ResponseFormat2(BaseModel):
-    type: CreatePromptResponseFormatPromptsType
+CreatePrompt2TTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
+- `5m`: 5 minutes
+- `1h`: 1 hour
 
-CreatePromptResponseFormatType = Literal["json_schema",]
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
 
 
-class CreatePromptResponseFormatJSONSchemaTypedDict(TypedDict):
-    name: str
-    schema_: Dict[str, Any]
-    description: NotRequired[str]
-    strict: NotRequired[bool]
+class CreatePrompt2CacheControlTypedDict(TypedDict):
+    type: CreatePrompt2PromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[CreatePrompt2TTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
 
-class CreatePromptResponseFormatJSONSchema(BaseModel):
-    name: str
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
 
-    schema_: Annotated[Dict[str, Any], pydantic.Field(alias="schema")]
 
-    description: Optional[str] = None
+class CreatePrompt2CacheControl(BaseModel):
+    type: CreatePrompt2PromptsType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
-    strict: Optional[bool] = None
+    ttl: Optional[CreatePrompt2TTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
 
-class ResponseFormat1TypedDict(TypedDict):
-    type: CreatePromptResponseFormatType
-    json_schema: CreatePromptResponseFormatJSONSchemaTypedDict
-    display_name: NotRequired[str]
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
 
-class ResponseFormat1(BaseModel):
-    type: CreatePromptResponseFormatType
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-    json_schema: CreatePromptResponseFormatJSONSchema
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    display_name: Optional[str] = None
+        return m
 
 
-CreatePromptResponseFormatTypedDict = TypeAliasType(
-    "CreatePromptResponseFormatTypedDict",
-    Union[
-        ResponseFormat2TypedDict,
-        ResponseFormat3TypedDict,
-        ResponseFormat1TypedDict,
-        ResponseFormat4,
-        Five,
-        Six,
-    ],
-)
-r"""An object specifying the format that the model must output.
+class CreatePrompt24TypedDict(TypedDict):
+    type: CreatePrompt2Type
+    r"""The type of the content part. Always `file`."""
+    file: FileContentPartSchemaTypedDict
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
+    cache_control: NotRequired[CreatePrompt2CacheControlTypedDict]
 
-Setting to `{ \"type\": \"json_schema\", \"json_schema\": {...} }` enables Structured Outputs which ensures the model will match your supplied JSON schema
 
-Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which ensures the message the model generates is valid JSON.
+class CreatePrompt24(BaseModel):
+    type: CreatePrompt2Type
+    r"""The type of the content part. Always `file`."""
 
-Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly \"stuck\" request. Also note that the message content may be partially cut off if finish_reason=\"length\", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
-"""
+    file: FileContentPartSchema
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
+
+    cache_control: Optional[CreatePrompt2CacheControl] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cache_control"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
 
 
-CreatePromptResponseFormat = TypeAliasType(
-    "CreatePromptResponseFormat",
+CreatePromptContent2TypedDict = TypeAliasType(
+    "CreatePromptContent2TypedDict",
     Union[
-        ResponseFormat2, ResponseFormat3, ResponseFormat1, ResponseFormat4, Five, Six
+        AudioContentPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ImageContentPartSchemaTypedDict,
+        CreatePrompt24TypedDict,
     ],
 )
-r"""An object specifying the format that the model must output.
 
-Setting to `{ \"type\": \"json_schema\", \"json_schema\": {...} }` enables Structured Outputs which ensures the model will match your supplied JSON schema
 
-Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which ensures the message the model generates is valid JSON.
+CreatePromptContent2 = Annotated[
+    Union[
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[ImageContentPartSchema, Tag("image_url")],
+        Annotated[AudioContentPartSchema, Tag("input_audio")],
+        Annotated[CreatePrompt24, Tag("file")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
 
-Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly \"stuck\" request. Also note that the message content may be partially cut off if finish_reason=\"length\", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
-"""
 
+CreatePromptMessagesPromptsContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsContentTypedDict",
+    Union[str, List[CreatePromptContent2TypedDict]],
+)
+r"""The contents of the user message."""
 
-PhotoRealVersion = Literal[
-    "v1",
-    "v2",
-]
-r"""The version of photoReal to use. Must be v1 or v2. Only available for `leonardoai` provider"""
 
+CreatePromptMessagesPromptsContent = TypeAliasType(
+    "CreatePromptMessagesPromptsContent", Union[str, List[CreatePromptContent2]]
+)
+r"""The contents of the user message."""
 
-EncodingFormat = Literal[
-    "float",
-    "base64",
-]
-r"""The format to return the embeddings"""
 
+class CreatePromptMessagesUserMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsRole
+    r"""The role of the messages author, in this case `user`."""
+    content: CreatePromptMessagesPromptsContentTypedDict
+    r"""The contents of the user message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-CreatePromptReasoningEffort = Literal[
-    "none",
-    "disable",
-    "minimal",
-    "low",
-    "medium",
-    "high",
-]
-r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
 
+class CreatePromptMessagesUserMessage(BaseModel):
+    role: CreatePromptMessagesPromptsRole
+    r"""The role of the messages author, in this case `user`."""
 
-Verbosity = Literal[
-    "low",
-    "medium",
-    "high",
-]
-r"""Controls the verbosity of the model output."""
+    content: CreatePromptMessagesPromptsContent
+    r"""The contents of the user message."""
 
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-CreatePromptThinkingLevel = Literal[
-    "low",
-    "high",
-]
-r"""The level of thinking to use for the model. Only supported by `Google AI`"""
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
 
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-class ModelParametersTypedDict(TypedDict):
-    r"""Optional model parameters like temperature and maxTokens."""
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    temperature: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    max_tokens: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    top_k: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    top_p: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    frequency_penalty: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    presence_penalty: NotRequired[float]
-    r"""Only supported on `chat` and `completion` models."""
-    num_images: NotRequired[float]
-    r"""Only supported on `image` models."""
-    seed: NotRequired[float]
-    r"""Best effort deterministic seed for the model. Currently only OpenAI models support these"""
-    format_: NotRequired[CreatePromptFormat]
-    r"""Only supported on `image` models."""
-    dimensions: NotRequired[str]
-    r"""Only supported on `image` models."""
-    quality: NotRequired[str]
-    r"""Only supported on `image` models."""
-    style: NotRequired[str]
-    r"""Only supported on `image` models."""
-    response_format: NotRequired[Nullable[CreatePromptResponseFormatTypedDict]]
-    r"""An object specifying the format that the model must output.
+        return m
 
-    Setting to `{ \"type\": \"json_schema\", \"json_schema\": {...} }` enables Structured Outputs which ensures the model will match your supplied JSON schema
 
-    Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which ensures the message the model generates is valid JSON.
+CreatePromptMessagesRole = Literal["system",]
+r"""The role of the messages author, in this case `system`."""
 
-    Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly \"stuck\" request. Also note that the message content may be partially cut off if finish_reason=\"length\", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
-    """
-    photo_real_version: NotRequired[PhotoRealVersion]
-    r"""The version of photoReal to use. Must be v1 or v2. Only available for `leonardoai` provider"""
-    encoding_format: NotRequired[EncodingFormat]
-    r"""The format to return the embeddings"""
-    reasoning_effort: NotRequired[CreatePromptReasoningEffort]
-    r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
-    budget_tokens: NotRequired[float]
-    r"""Gives the model enhanced reasoning capabilities for complex tasks. A value of 0 disables thinking. The minimum budget tokens for thinking are 1024. The Budget Tokens should never exceed the Max Tokens parameter. Only supported by `Anthropic`"""
-    verbosity: NotRequired[Verbosity]
-    r"""Controls the verbosity of the model output."""
-    thinking_level: NotRequired[CreatePromptThinkingLevel]
-    r"""The level of thinking to use for the model. Only supported by `Google AI`"""
-
-
-class ModelParameters(BaseModel):
-    r"""Optional model parameters like temperature and maxTokens."""
-
-    temperature: Optional[float] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    max_tokens: Annotated[Optional[float], pydantic.Field(alias="maxTokens")] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    top_k: Annotated[Optional[float], pydantic.Field(alias="topK")] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    top_p: Annotated[Optional[float], pydantic.Field(alias="topP")] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    frequency_penalty: Annotated[
-        Optional[float], pydantic.Field(alias="frequencyPenalty")
-    ] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    presence_penalty: Annotated[
-        Optional[float], pydantic.Field(alias="presencePenalty")
-    ] = None
-    r"""Only supported on `chat` and `completion` models."""
-
-    num_images: Annotated[Optional[float], pydantic.Field(alias="numImages")] = None
-    r"""Only supported on `image` models."""
-
-    seed: Optional[float] = None
-    r"""Best effort deterministic seed for the model. Currently only OpenAI models support these"""
-
-    format_: Annotated[Optional[CreatePromptFormat], pydantic.Field(alias="format")] = (
-        None
-    )
-    r"""Only supported on `image` models."""
-
-    dimensions: Optional[str] = None
-    r"""Only supported on `image` models."""
 
-    quality: Optional[str] = None
-    r"""Only supported on `image` models."""
-
-    style: Optional[str] = None
-    r"""Only supported on `image` models."""
+CreatePromptMessagesContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesContentTypedDict",
+    Union[str, List[TextContentPartSchemaTypedDict]],
+)
+r"""The contents of the system message."""
 
-    response_format: Annotated[
-        OptionalNullable[CreatePromptResponseFormat],
-        pydantic.Field(alias="responseFormat"),
-    ] = UNSET
-    r"""An object specifying the format that the model must output.
 
-    Setting to `{ \"type\": \"json_schema\", \"json_schema\": {...} }` enables Structured Outputs which ensures the model will match your supplied JSON schema
+CreatePromptMessagesContent = TypeAliasType(
+    "CreatePromptMessagesContent", Union[str, List[TextContentPartSchema]]
+)
+r"""The contents of the system message."""
 
-    Setting to `{ \"type\": \"json_object\" }` enables JSON mode, which ensures the message the model generates is valid JSON.
 
-    Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly \"stuck\" request. Also note that the message content may be partially cut off if finish_reason=\"length\", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.
-    """
+class CreatePromptMessagesSystemMessageTypedDict(TypedDict):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
 
-    photo_real_version: Annotated[
-        Optional[PhotoRealVersion], pydantic.Field(alias="photoRealVersion")
-    ] = None
-    r"""The version of photoReal to use. Must be v1 or v2. Only available for `leonardoai` provider"""
+    role: CreatePromptMessagesRole
+    r"""The role of the messages author, in this case `system`."""
+    content: CreatePromptMessagesContentTypedDict
+    r"""The contents of the system message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-    encoding_format: Optional[EncodingFormat] = None
-    r"""The format to return the embeddings"""
 
-    reasoning_effort: Annotated[
-        Optional[CreatePromptReasoningEffort], pydantic.Field(alias="reasoningEffort")
-    ] = None
-    r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
+class CreatePromptMessagesSystemMessage(BaseModel):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
 
-    budget_tokens: Annotated[Optional[float], pydantic.Field(alias="budgetTokens")] = (
-        None
-    )
-    r"""Gives the model enhanced reasoning capabilities for complex tasks. A value of 0 disables thinking. The minimum budget tokens for thinking are 1024. The Budget Tokens should never exceed the Max Tokens parameter. Only supported by `Anthropic`"""
+    role: CreatePromptMessagesRole
+    r"""The role of the messages author, in this case `system`."""
 
-    verbosity: Optional[Verbosity] = None
-    r"""Controls the verbosity of the model output."""
+    content: CreatePromptMessagesContent
+    r"""The contents of the system message."""
 
-    thinking_level: Annotated[
-        Optional[CreatePromptThinkingLevel], pydantic.Field(alias="thinkingLevel")
-    ] = None
-    r"""The level of thinking to use for the model. Only supported by `Google AI`"""
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "temperature",
-            "maxTokens",
-            "topK",
-            "topP",
-            "frequencyPenalty",
-            "presencePenalty",
-            "numImages",
-            "seed",
-            "format",
-            "dimensions",
-            "quality",
-            "style",
-            "responseFormat",
-            "photoRealVersion",
-            "encoding_format",
-            "reasoningEffort",
-            "budgetTokens",
-            "verbosity",
-            "thinkingLevel",
-        ]
-        nullable_fields = ["responseFormat"]
-        null_default_fields = []
-
+        optional_fields = set(["name"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
 
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
         return m
 
 
-@deprecated(
-    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+CreatePromptMessagesTypedDict = TypeAliasType(
+    "CreatePromptMessagesTypedDict",
+    Union[
+        CreatePromptMessagesSystemMessageTypedDict,
+        CreatePromptMessagesUserMessageTypedDict,
+        CreatePromptMessagesToolMessageTypedDict,
+        CreatePromptMessagesAssistantMessageTypedDict,
+    ],
 )
-class PromptConfigurationTypedDict(TypedDict):
-    r"""[DEPRECATED]. Please use the `prompt` property instead. The current `prompt_config` will keep working but it will be deprecated in future versions. Configuration for the prompt including model and messages."""
 
-    messages: List[CreatePromptMessagesTypedDict]
-    r"""Array of messages that make up the conversation."""
-    model: NotRequired[str]
-    r"""Model ID used to generate the response, like `openai/gpt-4o` or `google/gemini-2.5-pro`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
-    model_parameters: NotRequired[ModelParametersTypedDict]
-    r"""Optional model parameters like temperature and maxTokens."""
 
+CreatePromptMessages = Annotated[
+    Union[
+        Annotated[CreatePromptMessagesSystemMessage, Tag("system")],
+        Annotated[CreatePromptMessagesUserMessage, Tag("user")],
+        Annotated[CreatePromptMessagesAssistantMessage, Tag("assistant")],
+        Annotated[CreatePromptMessagesToolMessage, Tag("tool")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
+]
 
-@deprecated(
-    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
-)
-class PromptConfiguration(BaseModel):
-    r"""[DEPRECATED]. Please use the `prompt` property instead. The current `prompt_config` will keep working but it will be deprecated in future versions. Configuration for the prompt including model and messages."""
 
-    messages: List[CreatePromptMessages]
-    r"""Array of messages that make up the conversation."""
+CreatePromptVoice = Literal[
+    "alloy",
+    "echo",
+    "fable",
+    "onyx",
+    "nova",
+    "shimmer",
+]
+r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
 
-    model: Optional[str] = None
-    r"""Model ID used to generate the response, like `openai/gpt-4o` or `google/gemini-2.5-pro`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
 
-    model_parameters: Optional[ModelParameters] = None
-    r"""Optional model parameters like temperature and maxTokens."""
+CreatePromptFormat = Literal[
+    "wav",
+    "mp3",
+    "flac",
+    "opus",
+    "pcm16",
+]
+r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
 
-CreatePromptMessagesPromptsRequestRequestBodyRole = Literal["tool",]
-r"""The role of the messages author, in this case tool."""
+class CreatePromptAudioTypedDict(TypedDict):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
+    voice: CreatePromptVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+    format_: CreatePromptFormat
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
-CreatePromptContentPromptsRequestRequestBody2TypedDict = TextContentPartSchemaTypedDict
 
+class CreatePromptAudio(BaseModel):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
-CreatePromptContentPromptsRequestRequestBody2 = TextContentPartSchema
+    voice: CreatePromptVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
 
+    format_: Annotated[CreatePromptFormat, pydantic.Field(alias="format")]
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
-CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict = TypeAliasType(
-    "CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict",
-    Union[str, List[CreatePromptContentPromptsRequestRequestBody2TypedDict]],
-)
-r"""The contents of the tool message."""
 
+CreatePromptResponseFormatPromptsRequestType = Literal["json_schema",]
 
-CreatePromptMessagesPromptsRequestRequestBodyContent = TypeAliasType(
-    "CreatePromptMessagesPromptsRequestRequestBodyContent",
-    Union[str, List[CreatePromptContentPromptsRequestRequestBody2]],
-)
-r"""The contents of the tool message."""
 
+class CreatePromptResponseFormatPromptsJSONSchemaTypedDict(TypedDict):
+    name: str
+    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
+    description: NotRequired[str]
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
+    schema_: NotRequired[Any]
+    r"""The schema for the response format, described as a JSON Schema object."""
+    strict: NotRequired[bool]
+    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
 
-CreatePromptMessagesPromptsType = Literal["ephemeral",]
-r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
+class CreatePromptResponseFormatPromptsJSONSchema(BaseModel):
+    name: str
+    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
 
-CreatePromptMessagesTTL = Literal[
-    "5m",
-    "1h",
-]
-r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+    description: Optional[str] = None
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
 
-- `5m`: 5 minutes
-- `1h`: 1 hour
+    schema_: Annotated[Optional[Any], pydantic.Field(alias="schema")] = None
+    r"""The schema for the response format, described as a JSON Schema object."""
 
-Defaults to `5m`. Only supported by `Anthropic` Claude models.
-"""
+    strict: Optional[bool] = False
+    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "schema", "strict"])
+        serialized = handler(self)
+        m = {}
 
-class CreatePromptMessagesCacheControlTypedDict(TypedDict):
-    type: CreatePromptMessagesPromptsType
-    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
-    ttl: NotRequired[CreatePromptMessagesTTL]
-    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-    - `5m`: 5 minutes
-    - `1h`: 1 hour
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    Defaults to `5m`. Only supported by `Anthropic` Claude models.
-    """
+        return m
 
 
-class CreatePromptMessagesCacheControl(BaseModel):
-    type: CreatePromptMessagesPromptsType
-    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+class CreatePromptResponseFormatJSONSchemaTypedDict(TypedDict):
+    r"""
 
-    ttl: Optional[CreatePromptMessagesTTL] = "5m"
-    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+    JSON Schema response format. Used to generate structured JSON responses
+    """
 
-    - `5m`: 5 minutes
-    - `1h`: 1 hour
+    type: CreatePromptResponseFormatPromptsRequestType
+    json_schema: CreatePromptResponseFormatPromptsJSONSchemaTypedDict
 
-    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+
+class CreatePromptResponseFormatJSONSchema(BaseModel):
+    r"""
+
+    JSON Schema response format. Used to generate structured JSON responses
     """
 
+    type: CreatePromptResponseFormatPromptsRequestType
 
-class CreatePromptMessagesToolMessageTypedDict(TypedDict):
-    role: CreatePromptMessagesPromptsRequestRequestBodyRole
-    r"""The role of the messages author, in this case tool."""
-    content: CreatePromptMessagesPromptsRequestRequestBodyContentTypedDict
-    r"""The contents of the tool message."""
-    tool_call_id: Nullable[str]
-    r"""Tool call that this message is responding to."""
-    cache_control: NotRequired[CreatePromptMessagesCacheControlTypedDict]
+    json_schema: CreatePromptResponseFormatPromptsJSONSchema
 
 
-class CreatePromptMessagesToolMessage(BaseModel):
-    role: CreatePromptMessagesPromptsRequestRequestBodyRole
-    r"""The role of the messages author, in this case tool."""
+CreatePromptResponseFormatPromptsType = Literal["json_object",]
 
-    content: CreatePromptMessagesPromptsRequestRequestBodyContent
-    r"""The contents of the tool message."""
 
-    tool_call_id: Nullable[str]
-    r"""Tool call that this message is responding to."""
+class CreatePromptResponseFormatJSONObjectTypedDict(TypedDict):
+    r"""
 
-    cache_control: Optional[CreatePromptMessagesCacheControl] = None
+    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    """
 
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["cache_control"]
-        nullable_fields = ["tool_call_id"]
-        null_default_fields = []
+    type: CreatePromptResponseFormatPromptsType
 
-        serialized = handler(self)
 
-        m = {}
+class CreatePromptResponseFormatJSONObject(BaseModel):
+    r"""
 
-        for n, f in type(self).model_fields.items():
-            k = f.alias or n
-            val = serialized.get(k)
-            serialized.pop(k, None)
+    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    """
 
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
+    type: CreatePromptResponseFormatPromptsType
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
 
-        return m
+CreatePromptResponseFormatType = Literal["text",]
 
 
-CreatePromptContentPromptsRequest2TypedDict = TypeAliasType(
-    "CreatePromptContentPromptsRequest2TypedDict",
-    Union[
-        RefusalPartSchemaTypedDict,
-        RedactedReasoningPartSchemaTypedDict,
-        TextContentPartSchemaTypedDict,
-        ReasoningPartSchemaTypedDict,
-    ],
-)
+class CreatePromptResponseFormatTextTypedDict(TypedDict):
+    r"""
 
+    Default response format. Used to generate text responses
+    """
 
-CreatePromptContentPromptsRequest2 = Annotated[
-    Union[
-        Annotated[TextContentPartSchema, Tag("text")],
-        Annotated[RefusalPartSchema, Tag("refusal")],
-        Annotated[ReasoningPartSchema, Tag("reasoning")],
-        Annotated[RedactedReasoningPartSchema, Tag("redacted_reasoning")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+    type: CreatePromptResponseFormatType
 
 
-CreatePromptMessagesPromptsRequestContentTypedDict = TypeAliasType(
-    "CreatePromptMessagesPromptsRequestContentTypedDict",
-    Union[str, List[CreatePromptContentPromptsRequest2TypedDict]],
-)
-r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+class CreatePromptResponseFormatText(BaseModel):
+    r"""
+
+    Default response format. Used to generate text responses
+    """
 
+    type: CreatePromptResponseFormatType
 
-CreatePromptMessagesPromptsRequestContent = TypeAliasType(
-    "CreatePromptMessagesPromptsRequestContent",
-    Union[str, List[CreatePromptContentPromptsRequest2]],
+
+CreatePromptResponseFormatTypedDict = TypeAliasType(
+    "CreatePromptResponseFormatTypedDict",
+    Union[
+        CreatePromptResponseFormatTextTypedDict,
+        CreatePromptResponseFormatJSONObjectTypedDict,
+        CreatePromptResponseFormatJSONSchemaTypedDict,
+    ],
 )
-r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+r"""An object specifying the format that the model must output"""
 
 
-CreatePromptMessagesPromptsRequestRole = Literal["assistant",]
-r"""The role of the messages author, in this case `assistant`."""
+CreatePromptResponseFormat = Annotated[
+    Union[
+        Annotated[CreatePromptResponseFormatText, Tag("text")],
+        Annotated[CreatePromptResponseFormatJSONObject, Tag("json_object")],
+        Annotated[CreatePromptResponseFormatJSONSchema, Tag("json_schema")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""An object specifying the format that the model must output"""
 
 
-class CreatePromptMessagesAudioTypedDict(TypedDict):
-    r"""Data about a previous audio response from the model."""
+CreatePromptReasoningEffort = Literal[
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]
+r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 
-    id: str
-    r"""Unique identifier for a previous audio response from the model."""
+- `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+- All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+- The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+- `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 
+Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
+"""
 
-class CreatePromptMessagesAudio(BaseModel):
-    r"""Data about a previous audio response from the model."""
 
-    id: str
-    r"""Unique identifier for a previous audio response from the model."""
+CreatePromptStopTypedDict = TypeAliasType(
+    "CreatePromptStopTypedDict", Union[str, List[str]]
+)
+r"""Up to 4 sequences where the API will stop generating further tokens."""
 
 
-CreatePromptMessagesType = Literal["function",]
-r"""The type of the tool. Currently, only `function` is supported."""
+CreatePromptStop = TypeAliasType("CreatePromptStop", Union[str, List[str]])
+r"""Up to 4 sequences where the API will stop generating further tokens."""
 
 
-class CreatePromptMessagesFunctionTypedDict(TypedDict):
-    name: NotRequired[str]
-    r"""The name of the function to call."""
-    arguments: NotRequired[str]
-    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
+class CreatePromptStreamOptionsTypedDict(TypedDict):
+    r"""Options for streaming response. Only set this when you set stream: true."""
 
+    include_usage: NotRequired[bool]
+    r"""If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value."""
 
-class CreatePromptMessagesFunction(BaseModel):
-    name: Optional[str] = None
-    r"""The name of the function to call."""
 
-    arguments: Optional[str] = None
-    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
+class CreatePromptStreamOptions(BaseModel):
+    r"""Options for streaming response. Only set this when you set stream: true."""
 
+    include_usage: Optional[bool] = None
+    r"""If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value."""
 
-class CreatePromptMessagesToolCallsTypedDict(TypedDict):
-    id: str
-    r"""The ID of the tool call."""
-    type: CreatePromptMessagesType
-    r"""The type of the tool. Currently, only `function` is supported."""
-    function: CreatePromptMessagesFunctionTypedDict
-    thought_signature: NotRequired[str]
-    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["include_usage"])
+        serialized = handler(self)
+        m = {}
 
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-class CreatePromptMessagesToolCalls(BaseModel):
-    id: str
-    r"""The ID of the tool call."""
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    type: CreatePromptMessagesType
-    r"""The type of the tool. Currently, only `function` is supported."""
+        return m
 
-    function: CreatePromptMessagesFunction
 
-    thought_signature: Optional[str] = None
-    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+CreatePromptThinkingTypedDict = TypeAliasType(
+    "CreatePromptThinkingTypedDict",
+    Union[ThinkingConfigDisabledSchemaTypedDict, ThinkingConfigEnabledSchemaTypedDict],
+)
 
 
-class CreatePromptMessagesAssistantMessageTypedDict(TypedDict):
-    role: CreatePromptMessagesPromptsRequestRole
-    r"""The role of the messages author, in this case `assistant`."""
-    content: NotRequired[Nullable[CreatePromptMessagesPromptsRequestContentTypedDict]]
-    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
-    refusal: NotRequired[Nullable[str]]
-    r"""The refusal message by the assistant."""
-    name: NotRequired[str]
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
-    audio: NotRequired[Nullable[CreatePromptMessagesAudioTypedDict]]
-    r"""Data about a previous audio response from the model."""
-    tool_calls: NotRequired[List[CreatePromptMessagesToolCallsTypedDict]]
-    r"""The tool calls generated by the model, such as function calls."""
+CreatePromptThinking = Annotated[
+    Union[
+        Annotated[ThinkingConfigDisabledSchema, Tag("disabled")],
+        Annotated[ThinkingConfigEnabledSchema, Tag("enabled")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
 
 
-class CreatePromptMessagesAssistantMessage(BaseModel):
-    role: CreatePromptMessagesPromptsRequestRole
-    r"""The role of the messages author, in this case `assistant`."""
+CreatePromptToolChoiceType = Literal["function",]
+r"""The type of the tool. Currently, only function is supported."""
 
-    content: OptionalNullable[CreatePromptMessagesPromptsRequestContent] = UNSET
-    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
-    refusal: OptionalNullable[str] = UNSET
-    r"""The refusal message by the assistant."""
+class CreatePromptToolChoiceFunctionTypedDict(TypedDict):
+    name: str
+    r"""The name of the function to call."""
 
-    name: Optional[str] = None
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-    audio: OptionalNullable[CreatePromptMessagesAudio] = UNSET
-    r"""Data about a previous audio response from the model."""
+class CreatePromptToolChoiceFunction(BaseModel):
+    name: str
+    r"""The name of the function to call."""
 
-    tool_calls: Optional[List[CreatePromptMessagesToolCalls]] = None
-    r"""The tool calls generated by the model, such as function calls."""
+
+class CreatePromptToolChoice2TypedDict(TypedDict):
+    function: CreatePromptToolChoiceFunctionTypedDict
+    type: NotRequired[CreatePromptToolChoiceType]
+    r"""The type of the tool. Currently, only function is supported."""
+
+
+class CreatePromptToolChoice2(BaseModel):
+    function: CreatePromptToolChoiceFunction
+
+    type: Optional[CreatePromptToolChoiceType] = None
+    r"""The type of the tool. Currently, only function is supported."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["content", "refusal", "name", "audio", "tool_calls"]
-        nullable_fields = ["content", "refusal", "audio"]
-        null_default_fields = []
-
+        optional_fields = set(["type"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
         return m
 
 
-CreatePromptMessagesPromptsRole = Literal["user",]
-r"""The role of the messages author, in this case `user`."""
+CreatePromptToolChoice1 = Literal[
+    "none",
+    "auto",
+    "required",
+]
 
 
-CreatePrompt2PromptsRequestRequestBodyType = Literal["file",]
-r"""The type of the content part. Always `file`."""
+CreatePromptToolChoiceTypedDict = TypeAliasType(
+    "CreatePromptToolChoiceTypedDict",
+    Union[CreatePromptToolChoice2TypedDict, CreatePromptToolChoice1],
+)
+r"""Controls which (if any) tool is called by the model."""
 
 
-CreatePrompt2PromptsRequestRequestBodyPromptType = Literal["ephemeral",]
-r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+CreatePromptToolChoice = TypeAliasType(
+    "CreatePromptToolChoice", Union[CreatePromptToolChoice2, CreatePromptToolChoice1]
+)
+r"""Controls which (if any) tool is called by the model."""
 
 
-CreatePrompt2TTL = Literal[
-    "5m",
-    "1h",
+CreatePromptModalities = Literal[
+    "text",
+    "audio",
 ]
-r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
-- `5m`: 5 minutes
-- `1h`: 1 hour
 
-Defaults to `5m`. Only supported by `Anthropic` Claude models.
-"""
+CreatePromptID1 = Literal[
+    "orq_pii_detection",
+    "orq_sexual_moderation",
+    "orq_harmful_moderation",
+]
+r"""The key of the guardrail."""
 
 
-class CreatePrompt2CacheControlTypedDict(TypedDict):
-    type: CreatePrompt2PromptsRequestRequestBodyPromptType
-    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
-    ttl: NotRequired[CreatePrompt2TTL]
-    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+CreatePromptIDTypedDict = TypeAliasType(
+    "CreatePromptIDTypedDict", Union[CreatePromptID1, str]
+)
 
-    - `5m`: 5 minutes
-    - `1h`: 1 hour
 
-    Defaults to `5m`. Only supported by `Anthropic` Claude models.
-    """
+CreatePromptID = TypeAliasType("CreatePromptID", Union[CreatePromptID1, str])
 
 
-class CreatePrompt2CacheControl(BaseModel):
-    type: CreatePrompt2PromptsRequestRequestBodyPromptType
-    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+CreatePromptExecuteOn = Literal[
+    "input",
+    "output",
+]
+r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
-    ttl: Optional[CreatePrompt2TTL] = "5m"
-    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
 
-    - `5m`: 5 minutes
-    - `1h`: 1 hour
+class CreatePromptGuardrailsTypedDict(TypedDict):
+    id: CreatePromptIDTypedDict
+    execute_on: CreatePromptExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
-    Defaults to `5m`. Only supported by `Anthropic` Claude models.
-    """
 
+class CreatePromptGuardrails(BaseModel):
+    id: CreatePromptID
 
-class CreatePrompt24TypedDict(TypedDict):
-    type: CreatePrompt2PromptsRequestRequestBodyType
-    r"""The type of the content part. Always `file`."""
-    file: FileContentPartSchemaTypedDict
-    r"""File data for the content part. Must contain either file_data or uri, but not both."""
-    cache_control: NotRequired[CreatePrompt2CacheControlTypedDict]
+    execute_on: CreatePromptExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
-class CreatePrompt24(BaseModel):
-    type: CreatePrompt2PromptsRequestRequestBodyType
-    r"""The type of the content part. Always `file`."""
+class CreatePromptFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
 
-    file: FileContentPartSchema
-    r"""File data for the content part. Must contain either file_data or uri, but not both."""
 
-    cache_control: Optional[CreatePrompt2CacheControl] = None
+class CreatePromptFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
 
 
-CreatePromptContentPrompts2TypedDict = TypeAliasType(
-    "CreatePromptContentPrompts2TypedDict",
-    Union[
-        AudioContentPartSchemaTypedDict,
-        TextContentPartSchemaTypedDict,
-        ImageContentPartSchemaTypedDict,
-        CreatePrompt24TypedDict,
-    ],
-)
+class CreatePromptRetryTypedDict(TypedDict):
+    r"""Retry configuration for the request"""
 
+    count: NotRequired[float]
+    r"""Number of retry attempts (1-5)"""
+    on_codes: NotRequired[List[float]]
+    r"""HTTP status codes that trigger retry logic"""
 
-CreatePromptContentPrompts2 = Annotated[
-    Union[
-        Annotated[TextContentPartSchema, Tag("text")],
-        Annotated[ImageContentPartSchema, Tag("image_url")],
-        Annotated[AudioContentPartSchema, Tag("input_audio")],
-        Annotated[CreatePrompt24, Tag("file")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
 
+class CreatePromptRetry(BaseModel):
+    r"""Retry configuration for the request"""
 
-CreatePromptMessagesPromptsContentTypedDict = TypeAliasType(
-    "CreatePromptMessagesPromptsContentTypedDict",
-    Union[str, List[CreatePromptContentPrompts2TypedDict]],
-)
-r"""The contents of the user message."""
+    count: Optional[float] = 3
+    r"""Number of retry attempts (1-5)"""
 
+    on_codes: Optional[List[float]] = None
+    r"""HTTP status codes that trigger retry logic"""
 
-CreatePromptMessagesPromptsContent = TypeAliasType(
-    "CreatePromptMessagesPromptsContent", Union[str, List[CreatePromptContentPrompts2]]
-)
-r"""The contents of the user message."""
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "on_codes"])
+        serialized = handler(self)
+        m = {}
 
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-class CreatePromptMessagesUserMessageTypedDict(TypedDict):
-    role: CreatePromptMessagesPromptsRole
-    r"""The role of the messages author, in this case `user`."""
-    content: CreatePromptMessagesPromptsContentTypedDict
-    r"""The contents of the user message."""
-    name: NotRequired[str]
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
+        return m
 
-class CreatePromptMessagesUserMessage(BaseModel):
-    role: CreatePromptMessagesPromptsRole
-    r"""The role of the messages author, in this case `user`."""
 
-    content: CreatePromptMessagesPromptsContent
-    r"""The contents of the user message."""
+CreatePromptType = Literal["exact_match",]
 
-    name: Optional[str] = None
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
+class CreatePromptCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
 
-CreatePromptMessagesRole = Literal["system",]
-r"""The role of the messages author, in this case `system`."""
+    type: CreatePromptType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
 
 
-CreatePromptMessagesContentTypedDict = TypeAliasType(
-    "CreatePromptMessagesContentTypedDict",
-    Union[str, List[TextContentPartSchemaTypedDict]],
-)
-r"""The contents of the system message."""
+class CreatePromptCache(BaseModel):
+    r"""Cache configuration for the request."""
 
+    type: CreatePromptType
 
-CreatePromptMessagesContent = TypeAliasType(
-    "CreatePromptMessagesContent", Union[str, List[TextContentPartSchema]]
-)
-r"""The contents of the system message."""
+    ttl: Optional[float] = 1800
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
 
-class CreatePromptMessagesSystemMessageTypedDict(TypedDict):
-    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-    role: CreatePromptMessagesRole
-    r"""The role of the messages author, in this case `system`."""
-    content: CreatePromptMessagesContentTypedDict
-    r"""The contents of the system message."""
-    name: NotRequired[str]
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
+        return m
 
-class CreatePromptMessagesSystemMessage(BaseModel):
-    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
-
-    role: CreatePromptMessagesRole
-    r"""The role of the messages author, in this case `system`."""
 
-    content: CreatePromptMessagesContent
-    r"""The contents of the system message."""
+CreatePromptLoadBalancerType = Literal["weight_based",]
 
-    name: Optional[str] = None
-    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
+class CreatePromptLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
 
-CreatePromptPromptsMessagesTypedDict = TypeAliasType(
-    "CreatePromptPromptsMessagesTypedDict",
-    Union[
-        CreatePromptMessagesSystemMessageTypedDict,
-        CreatePromptMessagesUserMessageTypedDict,
-        CreatePromptMessagesToolMessageTypedDict,
-        CreatePromptMessagesAssistantMessageTypedDict,
-    ],
-)
 
+class CreatePromptLoadBalancerModels(BaseModel):
+    model: str
+    r"""Model identifier for load balancing"""
 
-CreatePromptPromptsMessages = Annotated[
-    Union[
-        Annotated[CreatePromptMessagesSystemMessage, Tag("system")],
-        Annotated[CreatePromptMessagesUserMessage, Tag("user")],
-        Annotated[CreatePromptMessagesAssistantMessage, Tag("assistant")],
-        Annotated[CreatePromptMessagesToolMessage, Tag("tool")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "role", "role")),
-]
+    weight: Optional[float] = 0.5
+    r"""Weight assigned to this model for load balancing"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["weight"])
+        serialized = handler(self)
+        m = {}
 
-CreatePromptResponseFormatPromptsRequestRequestBodyPrompt3Type = Literal["json_schema",]
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-class CreatePromptResponseFormatPromptsRequestJSONSchemaTypedDict(TypedDict):
-    name: str
-    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
-    description: NotRequired[str]
-    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
-    schema_: NotRequired[Any]
-    r"""The schema for the response format, described as a JSON Schema object."""
-    strict: NotRequired[bool]
-    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
+        return m
 
 
-class CreatePromptResponseFormatPromptsRequestJSONSchema(BaseModel):
-    name: str
-    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
+class CreatePromptLoadBalancer1TypedDict(TypedDict):
+    type: CreatePromptLoadBalancerType
+    models: List[CreatePromptLoadBalancerModelsTypedDict]
 
-    description: Optional[str] = None
-    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
 
-    schema_: Annotated[Optional[Any], pydantic.Field(alias="schema")] = None
-    r"""The schema for the response format, described as a JSON Schema object."""
+class CreatePromptLoadBalancer1(BaseModel):
+    type: CreatePromptLoadBalancerType
 
-    strict: Optional[bool] = False
-    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
+    models: List[CreatePromptLoadBalancerModels]
 
 
-class CreatePromptResponseFormatPromptsJSONSchemaTypedDict(TypedDict):
-    r"""
+CreatePromptLoadBalancerTypedDict = CreatePromptLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
 
-    JSON Schema response format. Used to generate structured JSON responses
-    """
 
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyPrompt3Type
-    json_schema: CreatePromptResponseFormatPromptsRequestJSONSchemaTypedDict
+CreatePromptLoadBalancer = CreatePromptLoadBalancer1
+r"""Load balancer configuration for the request."""
 
 
-class CreatePromptResponseFormatPromptsJSONSchema(BaseModel):
-    r"""
+class CreatePromptTimeoutTypedDict(TypedDict):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
 
-    JSON Schema response format. Used to generate structured JSON responses
-    """
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
 
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyPrompt3Type
 
-    json_schema: CreatePromptResponseFormatPromptsRequestJSONSchema
+class CreatePromptTimeout(BaseModel):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
 
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
 
-CreatePromptResponseFormatPromptsRequestRequestBodyPromptType = Literal["json_object",]
 
+class PromptInputTypedDict(TypedDict):
+    r"""Prompt configuration with model and messages."""
 
-class CreatePromptResponseFormatJSONObjectTypedDict(TypedDict):
-    r"""
+    messages: List[CreatePromptMessagesTypedDict]
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
+    model: NotRequired[str]
+    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+    audio: NotRequired[Nullable[CreatePromptAudioTypedDict]]
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+    frequency_penalty: NotRequired[Nullable[float]]
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim."""
+    max_tokens: NotRequired[Nullable[int]]
+    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
 
-    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
     """
+    max_completion_tokens: NotRequired[Nullable[int]]
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
+    logprobs: NotRequired[Nullable[bool]]
+    r"""Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message."""
+    top_logprobs: NotRequired[Nullable[int]]
+    r"""An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used."""
+    n: NotRequired[Nullable[int]]
+    r"""How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs."""
+    presence_penalty: NotRequired[Nullable[float]]
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics."""
+    response_format: NotRequired[CreatePromptResponseFormatTypedDict]
+    r"""An object specifying the format that the model must output"""
+    reasoning_effort: NotRequired[CreatePromptReasoningEffort]
+    r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyPromptType
-
-
-class CreatePromptResponseFormatJSONObject(BaseModel):
-    r"""
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 
-    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
     """
-
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyPromptType
+    verbosity: NotRequired[str]
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
+    seed: NotRequired[Nullable[float]]
+    r"""If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result."""
+    stop: NotRequired[Nullable[CreatePromptStopTypedDict]]
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
+    stream_options: NotRequired[Nullable[CreatePromptStreamOptionsTypedDict]]
+    r"""Options for streaming response. Only set this when you set stream: true."""
+    thinking: NotRequired[CreatePromptThinkingTypedDict]
+    temperature: NotRequired[Nullable[float]]
+    r"""What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."""
+    top_p: NotRequired[Nullable[float]]
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
+    top_k: NotRequired[Nullable[float]]
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
+    tool_choice: NotRequired[CreatePromptToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model."""
+    parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use."""
+    modalities: NotRequired[Nullable[List[CreatePromptModalities]]]
+    r"""Output types that you would like the model to generate. Most models are capable of generating text, which is the default: [\"text\"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: [\"text\", \"audio\"]."""
+    guardrails: NotRequired[List[CreatePromptGuardrailsTypedDict]]
+    r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[CreatePromptFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreatePromptRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreatePromptCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreatePromptLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreatePromptTimeoutTypedDict]
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
 
 
-CreatePromptResponseFormatPromptsRequestRequestBodyType = Literal["text",]
+class PromptInput(BaseModel):
+    r"""Prompt configuration with model and messages."""
 
+    messages: List[CreatePromptMessages]
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
 
-class CreatePromptResponseFormatTextTypedDict(TypedDict):
-    r"""
+    model: Optional[str] = None
+    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
 
-    Default response format. Used to generate text responses
-    """
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
 
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyType
+    audio: OptionalNullable[CreatePromptAudio] = UNSET
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
+    frequency_penalty: OptionalNullable[float] = UNSET
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim."""
 
-class CreatePromptResponseFormatText(BaseModel):
-    r"""
+    max_tokens: OptionalNullable[int] = UNSET
+    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
 
-    Default response format. Used to generate text responses
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
     """
 
-    type: CreatePromptResponseFormatPromptsRequestRequestBodyType
+    max_completion_tokens: OptionalNullable[int] = UNSET
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
 
+    logprobs: OptionalNullable[bool] = UNSET
+    r"""Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message."""
 
-CreatePromptPromptsResponseFormatTypedDict = TypeAliasType(
-    "CreatePromptPromptsResponseFormatTypedDict",
-    Union[
-        CreatePromptResponseFormatTextTypedDict,
-        CreatePromptResponseFormatJSONObjectTypedDict,
-        CreatePromptResponseFormatPromptsJSONSchemaTypedDict,
-    ],
-)
-r"""An object specifying the format that the model must output"""
+    top_logprobs: OptionalNullable[int] = UNSET
+    r"""An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used."""
 
+    n: OptionalNullable[int] = UNSET
+    r"""How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs."""
 
-CreatePromptPromptsResponseFormat = Annotated[
-    Union[
-        Annotated[CreatePromptResponseFormatText, Tag("text")],
-        Annotated[CreatePromptResponseFormatJSONObject, Tag("json_object")],
-        Annotated[CreatePromptResponseFormatPromptsJSONSchema, Tag("json_schema")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
-r"""An object specifying the format that the model must output"""
+    presence_penalty: OptionalNullable[float] = UNSET
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics."""
 
+    response_format: Optional[CreatePromptResponseFormat] = None
+    r"""An object specifying the format that the model must output"""
 
-class PromptInputTypedDict(TypedDict):
-    r"""Prompt configuration with model and messages. Either this field or `prompt_config` must be provided."""
+    reasoning_effort: Optional[CreatePromptReasoningEffort] = None
+    r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 
-    messages: List[CreatePromptPromptsMessagesTypedDict]
-    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
-    model: NotRequired[str]
-    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
-    temperature: NotRequired[Nullable[float]]
-    r"""What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."""
-    max_tokens: NotRequired[Nullable[int]]
-    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 
-    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+    Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
     """
-    response_format: NotRequired[CreatePromptPromptsResponseFormatTypedDict]
-    r"""An object specifying the format that the model must output"""
 
+    verbosity: Optional[str] = None
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
 
-class PromptInput(BaseModel):
-    r"""Prompt configuration with model and messages. Either this field or `prompt_config` must be provided."""
+    seed: OptionalNullable[float] = UNSET
+    r"""If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result."""
 
-    messages: List[CreatePromptPromptsMessages]
-    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
+    stop: OptionalNullable[CreatePromptStop] = UNSET
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
 
-    model: Optional[str] = None
-    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
+    stream_options: OptionalNullable[CreatePromptStreamOptions] = UNSET
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    thinking: Optional[CreatePromptThinking] = None
 
     temperature: OptionalNullable[float] = UNSET
     r"""What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."""
 
-    max_tokens: OptionalNullable[int] = UNSET
-    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
+    top_p: OptionalNullable[float] = UNSET
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
 
-    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
-    """
+    top_k: OptionalNullable[float] = UNSET
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
 
-    response_format: Optional[CreatePromptPromptsResponseFormat] = None
-    r"""An object specifying the format that the model must output"""
+    tool_choice: Optional[CreatePromptToolChoice] = None
+    r"""Controls which (if any) tool is called by the model."""
+
+    parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use."""
+
+    modalities: OptionalNullable[List[CreatePromptModalities]] = UNSET
+    r"""Output types that you would like the model to generate. Most models are capable of generating text, which is the default: [\"text\"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: [\"text\", \"audio\"]."""
+
+    guardrails: Optional[List[CreatePromptGuardrails]] = None
+    r"""A list of guardrails to apply to the request."""
+
+    fallbacks: Optional[List[CreatePromptFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreatePromptRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreatePromptCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreatePromptLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreatePromptTimeout] = None
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["model", "temperature", "max_tokens", "response_format"]
-        nullable_fields = ["temperature", "max_tokens"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "model",
+                "name",
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "response_format",
+                "reasoning_effort",
+                "verbosity",
+                "seed",
+                "stop",
+                "stream_options",
+                "thinking",
+                "temperature",
+                "top_p",
+                "top_k",
+                "tool_choice",
+                "parallel_tool_calls",
+                "modalities",
+                "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "seed",
+                "stop",
+                "stream_options",
+                "temperature",
+                "top_p",
+                "top_k",
+                "modalities",
+            ]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
@@ -1384,10 +1456,8 @@ class CreatePromptRequestBodyTypedDict(TypedDict):
     description: NotRequired[Nullable[str]]
     r"""The prompt’s description, meant to be displayable in the UI. Use this field to optionally store a long form explanation of the prompt for your own purpose"""
     metadata: NotRequired[CreatePromptMetadataTypedDict]
-    prompt_config: NotRequired[PromptConfigurationTypedDict]
-    r"""[DEPRECATED]. Please use the `prompt` property instead. The current `prompt_config` will keep working but it will be deprecated in future versions. Configuration for the prompt including model and messages."""
     prompt: NotRequired[PromptInputTypedDict]
-    r"""Prompt configuration with model and messages. Either this field or `prompt_config` must be provided."""
+    r"""Prompt configuration with model and messages."""
 
 
 class CreatePromptRequestBody(BaseModel):
@@ -1407,44 +1477,31 @@ class CreatePromptRequestBody(BaseModel):
 
     metadata: Optional[CreatePromptMetadata] = None
 
-    prompt_config: Annotated[
-        Optional[PromptConfiguration],
-        pydantic.Field(
-            deprecated="warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
-        ),
-    ] = None
-    r"""[DEPRECATED]. Please use the `prompt` property instead. The current `prompt_config` will keep working but it will be deprecated in future versions. Configuration for the prompt including model and messages."""
-
     prompt: Optional[PromptInput] = None
-    r"""Prompt configuration with model and messages. Either this field or `prompt_config` must be provided."""
+    r"""Prompt configuration with model and messages."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["description", "metadata", "prompt_config", "prompt"]
-        nullable_fields = ["description"]
-        null_default_fields = []
-
+        optional_fields = set(["description", "metadata", "prompt"])
+        nullable_fields = set(["description"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
@@ -1452,7 +1509,7 @@ class CreatePromptRequestBody(BaseModel):
 CreatePromptPromptsType = Literal["prompt",]
 
 
-CreatePromptModelType = Literal[
+ModelType = Literal[
     "chat",
     "completion",
     "embedding",
@@ -1460,6 +1517,7 @@ CreatePromptModelType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]
@@ -1500,39 +1558,47 @@ CreatePromptResponseFormat4 = Literal[
 ]
 
 
-CreatePromptResponseFormatPromptsResponse200ApplicationJSONType = Literal["text",]
+CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigModelParametersType = Literal[
+    "text",
+]
 
 
 class CreatePromptResponseFormat3TypedDict(TypedDict):
-    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONType
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigModelParametersType
 
 
 class CreatePromptResponseFormat3(BaseModel):
-    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONType
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigModelParametersType
 
 
-CreatePromptResponseFormatPromptsResponse200Type = Literal["json_object",]
+CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigType = Literal[
+    "json_object",
+]
 
 
 class CreatePromptResponseFormat2TypedDict(TypedDict):
-    type: CreatePromptResponseFormatPromptsResponse200Type
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigType
 
 
 class CreatePromptResponseFormat2(BaseModel):
-    type: CreatePromptResponseFormatPromptsResponse200Type
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyPromptConfigType
 
 
-CreatePromptResponseFormatPromptsResponseType = Literal["json_schema",]
+CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyType = Literal[
+    "json_schema",
+]
 
 
-class CreatePromptResponseFormatPromptsResponseJSONSchemaTypedDict(TypedDict):
+class CreatePromptResponseFormatPromptsResponse200ApplicationJSONJSONSchemaTypedDict(
+    TypedDict
+):
     name: str
     schema_: Dict[str, Any]
     description: NotRequired[str]
     strict: NotRequired[bool]
 
 
-class CreatePromptResponseFormatPromptsResponseJSONSchema(BaseModel):
+class CreatePromptResponseFormatPromptsResponse200ApplicationJSONJSONSchema(BaseModel):
     name: str
 
     schema_: Annotated[Dict[str, Any], pydantic.Field(alias="schema")]
@@ -1541,20 +1607,54 @@ class CreatePromptResponseFormatPromptsResponseJSONSchema(BaseModel):
 
     strict: Optional[bool] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "strict"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class CreatePromptResponseFormat1TypedDict(TypedDict):
-    type: CreatePromptResponseFormatPromptsResponseType
-    json_schema: CreatePromptResponseFormatPromptsResponseJSONSchemaTypedDict
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
+    json_schema: (
+        CreatePromptResponseFormatPromptsResponse200ApplicationJSONJSONSchemaTypedDict
+    )
     display_name: NotRequired[str]
 
 
 class CreatePromptResponseFormat1(BaseModel):
-    type: CreatePromptResponseFormatPromptsResponseType
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONResponseBodyType
 
-    json_schema: CreatePromptResponseFormatPromptsResponseJSONSchema
+    json_schema: CreatePromptResponseFormatPromptsResponse200ApplicationJSONJSONSchema
 
     display_name: Optional[str] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["display_name"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 CreatePromptPromptsResponseResponseFormatTypedDict = TypeAliasType(
     "CreatePromptPromptsResponseResponseFormatTypedDict",
@@ -1612,7 +1712,7 @@ CreatePromptEncodingFormat = Literal[
 r"""The format to return the embeddings"""
 
 
-CreatePromptPromptsReasoningEffort = Literal[
+CreatePromptPromptsResponseReasoningEffort = Literal[
     "none",
     "disable",
     "minimal",
@@ -1631,14 +1731,14 @@ CreatePromptVerbosity = Literal[
 r"""Controls the verbosity of the model output."""
 
 
-CreatePromptPromptsThinkingLevel = Literal[
+CreatePromptThinkingLevel = Literal[
     "low",
     "high",
 ]
 r"""The level of thinking to use for the model. Only supported by `Google AI`"""
 
 
-class CreatePromptModelParametersTypedDict(TypedDict):
+class ModelParametersTypedDict(TypedDict):
     r"""Model Parameters: Not all parameters apply to every model"""
 
     temperature: NotRequired[float]
@@ -1680,17 +1780,17 @@ class CreatePromptModelParametersTypedDict(TypedDict):
     r"""The version of photoReal to use. Must be v1 or v2. Only available for `leonardoai` provider"""
     encoding_format: NotRequired[CreatePromptEncodingFormat]
     r"""The format to return the embeddings"""
-    reasoning_effort: NotRequired[CreatePromptPromptsReasoningEffort]
+    reasoning_effort: NotRequired[CreatePromptPromptsResponseReasoningEffort]
     r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
     budget_tokens: NotRequired[float]
     r"""Gives the model enhanced reasoning capabilities for complex tasks. A value of 0 disables thinking. The minimum budget tokens for thinking are 1024. The Budget Tokens should never exceed the Max Tokens parameter. Only supported by `Anthropic`"""
     verbosity: NotRequired[CreatePromptVerbosity]
     r"""Controls the verbosity of the model output."""
-    thinking_level: NotRequired[CreatePromptPromptsThinkingLevel]
+    thinking_level: NotRequired[CreatePromptThinkingLevel]
     r"""The level of thinking to use for the model. Only supported by `Google AI`"""
 
 
-class CreatePromptModelParameters(BaseModel):
+class ModelParameters(BaseModel):
     r"""Model Parameters: Not all parameters apply to every model"""
 
     temperature: Optional[float] = None
@@ -1757,7 +1857,7 @@ class CreatePromptModelParameters(BaseModel):
     r"""The format to return the embeddings"""
 
     reasoning_effort: Annotated[
-        Optional[CreatePromptPromptsReasoningEffort],
+        Optional[CreatePromptPromptsResponseReasoningEffort],
         pydantic.Field(alias="reasoningEffort"),
     ] = None
     r"""Constrains effort on reasoning for reasoning models. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response."""
@@ -1767,403 +1867,1803 @@ class CreatePromptModelParameters(BaseModel):
     )
     r"""Gives the model enhanced reasoning capabilities for complex tasks. A value of 0 disables thinking. The minimum budget tokens for thinking are 1024. The Budget Tokens should never exceed the Max Tokens parameter. Only supported by `Anthropic`"""
 
-    verbosity: Optional[CreatePromptVerbosity] = None
-    r"""Controls the verbosity of the model output."""
+    verbosity: Optional[CreatePromptVerbosity] = None
+    r"""Controls the verbosity of the model output."""
+
+    thinking_level: Annotated[
+        Optional[CreatePromptThinkingLevel], pydantic.Field(alias="thinkingLevel")
+    ] = None
+    r"""The level of thinking to use for the model. Only supported by `Google AI`"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "temperature",
+                "maxTokens",
+                "topK",
+                "topP",
+                "frequencyPenalty",
+                "presencePenalty",
+                "numImages",
+                "seed",
+                "format",
+                "dimensions",
+                "quality",
+                "style",
+                "responseFormat",
+                "photoRealVersion",
+                "encoding_format",
+                "reasoningEffort",
+                "budgetTokens",
+                "verbosity",
+                "thinkingLevel",
+            ]
+        )
+        nullable_fields = set(["responseFormat"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+CreatePromptProvider = Literal[
+    "openai",
+    "groq",
+    "cohere",
+    "azure",
+    "aws",
+    "google",
+    "google-ai",
+    "huggingface",
+    "togetherai",
+    "perplexity",
+    "anthropic",
+    "leonardoai",
+    "fal",
+    "nvidia",
+    "jina",
+    "elevenlabs",
+    "litellm",
+    "cerebras",
+    "openailike",
+    "bytedance",
+    "mistral",
+    "deepseek",
+    "contextualai",
+    "moonshotai",
+    "zai",
+    "slack",
+]
+
+
+CreatePromptRole = Literal[
+    "system",
+    "assistant",
+    "user",
+    "exception",
+    "tool",
+    "prompt",
+    "correction",
+    "expected_output",
+]
+r"""The role of the prompt message"""
+
+
+CreatePrompt2PromptsResponse200ApplicationJSONType = Literal["file",]
+r"""The type of the content part. Always `file`."""
+
+
+class CreatePrompt2FileTypedDict(TypedDict):
+    file_data: NotRequired[str]
+    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
+    uri: NotRequired[str]
+    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
+    mime_type: NotRequired[str]
+    r"""MIME type of the file (e.g., application/pdf, image/png)"""
+    filename: NotRequired[str]
+    r"""The name of the file, used when passing the file to the model as a string."""
+
+
+class CreatePrompt2File(BaseModel):
+    file_data: Optional[str] = None
+    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
+
+    uri: Optional[str] = None
+    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
+
+    mime_type: Annotated[Optional[str], pydantic.Field(alias="mimeType")] = None
+    r"""MIME type of the file (e.g., application/pdf, image/png)"""
+
+    filename: Optional[str] = None
+    r"""The name of the file, used when passing the file to the model as a string."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["file_data", "uri", "mimeType", "filename"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePrompt23TypedDict(TypedDict):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONType
+    r"""The type of the content part. Always `file`."""
+    file: CreatePrompt2FileTypedDict
+
+
+class CreatePrompt23(BaseModel):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONType
+    r"""The type of the content part. Always `file`."""
+
+    file: CreatePrompt2File
+
+
+CreatePrompt2PromptsResponse200Type = Literal["image_url",]
+
+
+class CreatePrompt2ImageURLTypedDict(TypedDict):
+    url: str
+    r"""Either a URL of the image or the base64 encoded data URI."""
+    id: NotRequired[str]
+    r"""The orq.ai id of the image"""
+    detail: NotRequired[str]
+    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+
+
+class CreatePrompt2ImageURL(BaseModel):
+    url: str
+    r"""Either a URL of the image or the base64 encoded data URI."""
+
+    id: Optional[str] = None
+    r"""The orq.ai id of the image"""
+
+    detail: Optional[str] = None
+    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "detail"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePrompt22TypedDict(TypedDict):
+    r"""The image part of the prompt message. Only supported with vision models."""
+
+    type: CreatePrompt2PromptsResponse200Type
+    image_url: CreatePrompt2ImageURLTypedDict
+
+
+class CreatePrompt22(BaseModel):
+    r"""The image part of the prompt message. Only supported with vision models."""
+
+    type: CreatePrompt2PromptsResponse200Type
+
+    image_url: CreatePrompt2ImageURL
+
+
+CreatePrompt2PromptsResponseType = Literal["text",]
+
+
+class CreatePrompt21TypedDict(TypedDict):
+    r"""Text content part of a prompt message"""
+
+    type: CreatePrompt2PromptsResponseType
+    text: str
+
+
+class CreatePrompt21(BaseModel):
+    r"""Text content part of a prompt message"""
+
+    type: CreatePrompt2PromptsResponseType
+
+    text: str
+
+
+CreatePromptContentPromptsResponse2TypedDict = TypeAliasType(
+    "CreatePromptContentPromptsResponse2TypedDict",
+    Union[CreatePrompt21TypedDict, CreatePrompt22TypedDict, CreatePrompt23TypedDict],
+)
+
+
+CreatePromptContentPromptsResponse2 = Annotated[
+    Union[
+        Annotated[CreatePrompt21, Tag("text")],
+        Annotated[CreatePrompt22, Tag("image_url")],
+        Annotated[CreatePrompt23, Tag("file")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+CreatePromptContentTypedDict = TypeAliasType(
+    "CreatePromptContentTypedDict",
+    Union[str, List[CreatePromptContentPromptsResponse2TypedDict]],
+)
+r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+
+
+CreatePromptContent = TypeAliasType(
+    "CreatePromptContent", Union[str, List[CreatePromptContentPromptsResponse2]]
+)
+r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+
+
+CreatePromptPromptsResponse200Type = Literal["function",]
+
+
+class CreatePromptFunctionTypedDict(TypedDict):
+    name: str
+    arguments: str
+    r"""JSON string arguments for the functions"""
+
+
+class CreatePromptFunction(BaseModel):
+    name: str
+
+    arguments: str
+    r"""JSON string arguments for the functions"""
+
+
+class CreatePromptToolCallsTypedDict(TypedDict):
+    type: CreatePromptPromptsResponse200Type
+    function: CreatePromptFunctionTypedDict
+    id: NotRequired[str]
+    index: NotRequired[float]
+
+
+class CreatePromptToolCalls(BaseModel):
+    type: CreatePromptPromptsResponse200Type
+
+    function: CreatePromptFunction
+
+    id: Optional[str] = None
+
+    index: Optional[float] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "index"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptPromptsMessagesTypedDict(TypedDict):
+    role: CreatePromptRole
+    r"""The role of the prompt message"""
+    content: Nullable[CreatePromptContentTypedDict]
+    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+    tool_calls: NotRequired[List[CreatePromptToolCallsTypedDict]]
+    tool_call_id: NotRequired[Nullable[str]]
+
+
+class CreatePromptPromptsMessages(BaseModel):
+    role: CreatePromptRole
+    r"""The role of the prompt message"""
+
+    content: Nullable[CreatePromptContent]
+    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+
+    tool_calls: Optional[List[CreatePromptToolCalls]] = None
+
+    tool_call_id: OptionalNullable[str] = UNSET
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["tool_calls", "tool_call_id"])
+        nullable_fields = set(["content", "tool_call_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
+class PromptConfigTypedDict(TypedDict):
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
+
+    messages: List[CreatePromptPromptsMessagesTypedDict]
+    stream: NotRequired[bool]
+    model: NotRequired[Nullable[str]]
+    model_db_id: NotRequired[Nullable[str]]
+    r"""The id of the resource"""
+    model_type: NotRequired[Nullable[ModelType]]
+    r"""The modality of the model"""
+    model_parameters: NotRequired[ModelParametersTypedDict]
+    r"""Model Parameters: Not all parameters apply to every model"""
+    provider: NotRequired[Nullable[CreatePromptProvider]]
+    integration_id: NotRequired[Nullable[str]]
+    r"""The ID of the integration to use"""
+    version: NotRequired[str]
+
+
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
+class PromptConfig(BaseModel):
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
+
+    messages: List[CreatePromptPromptsMessages]
+
+    stream: Optional[bool] = None
+
+    model: OptionalNullable[str] = UNSET
+
+    model_db_id: OptionalNullable[str] = UNSET
+    r"""The id of the resource"""
+
+    model_type: OptionalNullable[ModelType] = UNSET
+    r"""The modality of the model"""
+
+    model_parameters: Optional[ModelParameters] = None
+    r"""Model Parameters: Not all parameters apply to every model"""
+
+    provider: OptionalNullable[CreatePromptProvider] = UNSET
+
+    integration_id: OptionalNullable[str] = UNSET
+    r"""The ID of the integration to use"""
+
+    version: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "stream",
+                "model",
+                "model_db_id",
+                "model_type",
+                "model_parameters",
+                "provider",
+                "integration_id",
+                "version",
+            ]
+        )
+        nullable_fields = set(
+            ["model", "model_db_id", "model_type", "provider", "integration_id"]
+        )
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+CreatePromptPromptsVoice = Literal[
+    "alloy",
+    "echo",
+    "fable",
+    "onyx",
+    "nova",
+    "shimmer",
+]
+r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+
+
+CreatePromptPromptsResponse200Format = Literal[
+    "wav",
+    "mp3",
+    "flac",
+    "opus",
+    "pcm16",
+]
+r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
+
+
+class CreatePromptPromptsAudioTypedDict(TypedDict):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+
+    voice: CreatePromptPromptsVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+    format_: CreatePromptPromptsResponse200Format
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
+
+
+class CreatePromptPromptsAudio(BaseModel):
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+
+    voice: CreatePromptPromptsVoice
+    r"""The voice the model uses to respond. Supported voices are alloy, echo, fable, onyx, nova, and shimmer."""
+
+    format_: Annotated[
+        CreatePromptPromptsResponse200Format, pydantic.Field(alias="format")
+    ]
+    r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
+
+
+CreatePromptResponseFormatPromptsResponse200ApplicationJSONType = Literal[
+    "json_schema",
+]
+
+
+class CreatePromptResponseFormatPromptsResponseJSONSchemaTypedDict(TypedDict):
+    name: str
+    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
+    description: NotRequired[str]
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
+    schema_: NotRequired[Any]
+    r"""The schema for the response format, described as a JSON Schema object."""
+    strict: NotRequired[bool]
+    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
+
+
+class CreatePromptResponseFormatPromptsResponseJSONSchema(BaseModel):
+    name: str
+    r"""The name of the response format. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
+
+    description: Optional[str] = None
+    r"""A description of what the response format is for, used by the model to determine how to respond in the format."""
+
+    schema_: Annotated[Optional[Any], pydantic.Field(alias="schema")] = None
+    r"""The schema for the response format, described as a JSON Schema object."""
+
+    strict: Optional[bool] = False
+    r"""Whether to enable strict schema adherence when generating the output. If set to true, the model will always follow the exact schema defined in the schema field. Only a subset of JSON Schema is supported when strict is true."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "schema", "strict"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptResponseFormatPromptsResponse200JSONSchemaTypedDict(TypedDict):
+    r"""
+
+    JSON Schema response format. Used to generate structured JSON responses
+    """
+
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONType
+    json_schema: CreatePromptResponseFormatPromptsResponseJSONSchemaTypedDict
+
+
+class CreatePromptResponseFormatPromptsResponse200JSONSchema(BaseModel):
+    r"""
+
+    JSON Schema response format. Used to generate structured JSON responses
+    """
+
+    type: CreatePromptResponseFormatPromptsResponse200ApplicationJSONType
+
+    json_schema: CreatePromptResponseFormatPromptsResponseJSONSchema
+
+
+CreatePromptResponseFormatPromptsResponse200Type = Literal["json_object",]
+
+
+class CreatePromptResponseFormatPromptsJSONObjectTypedDict(TypedDict):
+    r"""
+
+    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    """
+
+    type: CreatePromptResponseFormatPromptsResponse200Type
+
+
+class CreatePromptResponseFormatPromptsJSONObject(BaseModel):
+    r"""
+
+    JSON object response format. An older method of generating JSON responses. Using `json_schema` is recommended for models that support it. Note that the model will not generate JSON without a system or user message instructing it to do so.
+    """
+
+    type: CreatePromptResponseFormatPromptsResponse200Type
+
+
+CreatePromptResponseFormatPromptsResponseType = Literal["text",]
+
+
+class CreatePromptResponseFormatPromptsTextTypedDict(TypedDict):
+    r"""
+
+    Default response format. Used to generate text responses
+    """
+
+    type: CreatePromptResponseFormatPromptsResponseType
+
+
+class CreatePromptResponseFormatPromptsText(BaseModel):
+    r"""
+
+    Default response format. Used to generate text responses
+    """
+
+    type: CreatePromptResponseFormatPromptsResponseType
+
+
+CreatePromptPromptsResponseFormatTypedDict = TypeAliasType(
+    "CreatePromptPromptsResponseFormatTypedDict",
+    Union[
+        CreatePromptResponseFormatPromptsTextTypedDict,
+        CreatePromptResponseFormatPromptsJSONObjectTypedDict,
+        CreatePromptResponseFormatPromptsResponse200JSONSchemaTypedDict,
+    ],
+)
+r"""An object specifying the format that the model must output"""
+
+
+CreatePromptPromptsResponseFormat = Annotated[
+    Union[
+        Annotated[CreatePromptResponseFormatPromptsText, Tag("text")],
+        Annotated[CreatePromptResponseFormatPromptsJSONObject, Tag("json_object")],
+        Annotated[
+            CreatePromptResponseFormatPromptsResponse200JSONSchema, Tag("json_schema")
+        ],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""An object specifying the format that the model must output"""
+
+
+CreatePromptPromptsReasoningEffort = Literal[
+    "none",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+]
+r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
+
+- `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+- All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+- The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+- `xhigh` is currently only supported for `gpt-5.1-codex-max`.
+
+Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
+"""
+
+
+CreatePromptPromptsStopTypedDict = TypeAliasType(
+    "CreatePromptPromptsStopTypedDict", Union[str, List[str]]
+)
+r"""Up to 4 sequences where the API will stop generating further tokens."""
+
+
+CreatePromptPromptsStop = TypeAliasType(
+    "CreatePromptPromptsStop", Union[str, List[str]]
+)
+r"""Up to 4 sequences where the API will stop generating further tokens."""
+
+
+class CreatePromptPromptsStreamOptionsTypedDict(TypedDict):
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    include_usage: NotRequired[bool]
+    r"""If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value."""
+
+
+class CreatePromptPromptsStreamOptions(BaseModel):
+    r"""Options for streaming response. Only set this when you set stream: true."""
+
+    include_usage: Optional[bool] = None
+    r"""If set, an additional chunk will be streamed before the data: [DONE] message. The usage field on this chunk shows the token usage statistics for the entire request, and the choices field will always be an empty array. All other chunks will also include a usage field, but with a null value."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["include_usage"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+CreatePromptPromptsThinkingTypedDict = TypeAliasType(
+    "CreatePromptPromptsThinkingTypedDict",
+    Union[ThinkingConfigDisabledSchemaTypedDict, ThinkingConfigEnabledSchemaTypedDict],
+)
+
+
+CreatePromptPromptsThinking = Annotated[
+    Union[
+        Annotated[ThinkingConfigDisabledSchema, Tag("disabled")],
+        Annotated[ThinkingConfigEnabledSchema, Tag("enabled")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+CreatePromptToolChoicePromptsType = Literal["function",]
+r"""The type of the tool. Currently, only function is supported."""
+
+
+class CreatePromptToolChoicePromptsFunctionTypedDict(TypedDict):
+    name: str
+    r"""The name of the function to call."""
+
+
+class CreatePromptToolChoicePromptsFunction(BaseModel):
+    name: str
+    r"""The name of the function to call."""
+
+
+class CreatePromptToolChoicePrompts2TypedDict(TypedDict):
+    function: CreatePromptToolChoicePromptsFunctionTypedDict
+    type: NotRequired[CreatePromptToolChoicePromptsType]
+    r"""The type of the tool. Currently, only function is supported."""
+
+
+class CreatePromptToolChoicePrompts2(BaseModel):
+    function: CreatePromptToolChoicePromptsFunction
+
+    type: Optional[CreatePromptToolChoicePromptsType] = None
+    r"""The type of the tool. Currently, only function is supported."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["type"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+CreatePromptToolChoicePrompts1 = Literal[
+    "none",
+    "auto",
+    "required",
+]
+
+
+CreatePromptPromptsToolChoiceTypedDict = TypeAliasType(
+    "CreatePromptPromptsToolChoiceTypedDict",
+    Union[CreatePromptToolChoicePrompts2TypedDict, CreatePromptToolChoicePrompts1],
+)
+r"""Controls which (if any) tool is called by the model."""
+
+
+CreatePromptPromptsToolChoice = TypeAliasType(
+    "CreatePromptPromptsToolChoice",
+    Union[CreatePromptToolChoicePrompts2, CreatePromptToolChoicePrompts1],
+)
+r"""Controls which (if any) tool is called by the model."""
+
+
+CreatePromptPromptsModalities = Literal[
+    "text",
+    "audio",
+]
+
+
+CreatePromptIDPrompts1 = Literal[
+    "orq_pii_detection",
+    "orq_sexual_moderation",
+    "orq_harmful_moderation",
+]
+r"""The key of the guardrail."""
+
+
+CreatePromptPromptsIDTypedDict = TypeAliasType(
+    "CreatePromptPromptsIDTypedDict", Union[CreatePromptIDPrompts1, str]
+)
+
+
+CreatePromptPromptsID = TypeAliasType(
+    "CreatePromptPromptsID", Union[CreatePromptIDPrompts1, str]
+)
+
+
+CreatePromptPromptsExecuteOn = Literal[
+    "input",
+    "output",
+]
+r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class CreatePromptPromptsGuardrailsTypedDict(TypedDict):
+    id: CreatePromptPromptsIDTypedDict
+    execute_on: CreatePromptPromptsExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class CreatePromptPromptsGuardrails(BaseModel):
+    id: CreatePromptPromptsID
+
+    execute_on: CreatePromptPromptsExecuteOn
+    r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
+
+
+class CreatePromptPromptsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptPromptsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptPromptsRetryTypedDict(TypedDict):
+    r"""Retry configuration for the request"""
+
+    count: NotRequired[float]
+    r"""Number of retry attempts (1-5)"""
+    on_codes: NotRequired[List[float]]
+    r"""HTTP status codes that trigger retry logic"""
+
+
+class CreatePromptPromptsRetry(BaseModel):
+    r"""Retry configuration for the request"""
+
+    count: Optional[float] = 3
+    r"""Number of retry attempts (1-5)"""
+
+    on_codes: Optional[List[float]] = None
+    r"""HTTP status codes that trigger retry logic"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["count", "on_codes"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+CreatePromptPromptsResponseType = Literal["exact_match",]
+
+
+class CreatePromptPromptsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptPromptsResponseType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreatePromptPromptsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptPromptsResponseType
+
+    ttl: Optional[float] = 1800
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+CreatePromptLoadBalancerPromptsType = Literal["weight_based",]
+
+
+class CreatePromptLoadBalancerPromptsModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreatePromptLoadBalancerPromptsModels(BaseModel):
+    model: str
+    r"""Model identifier for load balancing"""
+
+    weight: Optional[float] = 0.5
+    r"""Weight assigned to this model for load balancing"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["weight"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptLoadBalancerPrompts1TypedDict(TypedDict):
+    type: CreatePromptLoadBalancerPromptsType
+    models: List[CreatePromptLoadBalancerPromptsModelsTypedDict]
+
+
+class CreatePromptLoadBalancerPrompts1(BaseModel):
+    type: CreatePromptLoadBalancerPromptsType
+
+    models: List[CreatePromptLoadBalancerPromptsModels]
+
+
+CreatePromptPromptsLoadBalancerTypedDict = CreatePromptLoadBalancerPrompts1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreatePromptPromptsLoadBalancer = CreatePromptLoadBalancerPrompts1
+r"""Load balancer configuration for the request."""
+
+
+class CreatePromptPromptsTimeoutTypedDict(TypedDict):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
+
+
+class CreatePromptPromptsTimeout(BaseModel):
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
+    call_timeout: float
+    r"""Timeout value in milliseconds"""
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyRole = Literal["tool",]
+r"""The role of the messages author, in this case tool."""
+
+
+CreatePromptContentPromptsResponse200ApplicationJSONResponseBody2TypedDict = (
+    TextContentPartSchemaTypedDict
+)
+
+
+CreatePromptContentPromptsResponse200ApplicationJSONResponseBody2 = (
+    TextContentPartSchema
+)
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContentTypedDict",
+    Union[
+        str,
+        List[
+            CreatePromptContentPromptsResponse200ApplicationJSONResponseBody2TypedDict
+        ],
+    ],
+)
+r"""The contents of the tool message."""
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContent = (
+    TypeAliasType(
+        "CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContent",
+        Union[
+            str, List[CreatePromptContentPromptsResponse200ApplicationJSONResponseBody2]
+        ],
+    )
+)
+r"""The contents of the tool message."""
+
+
+CreatePromptMessagesPromptsResponse200Type = Literal["ephemeral",]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+
+CreatePromptMessagesPromptsTTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+- `5m`: 5 minutes
+- `1h`: 1 hour
+
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
+
+
+class CreatePromptMessagesPromptsCacheControlTypedDict(TypedDict):
+    type: CreatePromptMessagesPromptsResponse200Type
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[CreatePromptMessagesPromptsTTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+
+class CreatePromptMessagesPromptsCacheControl(BaseModel):
+    type: CreatePromptMessagesPromptsResponse200Type
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+    ttl: Optional[CreatePromptMessagesPromptsTTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptMessagesPromptsToolMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyRole
+    r"""The role of the messages author, in this case tool."""
+    content: CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContentTypedDict
+    r"""The contents of the tool message."""
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
+    cache_control: NotRequired[CreatePromptMessagesPromptsCacheControlTypedDict]
+
+
+class CreatePromptMessagesPromptsToolMessage(BaseModel):
+    role: CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyRole
+    r"""The role of the messages author, in this case tool."""
+
+    content: CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyContent
+    r"""The contents of the tool message."""
+
+    tool_call_id: Nullable[str]
+    r"""Tool call that this message is responding to."""
+
+    cache_control: Optional[CreatePromptMessagesPromptsCacheControl] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["cache_control"])
+        nullable_fields = set(["tool_call_id"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+CreatePromptContentPromptsResponse200ApplicationJSON2TypedDict = TypeAliasType(
+    "CreatePromptContentPromptsResponse200ApplicationJSON2TypedDict",
+    Union[
+        RefusalPartSchemaTypedDict,
+        RedactedReasoningPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ReasoningPartSchemaTypedDict,
+    ],
+)
+
+
+CreatePromptContentPromptsResponse200ApplicationJSON2 = Annotated[
+    Union[
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[RefusalPartSchema, Tag("refusal")],
+        Annotated[ReasoningPartSchema, Tag("reasoning")],
+        Annotated[RedactedReasoningPartSchema, Tag("redacted_reasoning")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsResponse200ApplicationJSONContentTypedDict",
+    Union[str, List[CreatePromptContentPromptsResponse200ApplicationJSON2TypedDict]],
+)
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONContent = TypeAliasType(
+    "CreatePromptMessagesPromptsResponse200ApplicationJSONContent",
+    Union[str, List[CreatePromptContentPromptsResponse200ApplicationJSON2]],
+)
+r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+
+CreatePromptMessagesPromptsResponse200ApplicationJSONRole = Literal["assistant",]
+r"""The role of the messages author, in this case `assistant`."""
+
+
+class CreatePromptMessagesPromptsAudioTypedDict(TypedDict):
+    r"""Data about a previous audio response from the model."""
+
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
+
+
+class CreatePromptMessagesPromptsAudio(BaseModel):
+    r"""Data about a previous audio response from the model."""
+
+    id: str
+    r"""Unique identifier for a previous audio response from the model."""
+
+
+CreatePromptMessagesPromptsResponseType = Literal["function",]
+r"""The type of the tool. Currently, only `function` is supported."""
+
+
+class CreatePromptMessagesPromptsFunctionTypedDict(TypedDict):
+    name: NotRequired[str]
+    r"""The name of the function to call."""
+    arguments: NotRequired[str]
+    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
+
+
+class CreatePromptMessagesPromptsFunction(BaseModel):
+    name: Optional[str] = None
+    r"""The name of the function to call."""
+
+    arguments: Optional[str] = None
+    r"""The arguments to call the function with, as generated by the model in JSON format. Note that the model does not always generate valid JSON, and may hallucinate parameters not defined by your function schema. Validate the arguments in your code before calling your function."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name", "arguments"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptMessagesPromptsToolCallsTypedDict(TypedDict):
+    id: str
+    r"""The ID of the tool call."""
+    type: CreatePromptMessagesPromptsResponseType
+    r"""The type of the tool. Currently, only `function` is supported."""
+    function: CreatePromptMessagesPromptsFunctionTypedDict
+    thought_signature: NotRequired[str]
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+
+
+class CreatePromptMessagesPromptsToolCalls(BaseModel):
+    id: str
+    r"""The ID of the tool call."""
+
+    type: CreatePromptMessagesPromptsResponseType
+    r"""The type of the tool. Currently, only `function` is supported."""
+
+    function: CreatePromptMessagesPromptsFunction
+
+    thought_signature: Optional[str] = None
+    r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models when continuing a conversation after a tool call."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["thought_signature"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePromptMessagesPromptsAssistantMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsResponse200ApplicationJSONRole
+    r"""The role of the messages author, in this case `assistant`."""
+    content: NotRequired[
+        Nullable[CreatePromptMessagesPromptsResponse200ApplicationJSONContentTypedDict]
+    ]
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+    refusal: NotRequired[Nullable[str]]
+    r"""The refusal message by the assistant."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+    audio: NotRequired[Nullable[CreatePromptMessagesPromptsAudioTypedDict]]
+    r"""Data about a previous audio response from the model."""
+    tool_calls: NotRequired[List[CreatePromptMessagesPromptsToolCallsTypedDict]]
+    r"""The tool calls generated by the model, such as function calls."""
+
+
+class CreatePromptMessagesPromptsAssistantMessage(BaseModel):
+    role: CreatePromptMessagesPromptsResponse200ApplicationJSONRole
+    r"""The role of the messages author, in this case `assistant`."""
+
+    content: OptionalNullable[
+        CreatePromptMessagesPromptsResponse200ApplicationJSONContent
+    ] = UNSET
+    r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
+
+    refusal: OptionalNullable[str] = UNSET
+    r"""The refusal message by the assistant."""
+
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
+
+    audio: OptionalNullable[CreatePromptMessagesPromptsAudio] = UNSET
+    r"""Data about a previous audio response from the model."""
+
+    tool_calls: Optional[List[CreatePromptMessagesPromptsToolCalls]] = None
+    r"""The tool calls generated by the model, such as function calls."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["content", "refusal", "name", "audio", "tool_calls"])
+        nullable_fields = set(["content", "refusal", "audio"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+CreatePromptMessagesPromptsResponse200Role = Literal["user",]
+r"""The role of the messages author, in this case `user`."""
+
+
+CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyType = Literal["file",]
+r"""The type of the content part. Always `file`."""
+
+
+CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyPromptType = Literal[
+    "ephemeral",
+]
+r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+
+CreatePrompt2PromptsTTL = Literal[
+    "5m",
+    "1h",
+]
+r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+- `5m`: 5 minutes
+- `1h`: 1 hour
+
+Defaults to `5m`. Only supported by `Anthropic` Claude models.
+"""
+
+
+class CreatePrompt2PromptsCacheControlTypedDict(TypedDict):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyPromptType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+    ttl: NotRequired[CreatePrompt2PromptsTTL]
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+
+class CreatePrompt2PromptsCacheControl(BaseModel):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyPromptType
+    r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
+
+    ttl: Optional[CreatePrompt2PromptsTTL] = "5m"
+    r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
+
+    - `5m`: 5 minutes
+    - `1h`: 1 hour
+
+    Defaults to `5m`. Only supported by `Anthropic` Claude models.
+    """
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["ttl"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+class CreatePrompt2Prompts4TypedDict(TypedDict):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyType
+    r"""The type of the content part. Always `file`."""
+    file: FileContentPartSchemaTypedDict
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
+    cache_control: NotRequired[CreatePrompt2PromptsCacheControlTypedDict]
+
+
+class CreatePrompt2Prompts4(BaseModel):
+    type: CreatePrompt2PromptsResponse200ApplicationJSONResponseBodyType
+    r"""The type of the content part. Always `file`."""
+
+    file: FileContentPartSchema
+    r"""File data for the content part. Must contain either file_data or uri, but not both."""
 
-    thinking_level: Annotated[
-        Optional[CreatePromptPromptsThinkingLevel],
-        pydantic.Field(alias="thinkingLevel"),
-    ] = None
-    r"""The level of thinking to use for the model. Only supported by `Google AI`"""
+    cache_control: Optional[CreatePrompt2PromptsCacheControl] = None
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "temperature",
-            "maxTokens",
-            "topK",
-            "topP",
-            "frequencyPenalty",
-            "presencePenalty",
-            "numImages",
-            "seed",
-            "format",
-            "dimensions",
-            "quality",
-            "style",
-            "responseFormat",
-            "photoRealVersion",
-            "encoding_format",
-            "reasoningEffort",
-            "budgetTokens",
-            "verbosity",
-            "thinkingLevel",
-        ]
-        nullable_fields = ["responseFormat"]
-        null_default_fields = []
-
+        optional_fields = set(["cache_control"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
 
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
         return m
 
 
-CreatePromptProvider = Literal[
-    "openai",
-    "groq",
-    "cohere",
-    "azure",
-    "aws",
-    "google",
-    "google-ai",
-    "huggingface",
-    "togetherai",
-    "perplexity",
-    "anthropic",
-    "leonardoai",
-    "fal",
-    "nvidia",
-    "jina",
-    "elevenlabs",
-    "litellm",
-    "cerebras",
-    "openailike",
-    "bytedance",
-    "mistral",
-    "deepseek",
-    "contextualai",
-    "moonshotai",
-    "zai",
-    "slack",
-]
+CreatePromptContentPromptsResponse2002TypedDict = TypeAliasType(
+    "CreatePromptContentPromptsResponse2002TypedDict",
+    Union[
+        AudioContentPartSchemaTypedDict,
+        TextContentPartSchemaTypedDict,
+        ImageContentPartSchemaTypedDict,
+        CreatePrompt2Prompts4TypedDict,
+    ],
+)
 
 
-CreatePromptPromptsRole = Literal[
-    "system",
-    "assistant",
-    "user",
-    "exception",
-    "tool",
-    "prompt",
-    "correction",
-    "expected_output",
+CreatePromptContentPromptsResponse2002 = Annotated[
+    Union[
+        Annotated[TextContentPartSchema, Tag("text")],
+        Annotated[ImageContentPartSchema, Tag("image_url")],
+        Annotated[AudioContentPartSchema, Tag("input_audio")],
+        Annotated[CreatePrompt2Prompts4, Tag("file")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
 ]
-r"""The role of the prompt message"""
-
-
-CreatePrompt2PromptsResponse200ApplicationJSONType = Literal["file",]
-r"""The type of the content part. Always `file`."""
 
 
-class CreatePrompt2PromptsFileTypedDict(TypedDict):
-    file_data: NotRequired[str]
-    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
-    uri: NotRequired[str]
-    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
-    mime_type: NotRequired[str]
-    r"""MIME type of the file (e.g., application/pdf, image/png)"""
-    filename: NotRequired[str]
-    r"""The name of the file, used when passing the file to the model as a string."""
-
-
-class CreatePrompt2PromptsFile(BaseModel):
-    file_data: Optional[str] = None
-    r"""The file data as a data URI string in the format 'data:<mime-type>;base64,<base64-encoded-data>'. Example: 'data:image/png;base64,iVBORw0KGgoAAAANS...'"""
-
-    uri: Optional[str] = None
-    r"""URL to the file. Only supported by Anthropic Claude models for PDF files."""
-
-    mime_type: Annotated[Optional[str], pydantic.Field(alias="mimeType")] = None
-    r"""MIME type of the file (e.g., application/pdf, image/png)"""
+CreatePromptMessagesPromptsResponse200ContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsResponse200ContentTypedDict",
+    Union[str, List[CreatePromptContentPromptsResponse2002TypedDict]],
+)
+r"""The contents of the user message."""
 
-    filename: Optional[str] = None
-    r"""The name of the file, used when passing the file to the model as a string."""
 
+CreatePromptMessagesPromptsResponse200Content = TypeAliasType(
+    "CreatePromptMessagesPromptsResponse200Content",
+    Union[str, List[CreatePromptContentPromptsResponse2002]],
+)
+r"""The contents of the user message."""
 
-class CreatePrompt23TypedDict(TypedDict):
-    type: CreatePrompt2PromptsResponse200ApplicationJSONType
-    r"""The type of the content part. Always `file`."""
-    file: CreatePrompt2PromptsFileTypedDict
 
+class CreatePromptMessagesPromptsUserMessageTypedDict(TypedDict):
+    role: CreatePromptMessagesPromptsResponse200Role
+    r"""The role of the messages author, in this case `user`."""
+    content: CreatePromptMessagesPromptsResponse200ContentTypedDict
+    r"""The contents of the user message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
-class CreatePrompt23(BaseModel):
-    type: CreatePrompt2PromptsResponse200ApplicationJSONType
-    r"""The type of the content part. Always `file`."""
 
-    file: CreatePrompt2PromptsFile
+class CreatePromptMessagesPromptsUserMessage(BaseModel):
+    role: CreatePromptMessagesPromptsResponse200Role
+    r"""The role of the messages author, in this case `user`."""
 
+    content: CreatePromptMessagesPromptsResponse200Content
+    r"""The contents of the user message."""
 
-CreatePrompt2PromptsResponse200Type = Literal["image_url",]
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
 
-class CreatePrompt2PromptsImageURLTypedDict(TypedDict):
-    url: str
-    r"""Either a URL of the image or the base64 encoded data URI."""
-    id: NotRequired[str]
-    r"""The orq.ai id of the image"""
-    detail: NotRequired[str]
-    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-class CreatePrompt2PromptsImageURL(BaseModel):
-    url: str
-    r"""Either a URL of the image or the base64 encoded data URI."""
+        return m
 
-    id: Optional[str] = None
-    r"""The orq.ai id of the image"""
 
-    detail: Optional[str] = None
-    r"""Specifies the detail level of the image. Currently only supported with OpenAI models"""
+CreatePromptMessagesPromptsResponseRole = Literal["system",]
+r"""The role of the messages author, in this case `system`."""
 
 
-class CreatePrompt2Prompts2TypedDict(TypedDict):
-    r"""The image part of the prompt message. Only supported with vision models."""
+CreatePromptMessagesPromptsResponseContentTypedDict = TypeAliasType(
+    "CreatePromptMessagesPromptsResponseContentTypedDict",
+    Union[str, List[TextContentPartSchemaTypedDict]],
+)
+r"""The contents of the system message."""
 
-    type: CreatePrompt2PromptsResponse200Type
-    image_url: CreatePrompt2PromptsImageURLTypedDict
 
+CreatePromptMessagesPromptsResponseContent = TypeAliasType(
+    "CreatePromptMessagesPromptsResponseContent",
+    Union[str, List[TextContentPartSchema]],
+)
+r"""The contents of the system message."""
 
-class CreatePrompt2Prompts2(BaseModel):
-    r"""The image part of the prompt message. Only supported with vision models."""
 
-    type: CreatePrompt2PromptsResponse200Type
+class CreatePromptMessagesPromptsSystemMessageTypedDict(TypedDict):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
 
-    image_url: CreatePrompt2PromptsImageURL
+    role: CreatePromptMessagesPromptsResponseRole
+    r"""The role of the messages author, in this case `system`."""
+    content: CreatePromptMessagesPromptsResponseContentTypedDict
+    r"""The contents of the system message."""
+    name: NotRequired[str]
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
 
-CreatePrompt2PromptsResponseType = Literal["text",]
+class CreatePromptMessagesPromptsSystemMessage(BaseModel):
+    r"""Developer-provided instructions that the model should follow, regardless of messages sent by the user."""
 
+    role: CreatePromptMessagesPromptsResponseRole
+    r"""The role of the messages author, in this case `system`."""
 
-class CreatePrompt2Prompts1TypedDict(TypedDict):
-    r"""Text content part of a prompt message"""
+    content: CreatePromptMessagesPromptsResponseContent
+    r"""The contents of the system message."""
 
-    type: CreatePrompt2PromptsResponseType
-    text: str
+    name: Optional[str] = None
+    r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
 
-class CreatePrompt2Prompts1(BaseModel):
-    r"""Text content part of a prompt message"""
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-    type: CreatePrompt2PromptsResponseType
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
 
-    text: str
+        return m
 
 
-CreatePromptContentPromptsResponse2TypedDict = TypeAliasType(
-    "CreatePromptContentPromptsResponse2TypedDict",
+CreatePromptPromptsResponseMessagesTypedDict = TypeAliasType(
+    "CreatePromptPromptsResponseMessagesTypedDict",
     Union[
-        CreatePrompt2Prompts1TypedDict,
-        CreatePrompt2Prompts2TypedDict,
-        CreatePrompt23TypedDict,
+        CreatePromptMessagesPromptsSystemMessageTypedDict,
+        CreatePromptMessagesPromptsUserMessageTypedDict,
+        CreatePromptMessagesPromptsToolMessageTypedDict,
+        CreatePromptMessagesPromptsAssistantMessageTypedDict,
     ],
 )
 
 
-CreatePromptContentPromptsResponse2 = Annotated[
+CreatePromptPromptsResponseMessages = Annotated[
     Union[
-        Annotated[CreatePrompt2Prompts1, Tag("text")],
-        Annotated[CreatePrompt2Prompts2, Tag("image_url")],
-        Annotated[CreatePrompt23, Tag("file")],
+        Annotated[CreatePromptMessagesPromptsSystemMessage, Tag("system")],
+        Annotated[CreatePromptMessagesPromptsUserMessage, Tag("user")],
+        Annotated[CreatePromptMessagesPromptsAssistantMessage, Tag("assistant")],
+        Annotated[CreatePromptMessagesPromptsToolMessage, Tag("tool")],
     ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+    Discriminator(lambda m: get_discriminator(m, "role", "role")),
 ]
 
 
-CreatePromptPromptsContentTypedDict = TypeAliasType(
-    "CreatePromptPromptsContentTypedDict",
-    Union[str, List[CreatePromptContentPromptsResponse2TypedDict]],
-)
-r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
-
-
-CreatePromptPromptsContent = TypeAliasType(
-    "CreatePromptPromptsContent", Union[str, List[CreatePromptContentPromptsResponse2]]
-)
-r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
-
-
-CreatePromptPromptsResponseType = Literal["function",]
+class PromptFieldTypedDict(TypedDict):
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+    audio: NotRequired[Nullable[CreatePromptPromptsAudioTypedDict]]
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
+    frequency_penalty: NotRequired[Nullable[float]]
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim."""
+    max_tokens: NotRequired[Nullable[int]]
+    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
 
-class CreatePromptPromptsFunctionTypedDict(TypedDict):
-    name: str
-    arguments: str
-    r"""JSON string arguments for the functions"""
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+    """
+    max_completion_tokens: NotRequired[Nullable[int]]
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
+    logprobs: NotRequired[Nullable[bool]]
+    r"""Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message."""
+    top_logprobs: NotRequired[Nullable[int]]
+    r"""An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used."""
+    n: NotRequired[Nullable[int]]
+    r"""How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs."""
+    presence_penalty: NotRequired[Nullable[float]]
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics."""
+    response_format: NotRequired[CreatePromptPromptsResponseFormatTypedDict]
+    r"""An object specifying the format that the model must output"""
+    reasoning_effort: NotRequired[CreatePromptPromptsReasoningEffort]
+    r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 
-class CreatePromptPromptsFunction(BaseModel):
-    name: str
+    Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
+    """
+    verbosity: NotRequired[str]
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
+    seed: NotRequired[Nullable[float]]
+    r"""If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result."""
+    stop: NotRequired[Nullable[CreatePromptPromptsStopTypedDict]]
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
+    stream_options: NotRequired[Nullable[CreatePromptPromptsStreamOptionsTypedDict]]
+    r"""Options for streaming response. Only set this when you set stream: true."""
+    thinking: NotRequired[CreatePromptPromptsThinkingTypedDict]
+    temperature: NotRequired[Nullable[float]]
+    r"""What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."""
+    top_p: NotRequired[Nullable[float]]
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
+    top_k: NotRequired[Nullable[float]]
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
+    tool_choice: NotRequired[CreatePromptPromptsToolChoiceTypedDict]
+    r"""Controls which (if any) tool is called by the model."""
+    parallel_tool_calls: NotRequired[bool]
+    r"""Whether to enable parallel function calling during tool use."""
+    modalities: NotRequired[Nullable[List[CreatePromptPromptsModalities]]]
+    r"""Output types that you would like the model to generate. Most models are capable of generating text, which is the default: [\"text\"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: [\"text\", \"audio\"]."""
+    guardrails: NotRequired[List[CreatePromptPromptsGuardrailsTypedDict]]
+    r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[CreatePromptPromptsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreatePromptPromptsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreatePromptPromptsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreatePromptPromptsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreatePromptPromptsTimeoutTypedDict]
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+    messages: NotRequired[List[CreatePromptPromptsResponseMessagesTypedDict]]
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
+    model: NotRequired[Nullable[str]]
+    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`."""
+    version: NotRequired[str]
 
-    arguments: str
-    r"""JSON string arguments for the functions"""
 
+class PromptField(BaseModel):
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
 
-class CreatePromptPromptsToolCallsTypedDict(TypedDict):
-    type: CreatePromptPromptsResponseType
-    function: CreatePromptPromptsFunctionTypedDict
-    id: NotRequired[str]
-    index: NotRequired[float]
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
 
+    audio: OptionalNullable[CreatePromptPromptsAudio] = UNSET
+    r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
-class CreatePromptPromptsToolCalls(BaseModel):
-    type: CreatePromptPromptsResponseType
+    frequency_penalty: OptionalNullable[float] = UNSET
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on their existing frequency in the text so far, decreasing the model's likelihood to repeat the same line verbatim."""
 
-    function: CreatePromptPromptsFunction
+    max_tokens: OptionalNullable[int] = UNSET
+    r"""`[Deprecated]`. The maximum number of tokens that can be generated in the chat completion. This value can be used to control costs for text generated via API.
 
-    id: Optional[str] = None
+    This value is now `deprecated` in favor of `max_completion_tokens`, and is not compatible with o1 series models.
+    """
 
-    index: Optional[float] = None
+    max_completion_tokens: OptionalNullable[int] = UNSET
+    r"""An upper bound for the number of tokens that can be generated for a completion, including visible output tokens and reasoning tokens"""
 
+    logprobs: OptionalNullable[bool] = UNSET
+    r"""Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the content of message."""
 
-class CreatePromptPromptsResponseMessagesTypedDict(TypedDict):
-    role: CreatePromptPromptsRole
-    r"""The role of the prompt message"""
-    content: Nullable[CreatePromptPromptsContentTypedDict]
-    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
-    tool_calls: NotRequired[List[CreatePromptPromptsToolCallsTypedDict]]
-    tool_call_id: NotRequired[Nullable[str]]
+    top_logprobs: OptionalNullable[int] = UNSET
+    r"""An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. logprobs must be set to true if this parameter is used."""
 
+    n: OptionalNullable[int] = UNSET
+    r"""How many chat completion choices to generate for each input message. Note that you will be charged based on the number of generated tokens across all of the choices. Keep n as 1 to minimize costs."""
 
-class CreatePromptPromptsResponseMessages(BaseModel):
-    role: CreatePromptPromptsRole
-    r"""The role of the prompt message"""
+    presence_penalty: OptionalNullable[float] = UNSET
+    r"""Number between -2.0 and 2.0. Positive values penalize new tokens based on whether they appear in the text so far, increasing the model's likelihood to talk about new topics."""
 
-    content: Nullable[CreatePromptPromptsContent]
-    r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
+    response_format: Optional[CreatePromptPromptsResponseFormat] = None
+    r"""An object specifying the format that the model must output"""
 
-    tool_calls: Optional[List[CreatePromptPromptsToolCalls]] = None
+    reasoning_effort: Optional[CreatePromptPromptsReasoningEffort] = None
+    r"""Constrains effort on reasoning for [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`. Reducing reasoning effort can result in faster responses and fewer tokens used on reasoning in a response.
 
-    tool_call_id: OptionalNullable[str] = UNSET
+    - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool calls are supported for all reasoning values in gpt-5.1.
+    - All models before `gpt-5.1` default to `medium` reasoning effort, and do not support `none`.
+    - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
+    - `xhigh` is currently only supported for `gpt-5.1-codex-max`.
 
-    @model_serializer(mode="wrap")
-    def serialize_model(self, handler):
-        optional_fields = ["tool_calls", "tool_call_id"]
-        nullable_fields = ["content", "tool_call_id"]
-        null_default_fields = []
+    Any of \"none\", \"minimal\", \"low\", \"medium\", \"high\", \"xhigh\".
+    """
 
-        serialized = handler(self)
+    verbosity: Optional[str] = None
+    r"""Adjusts response verbosity. Lower levels yield shorter answers."""
 
-        m = {}
+    seed: OptionalNullable[float] = UNSET
+    r"""If specified, our system will make a best effort to sample deterministically, such that repeated requests with the same seed and parameters should return the same result."""
 
-        for n, f in type(self).model_fields.items():
-            k = f.alias or n
-            val = serialized.get(k)
-            serialized.pop(k, None)
+    stop: OptionalNullable[CreatePromptPromptsStop] = UNSET
+    r"""Up to 4 sequences where the API will stop generating further tokens."""
 
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
+    stream_options: OptionalNullable[CreatePromptPromptsStreamOptions] = UNSET
+    r"""Options for streaming response. Only set this when you set stream: true."""
 
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+    thinking: Optional[CreatePromptPromptsThinking] = None
 
-        return m
+    temperature: OptionalNullable[float] = UNSET
+    r"""What sampling temperature to use, between 0 and 2. Higher values like 0.8 will make the output more random, while lower values like 0.2 will make it more focused and deterministic."""
 
+    top_p: OptionalNullable[float] = UNSET
+    r"""An alternative to sampling with temperature, called nucleus sampling, where the model considers the results of the tokens with top_p probability mass."""
 
-class CreatePromptPromptConfigTypedDict(TypedDict):
-    r"""A list of messages compatible with the openAI schema"""
+    top_k: OptionalNullable[float] = UNSET
+    r"""Limits the model to consider only the top k most likely tokens at each step."""
 
-    messages: List[CreatePromptPromptsResponseMessagesTypedDict]
-    stream: NotRequired[bool]
-    model: NotRequired[str]
-    model_db_id: NotRequired[Nullable[str]]
-    r"""The id of the resource"""
-    model_type: NotRequired[Nullable[CreatePromptModelType]]
-    r"""The modality of the model"""
-    model_parameters: NotRequired[CreatePromptModelParametersTypedDict]
-    r"""Model Parameters: Not all parameters apply to every model"""
-    provider: NotRequired[CreatePromptProvider]
-    integration_id: NotRequired[Nullable[str]]
-    r"""The ID of the integration to use"""
-    version: NotRequired[str]
+    tool_choice: Optional[CreatePromptPromptsToolChoice] = None
+    r"""Controls which (if any) tool is called by the model."""
 
+    parallel_tool_calls: Optional[bool] = None
+    r"""Whether to enable parallel function calling during tool use."""
 
-class CreatePromptPromptConfig(BaseModel):
-    r"""A list of messages compatible with the openAI schema"""
+    modalities: OptionalNullable[List[CreatePromptPromptsModalities]] = UNSET
+    r"""Output types that you would like the model to generate. Most models are capable of generating text, which is the default: [\"text\"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: [\"text\", \"audio\"]."""
 
-    messages: List[CreatePromptPromptsResponseMessages]
+    guardrails: Optional[List[CreatePromptPromptsGuardrails]] = None
+    r"""A list of guardrails to apply to the request."""
 
-    stream: Optional[bool] = None
+    fallbacks: Optional[List[CreatePromptPromptsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
 
-    model: Optional[str] = None
+    retry: Optional[CreatePromptPromptsRetry] = None
+    r"""Retry configuration for the request"""
 
-    model_db_id: OptionalNullable[str] = UNSET
-    r"""The id of the resource"""
+    cache: Optional[CreatePromptPromptsCache] = None
+    r"""Cache configuration for the request."""
 
-    model_type: OptionalNullable[CreatePromptModelType] = UNSET
-    r"""The modality of the model"""
+    load_balancer: Optional[CreatePromptPromptsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
 
-    model_parameters: Optional[CreatePromptModelParameters] = None
-    r"""Model Parameters: Not all parameters apply to every model"""
+    timeout: Optional[CreatePromptPromptsTimeout] = None
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
 
-    provider: Optional[CreatePromptProvider] = None
+    messages: Optional[List[CreatePromptPromptsResponseMessages]] = None
+    r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
 
-    integration_id: OptionalNullable[str] = UNSET
-    r"""The ID of the integration to use"""
+    model: OptionalNullable[str] = UNSET
+    r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`."""
 
     version: Optional[str] = None
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "stream",
-            "model",
-            "model_db_id",
-            "model_type",
-            "model_parameters",
-            "provider",
-            "integration_id",
-            "version",
-        ]
-        nullable_fields = ["model_db_id", "model_type", "integration_id"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "name",
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "response_format",
+                "reasoning_effort",
+                "verbosity",
+                "seed",
+                "stop",
+                "stream_options",
+                "thinking",
+                "temperature",
+                "top_p",
+                "top_k",
+                "tool_choice",
+                "parallel_tool_calls",
+                "modalities",
+                "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
+                "messages",
+                "model",
+                "version",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "audio",
+                "frequency_penalty",
+                "max_tokens",
+                "max_completion_tokens",
+                "logprobs",
+                "top_logprobs",
+                "n",
+                "presence_penalty",
+                "seed",
+                "stop",
+                "stream_options",
+                "temperature",
+                "top_p",
+                "top_k",
+                "modalities",
+                "model",
+            ]
+        )
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
@@ -2220,31 +3720,26 @@ class CreatePromptPromptsMetadata(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["use_cases", "language"]
-        nullable_fields = ["language"]
-        null_default_fields = []
-
+        optional_fields = set(["use_cases", "language"])
+        nullable_fields = set(["language"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m
 
@@ -2260,12 +3755,14 @@ class CreatePromptPromptTypedDict(TypedDict):
     updated: str
     display_name: str
     r"""The prompt’s name, meant to be displayable in the UI."""
-    prompt_config: CreatePromptPromptConfigTypedDict
-    r"""A list of messages compatible with the openAI schema"""
+    prompt: PromptFieldTypedDict
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
     created_by_id: NotRequired[Nullable[str]]
     updated_by_id: NotRequired[Nullable[str]]
     description: NotRequired[Nullable[str]]
     r"""The prompt’s description, meant to be displayable in the UI. Use this field to optionally store a long form explanation of the prompt for your own purpose"""
+    prompt_config: NotRequired[PromptConfigTypedDict]
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
     metadata: NotRequired[CreatePromptPromptsMetadataTypedDict]
 
 
@@ -2287,8 +3784,8 @@ class CreatePromptPrompt(BaseModel):
     display_name: str
     r"""The prompt’s name, meant to be displayable in the UI."""
 
-    prompt_config: CreatePromptPromptConfig
-    r"""A list of messages compatible with the openAI schema"""
+    prompt: PromptField
+    r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
 
     created_by_id: OptionalNullable[str] = UNSET
 
@@ -2297,34 +3794,45 @@ class CreatePromptPrompt(BaseModel):
     description: OptionalNullable[str] = UNSET
     r"""The prompt’s description, meant to be displayable in the UI. Use this field to optionally store a long form explanation of the prompt for your own purpose"""
 
+    prompt_config: Annotated[
+        Optional[PromptConfig],
+        pydantic.Field(
+            deprecated="warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+        ),
+    ] = None
+    r"""[DEPRECATED] Use the `prompt` property instead. A list of messages compatible with the openAI schema."""
+
     metadata: Optional[CreatePromptPromptsMetadata] = None
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["created_by_id", "updated_by_id", "description", "metadata"]
-        nullable_fields = ["created_by_id", "updated_by_id", "description"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "created_by_id",
+                "updated_by_id",
+                "description",
+                "prompt_config",
+                "metadata",
+            ]
+        )
+        nullable_fields = set(["created_by_id", "updated_by_id", "description"])
         serialized = handler(self)
-
         m = {}
 
         for n, f in type(self).model_fields.items():
             k = f.alias or n
             val = serialized.get(k)
-            serialized.pop(k, None)
-
-            optional_nullable = k in optional_fields and k in nullable_fields
-            is_set = (
-                self.__pydantic_fields_set__.intersection({n})
-                or k in null_default_fields
-            )  # pylint: disable=no-member
-
-            if val is not None and val != UNSET_SENTINEL:
-                m[k] = val
-            elif val != UNSET_SENTINEL and (
-                not k in optional_fields or (optional_nullable and is_set)
-            ):
-                m[k] = val
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
 
         return m