orq-ai-sdk 4.2.0rc28__py3-none-any.whl → 4.2.6__py3-none-any.whl

orq_ai_sdk/models/createchatcompletionop.py

@@ -11,6 +11,7 @@ from .imagecontentpartschema import (
     ImageContentPartSchemaTypedDict,
 )
 from .publiccontact import PublicContact, PublicContactTypedDict
+from .publicidentity import PublicIdentity, PublicIdentityTypedDict
 from .reasoningpartschema import ReasoningPartSchema, ReasoningPartSchemaTypedDict
 from .redactedreasoningpartschema import (
     RedactedReasoningPartSchema,
@@ -46,31 +47,37 @@ from typing_extensions import (
 )
 
 
-CreateChatCompletionMessagesRouterRequestRequestBody5Role = Literal["tool",]
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Role = Literal[
+    "tool",
+]
 r"""The role of the messages author, in this case tool."""
 
 
-CreateChatCompletionContentRouterRequest2TypedDict = TextContentPartSchemaTypedDict
+CreateChatCompletionContentRouterChatCompletionsRequest2TypedDict = (
+    TextContentPartSchemaTypedDict
+)
 
 
-CreateChatCompletionContentRouterRequest2 = TextContentPartSchema
+CreateChatCompletionContentRouterChatCompletionsRequest2 = TextContentPartSchema
 
 
-CreateChatCompletionMessagesRouterRequestRequestBody5ContentTypedDict = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestRequestBody5ContentTypedDict",
-    Union[str, List[CreateChatCompletionContentRouterRequest2TypedDict]],
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5ContentTypedDict = TypeAliasType(
+    "CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5ContentTypedDict",
+    Union[str, List[CreateChatCompletionContentRouterChatCompletionsRequest2TypedDict]],
 )
 r"""The contents of the tool message."""
 
 
-CreateChatCompletionMessagesRouterRequestRequestBody5Content = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestRequestBody5Content",
-    Union[str, List[CreateChatCompletionContentRouterRequest2]],
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Content = (
+    TypeAliasType(
+        "CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Content",
+        Union[str, List[CreateChatCompletionContentRouterChatCompletionsRequest2]],
+    )
 )
 r"""The contents of the tool message."""
 
 
-CreateChatCompletionMessagesRouterType = Literal["ephemeral",]
+CreateChatCompletionMessagesRouterChatCompletionsType = Literal["ephemeral",]
 r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
 
@@ -88,7 +95,7 @@ Defaults to `5m`. Only supported by `Anthropic` Claude models.
 
 
 class CreateChatCompletionMessagesCacheControlTypedDict(TypedDict):
-    type: CreateChatCompletionMessagesRouterType
+    type: CreateChatCompletionMessagesRouterChatCompletionsType
     r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
     ttl: NotRequired[CreateChatCompletionMessagesTTL]
     r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
@@ -101,7 +108,7 @@ class CreateChatCompletionMessagesCacheControlTypedDict(TypedDict):
 
 
 class CreateChatCompletionMessagesCacheControl(BaseModel):
-    type: CreateChatCompletionMessagesRouterType
+    type: CreateChatCompletionMessagesRouterChatCompletionsType
     r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
     ttl: Optional[CreateChatCompletionMessagesTTL] = "5m"
@@ -113,11 +120,27 @@ class CreateChatCompletionMessagesCacheControl(BaseModel):
     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 CreateChatCompletionMessagesToolMessageTypedDict(TypedDict):
-    role: CreateChatCompletionMessagesRouterRequestRequestBody5Role
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Role
     r"""The role of the messages author, in this case tool."""
-    content: CreateChatCompletionMessagesRouterRequestRequestBody5ContentTypedDict
+    content: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5ContentTypedDict
     r"""The contents of the tool message."""
     tool_call_id: Nullable[str]
     r"""Tool call that this message is responding to."""
@@ -125,10 +148,10 @@ class CreateChatCompletionMessagesToolMessageTypedDict(TypedDict):
 
 
 class CreateChatCompletionMessagesToolMessage(BaseModel):
-    role: CreateChatCompletionMessagesRouterRequestRequestBody5Role
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Role
     r"""The role of the messages author, in this case tool."""
 
-    content: CreateChatCompletionMessagesRouterRequestRequestBody5Content
+    content: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBody5Content
     r"""The contents of the tool message."""
 
     tool_call_id: Nullable[str]
@@ -138,37 +161,32 @@ class CreateChatCompletionMessagesToolMessage(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["cache_control"]
-        nullable_fields = ["tool_call_id"]
-        null_default_fields = []
-
+        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)
-            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
 
 
-CreateChatCompletionContentRouter2TypedDict = TypeAliasType(
-    "CreateChatCompletionContentRouter2TypedDict",
+CreateChatCompletionContentRouterChatCompletions2TypedDict = TypeAliasType(
+    "CreateChatCompletionContentRouterChatCompletions2TypedDict",
     Union[
         RefusalPartSchemaTypedDict,
         RedactedReasoningPartSchemaTypedDict,
@@ -178,7 +196,7 @@ CreateChatCompletionContentRouter2TypedDict = TypeAliasType(
 )
 
 
-CreateChatCompletionContentRouter2 = Annotated[
+CreateChatCompletionContentRouterChatCompletions2 = Annotated[
     Union[
         Annotated[TextContentPartSchema, Tag("text")],
         Annotated[RefusalPartSchema, Tag("refusal")],
@@ -189,21 +207,25 @@ CreateChatCompletionContentRouter2 = Annotated[
 ]
 
 
-CreateChatCompletionMessagesRouterRequestRequestBodyContentTypedDict = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestRequestBodyContentTypedDict",
-    Union[str, List[CreateChatCompletionContentRouter2TypedDict]],
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContentTypedDict = TypeAliasType(
+    "CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContentTypedDict",
+    Union[str, List[CreateChatCompletionContentRouterChatCompletions2TypedDict]],
 )
 r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
 
-CreateChatCompletionMessagesRouterRequestRequestBodyContent = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestRequestBodyContent",
-    Union[str, List[CreateChatCompletionContentRouter2]],
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContent = (
+    TypeAliasType(
+        "CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContent",
+        Union[str, List[CreateChatCompletionContentRouterChatCompletions2]],
+    )
 )
 r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
 
-CreateChatCompletionMessagesRouterRequestRequestBodyRole = Literal["assistant",]
+CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyRole = Literal[
+    "assistant",
+]
 r"""The role of the messages author, in this case `assistant`."""
 
 
@@ -239,6 +261,22 @@ class CreateChatCompletionMessagesFunction(BaseModel):
     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 CreateChatCompletionMessagesToolCallsTypedDict(TypedDict):
     id: str
@@ -262,12 +300,30 @@ class CreateChatCompletionMessagesToolCalls(BaseModel):
     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 CreateChatCompletionMessagesAssistantMessageTypedDict(TypedDict):
-    role: CreateChatCompletionMessagesRouterRequestRequestBodyRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyRole
     r"""The role of the messages author, in this case `assistant`."""
     content: NotRequired[
-        Nullable[CreateChatCompletionMessagesRouterRequestRequestBodyContentTypedDict]
+        Nullable[
+            CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContentTypedDict
+        ]
     ]
     r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
     refusal: NotRequired[Nullable[str]]
@@ -281,11 +337,11 @@ class CreateChatCompletionMessagesAssistantMessageTypedDict(TypedDict):
 
 
 class CreateChatCompletionMessagesAssistantMessage(BaseModel):
-    role: CreateChatCompletionMessagesRouterRequestRequestBodyRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyRole
     r"""The role of the messages author, in this case `assistant`."""
 
     content: OptionalNullable[
-        CreateChatCompletionMessagesRouterRequestRequestBodyContent
+        CreateChatCompletionMessagesRouterChatCompletionsRequestRequestBodyContent
     ] = UNSET
     r"""The contents of the assistant message. Required unless `tool_calls` or `function_call` is specified."""
 
@@ -303,36 +359,31 @@ class CreateChatCompletionMessagesAssistantMessage(BaseModel):
 
     @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(["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)
-            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
 
 
-CreateChatCompletionMessagesRouterRequestRole = Literal["user",]
+CreateChatCompletionMessagesRouterChatCompletionsRequestRole = Literal["user",]
 r"""The role of the messages author, in this case `user`."""
 
 
@@ -340,7 +391,7 @@ CreateChatCompletion2Type = Literal["file",]
 r"""The type of the content part. Always `file`."""
 
 
-CreateChatCompletion2RouterType = Literal["ephemeral",]
+CreateChatCompletion2RouterChatCompletionsType = Literal["ephemeral",]
 r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
 
@@ -358,7 +409,7 @@ Defaults to `5m`. Only supported by `Anthropic` Claude models.
 
 
 class CreateChatCompletion2CacheControlTypedDict(TypedDict):
-    type: CreateChatCompletion2RouterType
+    type: CreateChatCompletion2RouterChatCompletionsType
     r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
     ttl: NotRequired[CreateChatCompletion2TTL]
     r"""The time-to-live for the cache control breakpoint. This may be one of the following values:
@@ -371,7 +422,7 @@ class CreateChatCompletion2CacheControlTypedDict(TypedDict):
 
 
 class CreateChatCompletion2CacheControl(BaseModel):
-    type: CreateChatCompletion2RouterType
+    type: CreateChatCompletion2RouterChatCompletionsType
     r"""Create a cache control breakpoint at this content block. Accepts only the value \"ephemeral\"."""
 
     ttl: Optional[CreateChatCompletion2TTL] = "5m"
@@ -383,6 +434,22 @@ class CreateChatCompletion2CacheControl(BaseModel):
     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 CreateChatCompletion24TypedDict(TypedDict):
     type: CreateChatCompletion2Type
@@ -401,6 +468,22 @@ class CreateChatCompletion24(BaseModel):
 
     cache_control: Optional[CreateChatCompletion2CacheControl] = 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
+
 
 CreateChatCompletionContent2TypedDict = TypeAliasType(
     "CreateChatCompletionContent2TypedDict",
@@ -424,76 +507,111 @@ CreateChatCompletionContent2 = Annotated[
 ]
 
 
-CreateChatCompletionMessagesRouterRequestContentTypedDict = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestContentTypedDict",
-    Union[str, List[CreateChatCompletionContent2TypedDict]],
+CreateChatCompletionMessagesRouterChatCompletionsRequestContentTypedDict = (
+    TypeAliasType(
+        "CreateChatCompletionMessagesRouterChatCompletionsRequestContentTypedDict",
+        Union[str, List[CreateChatCompletionContent2TypedDict]],
+    )
 )
 r"""The contents of the user message."""
 
 
-CreateChatCompletionMessagesRouterRequestContent = TypeAliasType(
-    "CreateChatCompletionMessagesRouterRequestContent",
+CreateChatCompletionMessagesRouterChatCompletionsRequestContent = TypeAliasType(
+    "CreateChatCompletionMessagesRouterChatCompletionsRequestContent",
     Union[str, List[CreateChatCompletionContent2]],
 )
 r"""The contents of the user message."""
 
 
 class CreateChatCompletionMessagesUserMessageTypedDict(TypedDict):
-    role: CreateChatCompletionMessagesRouterRequestRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRole
     r"""The role of the messages author, in this case `user`."""
-    content: CreateChatCompletionMessagesRouterRequestContentTypedDict
+    content: CreateChatCompletionMessagesRouterChatCompletionsRequestContentTypedDict
     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 CreateChatCompletionMessagesUserMessage(BaseModel):
-    role: CreateChatCompletionMessagesRouterRequestRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRequestRole
     r"""The role of the messages author, in this case `user`."""
 
-    content: CreateChatCompletionMessagesRouterRequestContent
+    content: CreateChatCompletionMessagesRouterChatCompletionsRequestContent
     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."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name"])
+        serialized = handler(self)
+        m = {}
 
-CreateChatCompletionMessagesRouterRole = Literal["developer",]
+        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
+
+
+CreateChatCompletionMessagesRouterChatCompletionsRole = Literal["developer",]
 r"""The role of the messages author, in this case  `developer`."""
 
 
-CreateChatCompletionMessagesRouterContentTypedDict = TypeAliasType(
-    "CreateChatCompletionMessagesRouterContentTypedDict",
+CreateChatCompletionMessagesRouterChatCompletionsContentTypedDict = TypeAliasType(
+    "CreateChatCompletionMessagesRouterChatCompletionsContentTypedDict",
     Union[str, List[TextContentPartSchemaTypedDict]],
 )
 r"""The contents of the developer message."""
 
 
-CreateChatCompletionMessagesRouterContent = TypeAliasType(
-    "CreateChatCompletionMessagesRouterContent", Union[str, List[TextContentPartSchema]]
+CreateChatCompletionMessagesRouterChatCompletionsContent = TypeAliasType(
+    "CreateChatCompletionMessagesRouterChatCompletionsContent",
+    Union[str, List[TextContentPartSchema]],
 )
 r"""The contents of the developer message."""
 
 
 class CreateChatCompletionMessagesDeveloperMessageTypedDict(TypedDict):
-    role: CreateChatCompletionMessagesRouterRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRole
     r"""The role of the messages author, in this case  `developer`."""
-    content: CreateChatCompletionMessagesRouterContentTypedDict
+    content: CreateChatCompletionMessagesRouterChatCompletionsContentTypedDict
     r"""The contents of the developer message."""
     name: NotRequired[str]
     r"""An optional name for the participant. Provides the model information to differentiate between participants of the same role."""
 
 
 class CreateChatCompletionMessagesDeveloperMessage(BaseModel):
-    role: CreateChatCompletionMessagesRouterRole
+    role: CreateChatCompletionMessagesRouterChatCompletionsRole
     r"""The role of the messages author, in this case  `developer`."""
 
-    content: CreateChatCompletionMessagesRouterContent
+    content: CreateChatCompletionMessagesRouterChatCompletionsContent
     r"""The contents of the developer message."""
 
     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 = {}
+
+        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
+
 
 CreateChatCompletionMessagesRole = Literal["system",]
 r"""The role of the messages author, in this case `system`."""
@@ -535,6 +653,22 @@ class CreateChatCompletionMessagesSystemMessage(BaseModel):
     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 = {}
+
+        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
+
 
 CreateChatCompletionMessagesTypedDict = TypeAliasType(
     "CreateChatCompletionMessagesTypedDict",
@@ -600,10 +734,14 @@ class CreateChatCompletionAudio(BaseModel):
     r"""Specifies the output audio format. Must be one of wav, mp3, flac, opus, or pcm16."""
 
 
-CreateChatCompletionResponseFormatRouterRequestType = Literal["json_schema",]
+CreateChatCompletionResponseFormatRouterChatCompletionsRequestType = Literal[
+    "json_schema",
+]
 
 
-class CreateChatCompletionResponseFormatRouterJSONSchemaTypedDict(TypedDict):
+class CreateChatCompletionResponseFormatRouterChatCompletionsJSONSchemaTypedDict(
+    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]
@@ -614,7 +752,7 @@ class CreateChatCompletionResponseFormatRouterJSONSchemaTypedDict(TypedDict):
     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 CreateChatCompletionResponseFormatRouterJSONSchema(BaseModel):
+class CreateChatCompletionResponseFormatRouterChatCompletionsJSONSchema(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."""
 
@@ -627,6 +765,22 @@ class CreateChatCompletionResponseFormatRouterJSONSchema(BaseModel):
     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 CreateChatCompletionResponseFormatJSONSchemaTypedDict(TypedDict):
     r"""
@@ -634,8 +788,10 @@ class CreateChatCompletionResponseFormatJSONSchemaTypedDict(TypedDict):
     JSON Schema response format. Used to generate structured JSON responses
     """
 
-    type: CreateChatCompletionResponseFormatRouterRequestType
-    json_schema: CreateChatCompletionResponseFormatRouterJSONSchemaTypedDict
+    type: CreateChatCompletionResponseFormatRouterChatCompletionsRequestType
+    json_schema: (
+        CreateChatCompletionResponseFormatRouterChatCompletionsJSONSchemaTypedDict
+    )
 
 
 class CreateChatCompletionResponseFormatJSONSchema(BaseModel):
@@ -644,12 +800,12 @@ class CreateChatCompletionResponseFormatJSONSchema(BaseModel):
     JSON Schema response format. Used to generate structured JSON responses
     """
 
-    type: CreateChatCompletionResponseFormatRouterRequestType
+    type: CreateChatCompletionResponseFormatRouterChatCompletionsRequestType
 
-    json_schema: CreateChatCompletionResponseFormatRouterJSONSchema
+    json_schema: CreateChatCompletionResponseFormatRouterChatCompletionsJSONSchema
 
 
-CreateChatCompletionResponseFormatRouterType = Literal["json_object",]
+CreateChatCompletionResponseFormatRouterChatCompletionsType = Literal["json_object",]
 
 
 class CreateChatCompletionResponseFormatJSONObjectTypedDict(TypedDict):
@@ -658,7 +814,7 @@ class CreateChatCompletionResponseFormatJSONObjectTypedDict(TypedDict):
     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: CreateChatCompletionResponseFormatRouterType
+    type: CreateChatCompletionResponseFormatRouterChatCompletionsType
 
 
 class CreateChatCompletionResponseFormatJSONObject(BaseModel):
@@ -667,7 +823,7 @@ class CreateChatCompletionResponseFormatJSONObject(BaseModel):
     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: CreateChatCompletionResponseFormatRouterType
+    type: CreateChatCompletionResponseFormatRouterChatCompletionsType
 
 
 CreateChatCompletionResponseFormatType = Literal["text",]
@@ -757,6 +913,22 @@ class CreateChatCompletionStreamOptions(BaseModel):
     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
+
 
 CreateChatCompletionThinkingTypedDict = TypeAliasType(
     "CreateChatCompletionThinkingTypedDict",
@@ -777,13 +949,13 @@ CreateChatCompletionType = Literal["function",]
 r"""The type of the tool. Currently, only function is supported."""
 
 
-CreateChatCompletionRouterType = Literal["object",]
+CreateChatCompletionRouterChatCompletionsType = Literal["object",]
 
 
 class CreateChatCompletionParametersTypedDict(TypedDict):
     r"""The parameters the functions accepts, described as a JSON Schema object"""
 
-    type: CreateChatCompletionRouterType
+    type: CreateChatCompletionRouterChatCompletionsType
     properties: Dict[str, Any]
     required: NotRequired[List[str]]
     additional_properties: NotRequired[bool]
@@ -792,7 +964,7 @@ class CreateChatCompletionParametersTypedDict(TypedDict):
 class CreateChatCompletionParameters(BaseModel):
     r"""The parameters the functions accepts, described as a JSON Schema object"""
 
-    type: CreateChatCompletionRouterType
+    type: CreateChatCompletionRouterChatCompletionsType
 
     properties: Dict[str, Any]
 
@@ -802,6 +974,22 @@ class CreateChatCompletionParameters(BaseModel):
         Optional[bool], pydantic.Field(alias="additionalProperties")
     ] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["required", "additionalProperties"])
+        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 CreateChatCompletionFunctionTypedDict(TypedDict):
     name: str
@@ -827,6 +1015,22 @@ class CreateChatCompletionFunction(BaseModel):
     strict: Optional[bool] = None
     r"""Whether to enable strict schema adherence when generating the function call."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["description", "parameters", "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 CreateChatCompletionToolsTypedDict(TypedDict):
     function: CreateChatCompletionFunctionTypedDict
@@ -840,6 +1044,22 @@ class CreateChatCompletionTools(BaseModel):
     type: Optional[CreateChatCompletionType] = 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
+
 
 CreateChatCompletionToolChoiceType = Literal["function",]
 r"""The type of the tool. Currently, only function is supported."""
@@ -867,6 +1087,22 @@ class CreateChatCompletionToolChoice2(BaseModel):
     type: Optional[CreateChatCompletionToolChoiceType] = 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
+
 
 CreateChatCompletionToolChoice1 = Literal[
     "none",
@@ -933,6 +1169,16 @@ class CreateChatCompletionGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class CreateChatCompletionFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreateChatCompletionFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
 class CreateChatCompletionRetryTypedDict(TypedDict):
     r"""Retry configuration for the request"""
 
@@ -951,13 +1197,167 @@ class CreateChatCompletionRetry(BaseModel):
     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
+
+
+CreateChatCompletionRouterChatCompletionsRequestType = Literal["exact_match",]
+
+
+class CreateChatCompletionCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreateChatCompletionRouterChatCompletionsRequestType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreateChatCompletionCache(BaseModel):
+    r"""Cache configuration for the request."""
 
-class FallbacksTypedDict(TypedDict):
+    type: CreateChatCompletionRouterChatCompletionsRequestType
+
+    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
+
+
+CreateChatCompletionLoadBalancerType = Literal["weight_based",]
+
+
+class CreateChatCompletionLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreateChatCompletionLoadBalancerModels(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 CreateChatCompletionLoadBalancer1TypedDict(TypedDict):
+    type: CreateChatCompletionLoadBalancerType
+    models: List[CreateChatCompletionLoadBalancerModelsTypedDict]
+
+
+class CreateChatCompletionLoadBalancer1(BaseModel):
+    type: CreateChatCompletionLoadBalancerType
+
+    models: List[CreateChatCompletionLoadBalancerModels]
+
+
+CreateChatCompletionLoadBalancerTypedDict = CreateChatCompletionLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreateChatCompletionLoadBalancer = CreateChatCompletionLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class CreateChatCompletionTimeoutTypedDict(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 CreateChatCompletionTimeout(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"""
+
+
+class CreateChatCompletionRouterChatCompletionsRetryTypedDict(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 CreateChatCompletionRouterChatCompletionsRetry(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
+
+
+class CreateChatCompletionRouterChatCompletionsFallbacksTypedDict(TypedDict):
     model: str
     r"""Fallback model identifier"""
 
 
-class Fallbacks(BaseModel):
+class CreateChatCompletionRouterChatCompletionsFallbacks(BaseModel):
     model: str
     r"""Fallback model identifier"""
 
@@ -985,51 +1385,6 @@ class Prompt(BaseModel):
     r"""Version of the prompt to use (currently only \"latest\" supported)"""
 
 
-@deprecated(
-    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
-)
-class CreateChatCompletionContactTypedDict(TypedDict):
-    r"""@deprecated Use identity instead. Information about the contact making the request."""
-
-    id: str
-    r"""Unique identifier for the contact"""
-    display_name: NotRequired[str]
-    r"""Display name of the contact"""
-    email: NotRequired[str]
-    r"""Email address of the contact"""
-    metadata: NotRequired[List[Dict[str, Any]]]
-    r"""A hash of key/value pairs containing any other data about the contact"""
-    logo_url: NotRequired[str]
-    r"""URL to the contact's avatar or logo"""
-    tags: NotRequired[List[str]]
-    r"""A list of tags associated with the contact"""
-
-
-@deprecated(
-    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
-)
-class CreateChatCompletionContact(BaseModel):
-    r"""@deprecated Use identity instead. Information about the contact making the request."""
-
-    id: str
-    r"""Unique identifier for the contact"""
-
-    display_name: Optional[str] = None
-    r"""Display name of the contact"""
-
-    email: Optional[str] = None
-    r"""Email address of the contact"""
-
-    metadata: Optional[List[Dict[str, Any]]] = None
-    r"""A hash of key/value pairs containing any other data about the contact"""
-
-    logo_url: Optional[str] = None
-    r"""URL to the contact's avatar or logo"""
-
-    tags: Optional[List[str]] = None
-    r"""A list of tags associated with the contact"""
-
-
 class CreateChatCompletionThreadTypedDict(TypedDict):
     r"""Thread information to group related requests"""
 
@@ -1048,6 +1403,22 @@ class CreateChatCompletionThread(BaseModel):
     tags: Optional[List[str]] = None
     r"""Optional tags to differentiate or categorize threads"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["tags"])
+        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 Inputs2TypedDict(TypedDict):
     key: str
@@ -1062,6 +1433,22 @@ class Inputs2(BaseModel):
 
     is_pii: Optional[bool] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["value", "is_pii"])
+        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
+
 
 InputsTypedDict = TypeAliasType(
     "InputsTypedDict", Union[Dict[str, Any], List[Inputs2TypedDict]]
@@ -1073,25 +1460,43 @@ Inputs = TypeAliasType("Inputs", Union[Dict[str, Any], List[Inputs2]])
 r"""Values to replace in the prompt messages using {{variableName}} syntax"""
 
 
-CreateChatCompletionRouterRequestType = Literal["exact_match",]
+CreateChatCompletionRouterChatCompletionsRequestRequestBodyType = Literal[
+    "exact_match",
+]
 
 
-class CacheTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsCacheTypedDict(TypedDict):
     r"""Cache configuration for the request."""
 
-    type: CreateChatCompletionRouterRequestType
+    type: CreateChatCompletionRouterChatCompletionsRequestRequestBodyType
     ttl: NotRequired[float]
     r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
 
 
-class Cache(BaseModel):
+class CreateChatCompletionRouterChatCompletionsCache(BaseModel):
     r"""Cache configuration for the request."""
 
-    type: CreateChatCompletionRouterRequestType
+    type: CreateChatCompletionRouterChatCompletionsRequestRequestBodyType
 
     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
+
 
 CreateChatCompletionSearchType = Literal[
     "vector_search",
@@ -1113,48 +1518,50 @@ class CreateChatCompletionOrExists(BaseModel):
     exists: bool
 
 
-CreateChatCompletionOrRouterNinTypedDict = TypeAliasType(
-    "CreateChatCompletionOrRouterNinTypedDict", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsNinTypedDict = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsNinTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionOrRouterNin = TypeAliasType(
-    "CreateChatCompletionOrRouterNin", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsNin = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsNin", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionOrNinTypedDict(TypedDict):
     r"""Not in"""
 
-    nin: List[CreateChatCompletionOrRouterNinTypedDict]
+    nin: List[CreateChatCompletionOrRouterChatCompletionsNinTypedDict]
 
 
 class CreateChatCompletionOrNin(BaseModel):
     r"""Not in"""
 
-    nin: List[CreateChatCompletionOrRouterNin]
+    nin: List[CreateChatCompletionOrRouterChatCompletionsNin]
 
 
-CreateChatCompletionOrRouterInTypedDict = TypeAliasType(
-    "CreateChatCompletionOrRouterInTypedDict", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsInTypedDict = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsInTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionOrRouterIn = TypeAliasType(
-    "CreateChatCompletionOrRouterIn", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsIn = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsIn", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionOrInTypedDict(TypedDict):
     r"""In"""
 
-    in_: List[CreateChatCompletionOrRouterInTypedDict]
+    in_: List[CreateChatCompletionOrRouterChatCompletionsInTypedDict]
 
 
 class CreateChatCompletionOrIn(BaseModel):
     r"""In"""
 
-    in_: Annotated[List[CreateChatCompletionOrRouterIn], pydantic.Field(alias="in")]
+    in_: Annotated[
+        List[CreateChatCompletionOrRouterChatCompletionsIn], pydantic.Field(alias="in")
+    ]
 
 
 class CreateChatCompletionOrLteTypedDict(TypedDict):
@@ -1205,52 +1612,52 @@ class CreateChatCompletionOrGt(BaseModel):
     gt: float
 
 
-CreateChatCompletionOrRouterNeTypedDict = TypeAliasType(
-    "CreateChatCompletionOrRouterNeTypedDict", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsNeTypedDict = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsNeTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionOrRouterNe = TypeAliasType(
-    "CreateChatCompletionOrRouterNe", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsNe = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsNe", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionOrNeTypedDict(TypedDict):
     r"""Not equal to"""
 
-    ne: CreateChatCompletionOrRouterNeTypedDict
+    ne: CreateChatCompletionOrRouterChatCompletionsNeTypedDict
 
 
 class CreateChatCompletionOrNe(BaseModel):
     r"""Not equal to"""
 
-    ne: CreateChatCompletionOrRouterNe
+    ne: CreateChatCompletionOrRouterChatCompletionsNe
 
 
-CreateChatCompletionOrRouterEqTypedDict = TypeAliasType(
-    "CreateChatCompletionOrRouterEqTypedDict", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsEqTypedDict = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsEqTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionOrRouterEq = TypeAliasType(
-    "CreateChatCompletionOrRouterEq", Union[str, float, bool]
+CreateChatCompletionOrRouterChatCompletionsEq = TypeAliasType(
+    "CreateChatCompletionOrRouterChatCompletionsEq", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionOrEqTypedDict(TypedDict):
     r"""Equal to"""
 
-    eq: CreateChatCompletionOrRouterEqTypedDict
+    eq: CreateChatCompletionOrRouterChatCompletionsEqTypedDict
 
 
 class CreateChatCompletionOrEq(BaseModel):
     r"""Equal to"""
 
-    eq: CreateChatCompletionOrRouterEq
+    eq: CreateChatCompletionOrRouterChatCompletionsEq
 
 
-CreateChatCompletionFilterByRouterOrTypedDict = TypeAliasType(
-    "CreateChatCompletionFilterByRouterOrTypedDict",
+CreateChatCompletionFilterByRouterChatCompletionsOrTypedDict = TypeAliasType(
+    "CreateChatCompletionFilterByRouterChatCompletionsOrTypedDict",
     Union[
         CreateChatCompletionOrEqTypedDict,
         CreateChatCompletionOrNeTypedDict,
@@ -1265,8 +1672,8 @@ CreateChatCompletionFilterByRouterOrTypedDict = TypeAliasType(
 )
 
 
-CreateChatCompletionFilterByRouterOr = TypeAliasType(
-    "CreateChatCompletionFilterByRouterOr",
+CreateChatCompletionFilterByRouterChatCompletionsOr = TypeAliasType(
+    "CreateChatCompletionFilterByRouterChatCompletionsOr",
     Union[
         CreateChatCompletionOrEq,
         CreateChatCompletionOrNe,
@@ -1284,14 +1691,14 @@ CreateChatCompletionFilterByRouterOr = TypeAliasType(
 class CreateChatCompletionFilterByOrTypedDict(TypedDict):
     r"""Or"""
 
-    or_: List[Dict[str, CreateChatCompletionFilterByRouterOrTypedDict]]
+    or_: List[Dict[str, CreateChatCompletionFilterByRouterChatCompletionsOrTypedDict]]
 
 
 class CreateChatCompletionFilterByOr(BaseModel):
     r"""Or"""
 
     or_: Annotated[
-        List[Dict[str, CreateChatCompletionFilterByRouterOr]],
+        List[Dict[str, CreateChatCompletionFilterByRouterChatCompletionsOr]],
         pydantic.Field(alias="or"),
     ]
 
@@ -1308,48 +1715,50 @@ class CreateChatCompletionAndExists(BaseModel):
     exists: bool
 
 
-CreateChatCompletionAndRouterNinTypedDict = TypeAliasType(
-    "CreateChatCompletionAndRouterNinTypedDict", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsNinTypedDict = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsNinTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionAndRouterNin = TypeAliasType(
-    "CreateChatCompletionAndRouterNin", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsNin = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsNin", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionAndNinTypedDict(TypedDict):
     r"""Not in"""
 
-    nin: List[CreateChatCompletionAndRouterNinTypedDict]
+    nin: List[CreateChatCompletionAndRouterChatCompletionsNinTypedDict]
 
 
 class CreateChatCompletionAndNin(BaseModel):
     r"""Not in"""
 
-    nin: List[CreateChatCompletionAndRouterNin]
+    nin: List[CreateChatCompletionAndRouterChatCompletionsNin]
 
 
-CreateChatCompletionAndRouterInTypedDict = TypeAliasType(
-    "CreateChatCompletionAndRouterInTypedDict", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsInTypedDict = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsInTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionAndRouterIn = TypeAliasType(
-    "CreateChatCompletionAndRouterIn", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsIn = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsIn", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionAndInTypedDict(TypedDict):
     r"""In"""
 
-    in_: List[CreateChatCompletionAndRouterInTypedDict]
+    in_: List[CreateChatCompletionAndRouterChatCompletionsInTypedDict]
 
 
 class CreateChatCompletionAndIn(BaseModel):
     r"""In"""
 
-    in_: Annotated[List[CreateChatCompletionAndRouterIn], pydantic.Field(alias="in")]
+    in_: Annotated[
+        List[CreateChatCompletionAndRouterChatCompletionsIn], pydantic.Field(alias="in")
+    ]
 
 
 class CreateChatCompletionAndLteTypedDict(TypedDict):
@@ -1400,52 +1809,52 @@ class CreateChatCompletionAndGt(BaseModel):
     gt: float
 
 
-CreateChatCompletionAndRouterNeTypedDict = TypeAliasType(
-    "CreateChatCompletionAndRouterNeTypedDict", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsNeTypedDict = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsNeTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionAndRouterNe = TypeAliasType(
-    "CreateChatCompletionAndRouterNe", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsNe = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsNe", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionAndNeTypedDict(TypedDict):
     r"""Not equal to"""
 
-    ne: CreateChatCompletionAndRouterNeTypedDict
+    ne: CreateChatCompletionAndRouterChatCompletionsNeTypedDict
 
 
 class CreateChatCompletionAndNe(BaseModel):
     r"""Not equal to"""
 
-    ne: CreateChatCompletionAndRouterNe
+    ne: CreateChatCompletionAndRouterChatCompletionsNe
 
 
-CreateChatCompletionAndRouterEqTypedDict = TypeAliasType(
-    "CreateChatCompletionAndRouterEqTypedDict", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsEqTypedDict = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsEqTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletionAndRouterEq = TypeAliasType(
-    "CreateChatCompletionAndRouterEq", Union[str, float, bool]
+CreateChatCompletionAndRouterChatCompletionsEq = TypeAliasType(
+    "CreateChatCompletionAndRouterChatCompletionsEq", Union[str, float, bool]
 )
 
 
 class CreateChatCompletionAndEqTypedDict(TypedDict):
     r"""Equal to"""
 
-    eq: CreateChatCompletionAndRouterEqTypedDict
+    eq: CreateChatCompletionAndRouterChatCompletionsEqTypedDict
 
 
 class CreateChatCompletionAndEq(BaseModel):
     r"""Equal to"""
 
-    eq: CreateChatCompletionAndRouterEq
+    eq: CreateChatCompletionAndRouterChatCompletionsEq
 
 
-CreateChatCompletionFilterByRouterAndTypedDict = TypeAliasType(
-    "CreateChatCompletionFilterByRouterAndTypedDict",
+CreateChatCompletionFilterByRouterChatCompletionsAndTypedDict = TypeAliasType(
+    "CreateChatCompletionFilterByRouterChatCompletionsAndTypedDict",
     Union[
         CreateChatCompletionAndEqTypedDict,
         CreateChatCompletionAndNeTypedDict,
@@ -1460,8 +1869,8 @@ CreateChatCompletionFilterByRouterAndTypedDict = TypeAliasType(
 )
 
 
-CreateChatCompletionFilterByRouterAnd = TypeAliasType(
-    "CreateChatCompletionFilterByRouterAnd",
+CreateChatCompletionFilterByRouterChatCompletionsAnd = TypeAliasType(
+    "CreateChatCompletionFilterByRouterChatCompletionsAnd",
     Union[
         CreateChatCompletionAndEq,
         CreateChatCompletionAndNe,
@@ -1479,14 +1888,14 @@ CreateChatCompletionFilterByRouterAnd = TypeAliasType(
 class CreateChatCompletionFilterByAndTypedDict(TypedDict):
     r"""And"""
 
-    and_: List[Dict[str, CreateChatCompletionFilterByRouterAndTypedDict]]
+    and_: List[Dict[str, CreateChatCompletionFilterByRouterChatCompletionsAndTypedDict]]
 
 
 class CreateChatCompletionFilterByAnd(BaseModel):
     r"""And"""
 
     and_: Annotated[
-        List[Dict[str, CreateChatCompletionFilterByRouterAnd]],
+        List[Dict[str, CreateChatCompletionFilterByRouterChatCompletionsAnd]],
         pydantic.Field(alias="and"),
     ]
 
@@ -1503,48 +1912,50 @@ class CreateChatCompletion1Exists(BaseModel):
     exists: bool
 
 
-CreateChatCompletion1RouterNinTypedDict = TypeAliasType(
-    "CreateChatCompletion1RouterNinTypedDict", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsNinTypedDict = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsNinTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletion1RouterNin = TypeAliasType(
-    "CreateChatCompletion1RouterNin", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsNin = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsNin", Union[str, float, bool]
 )
 
 
 class CreateChatCompletion1NinTypedDict(TypedDict):
     r"""Not in"""
 
-    nin: List[CreateChatCompletion1RouterNinTypedDict]
+    nin: List[CreateChatCompletion1RouterChatCompletionsNinTypedDict]
 
 
 class CreateChatCompletion1Nin(BaseModel):
     r"""Not in"""
 
-    nin: List[CreateChatCompletion1RouterNin]
+    nin: List[CreateChatCompletion1RouterChatCompletionsNin]
 
 
-CreateChatCompletion1RouterInTypedDict = TypeAliasType(
-    "CreateChatCompletion1RouterInTypedDict", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsInTypedDict = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsInTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletion1RouterIn = TypeAliasType(
-    "CreateChatCompletion1RouterIn", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsIn = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsIn", Union[str, float, bool]
 )
 
 
 class CreateChatCompletion1InTypedDict(TypedDict):
     r"""In"""
 
-    in_: List[CreateChatCompletion1RouterInTypedDict]
+    in_: List[CreateChatCompletion1RouterChatCompletionsInTypedDict]
 
 
 class CreateChatCompletion1In(BaseModel):
     r"""In"""
 
-    in_: Annotated[List[CreateChatCompletion1RouterIn], pydantic.Field(alias="in")]
+    in_: Annotated[
+        List[CreateChatCompletion1RouterChatCompletionsIn], pydantic.Field(alias="in")
+    ]
 
 
 class CreateChatCompletion1LteTypedDict(TypedDict):
@@ -1595,48 +2006,48 @@ class CreateChatCompletion1Gt(BaseModel):
     gt: float
 
 
-CreateChatCompletion1RouterNeTypedDict = TypeAliasType(
-    "CreateChatCompletion1RouterNeTypedDict", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsNeTypedDict = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsNeTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletion1RouterNe = TypeAliasType(
-    "CreateChatCompletion1RouterNe", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsNe = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsNe", Union[str, float, bool]
 )
 
 
 class CreateChatCompletion1NeTypedDict(TypedDict):
     r"""Not equal to"""
 
-    ne: CreateChatCompletion1RouterNeTypedDict
+    ne: CreateChatCompletion1RouterChatCompletionsNeTypedDict
 
 
 class CreateChatCompletion1Ne(BaseModel):
     r"""Not equal to"""
 
-    ne: CreateChatCompletion1RouterNe
+    ne: CreateChatCompletion1RouterChatCompletionsNe
 
 
-CreateChatCompletion1RouterEqTypedDict = TypeAliasType(
-    "CreateChatCompletion1RouterEqTypedDict", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsEqTypedDict = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsEqTypedDict", Union[str, float, bool]
 )
 
 
-CreateChatCompletion1RouterEq = TypeAliasType(
-    "CreateChatCompletion1RouterEq", Union[str, float, bool]
+CreateChatCompletion1RouterChatCompletionsEq = TypeAliasType(
+    "CreateChatCompletion1RouterChatCompletionsEq", Union[str, float, bool]
 )
 
 
 class CreateChatCompletion1EqTypedDict(TypedDict):
     r"""Equal to"""
 
-    eq: CreateChatCompletion1RouterEqTypedDict
+    eq: CreateChatCompletion1RouterChatCompletionsEqTypedDict
 
 
 class CreateChatCompletion1Eq(BaseModel):
     r"""Equal to"""
 
-    eq: CreateChatCompletion1RouterEq
+    eq: CreateChatCompletion1RouterChatCompletionsEq
 
 
 CreateChatCompletionFilterBy1TypedDict = TypeAliasType(
@@ -1716,6 +2127,22 @@ class CreateChatCompletionSearchOptions(BaseModel):
     include_scores: Optional[bool] = None
     r"""Whether to include the scores in the chunk"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["include_vectors", "include_metadata", "include_scores"])
+        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 CreateChatCompletionRerankConfigTypedDict(TypedDict):
     r"""Override the rerank configuration for this search. If not provided, will use the knowledge base configured rerank settings."""
@@ -1740,6 +2167,22 @@ class CreateChatCompletionRerankConfig(BaseModel):
     top_k: Optional[int] = 10
     r"""The number of top results to return after reranking. If not provided, will default to the knowledge base configured `top_k`."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["threshold", "top_k"])
+        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 CreateChatCompletionAgenticRagConfigTypedDict(TypedDict):
     r"""Override the agentic RAG configuration for this search. If not provided, will use the knowledge base configured agentic RAG settings."""
@@ -1804,94 +2247,168 @@ class CreateChatCompletionKnowledgeBases(BaseModel):
     query: Optional[str] = None
     r"""The query to use to search the knowledge base. If not provided we will use the last user message from the messages of the requests"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "top_k",
+                "threshold",
+                "search_type",
+                "filter_by",
+                "search_options",
+                "rerank_config",
+                "agentic_rag_config",
+                "query",
+            ]
+        )
+        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
+
 
-LoadBalancerType = Literal["weight_based",]
+CreateChatCompletionLoadBalancerRouterChatCompletionsType = Literal["weight_based",]
 
 
-class LoadBalancer1TypedDict(TypedDict):
-    type: LoadBalancerType
+class CreateChatCompletionLoadBalancerRouterChatCompletionsModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class LoadBalancer1(BaseModel):
-    type: LoadBalancerType
-
+class CreateChatCompletionLoadBalancerRouterChatCompletionsModels(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
 
-LoadBalancerTypedDict = LoadBalancer1TypedDict
 
+class CreateChatCompletionLoadBalancerRouterChatCompletions1TypedDict(TypedDict):
+    type: CreateChatCompletionLoadBalancerRouterChatCompletionsType
+    models: List[CreateChatCompletionLoadBalancerRouterChatCompletionsModelsTypedDict]
 
-LoadBalancer = LoadBalancer1
 
+class CreateChatCompletionLoadBalancerRouterChatCompletions1(BaseModel):
+    type: CreateChatCompletionLoadBalancerRouterChatCompletionsType
 
-class TimeoutTypedDict(TypedDict):
+    models: List[CreateChatCompletionLoadBalancerRouterChatCompletionsModels]
+
+
+CreateChatCompletionRouterChatCompletionsLoadBalancerTypedDict = (
+    CreateChatCompletionLoadBalancerRouterChatCompletions1TypedDict
+)
+r"""Array of models with weights for load balancing requests"""
+
+
+CreateChatCompletionRouterChatCompletionsLoadBalancer = (
+    CreateChatCompletionLoadBalancerRouterChatCompletions1
+)
+r"""Array of models with weights for load balancing requests"""
+
+
+class CreateChatCompletionRouterChatCompletionsTimeoutTypedDict(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 Timeout(BaseModel):
+class CreateChatCompletionRouterChatCompletionsTimeout(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"""
 
 
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
 class CreateChatCompletionOrqTypedDict(TypedDict):
     r"""Leverage Orq's intelligent routing capabilities to enhance your AI application with enterprise-grade reliability and observability. Orq provides automatic request management including retries on failures, model fallbacks for high availability, identity-level analytics tracking, conversation threading, and dynamic prompt templating with variable substitution."""
 
     name: NotRequired[str]
     r"""The name to display on the trace. If not specified, the default system name will be used."""
-    retry: NotRequired[CreateChatCompletionRetryTypedDict]
+    retry: NotRequired[CreateChatCompletionRouterChatCompletionsRetryTypedDict]
     r"""Retry configuration for the request"""
-    fallbacks: NotRequired[List[FallbacksTypedDict]]
+    fallbacks: NotRequired[
+        List[CreateChatCompletionRouterChatCompletionsFallbacksTypedDict]
+    ]
     r"""Array of fallback models to use if primary model fails"""
     prompt: NotRequired[PromptTypedDict]
     r"""Prompt configuration for the request"""
-    identity: NotRequired[PublicContactTypedDict]
+    identity: NotRequired[PublicIdentityTypedDict]
     r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
-    contact: NotRequired[CreateChatCompletionContactTypedDict]
+    contact: NotRequired[PublicContactTypedDict]
+    r"""@deprecated Use identity instead. Information about the contact making the request."""
     thread: NotRequired[CreateChatCompletionThreadTypedDict]
     r"""Thread information to group related requests"""
     inputs: NotRequired[InputsTypedDict]
     r"""Values to replace in the prompt messages using {{variableName}} syntax"""
-    cache: NotRequired[CacheTypedDict]
+    cache: NotRequired[CreateChatCompletionRouterChatCompletionsCacheTypedDict]
     r"""Cache configuration for the request."""
     knowledge_bases: NotRequired[List[CreateChatCompletionKnowledgeBasesTypedDict]]
-    load_balancer: NotRequired[List[LoadBalancerTypedDict]]
+    load_balancer: NotRequired[
+        CreateChatCompletionRouterChatCompletionsLoadBalancerTypedDict
+    ]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[TimeoutTypedDict]
+    timeout: NotRequired[CreateChatCompletionRouterChatCompletionsTimeoutTypedDict]
     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."""
 
 
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
 class CreateChatCompletionOrq(BaseModel):
     r"""Leverage Orq's intelligent routing capabilities to enhance your AI application with enterprise-grade reliability and observability. Orq provides automatic request management including retries on failures, model fallbacks for high availability, identity-level analytics tracking, conversation threading, and dynamic prompt templating with variable substitution."""
 
     name: Optional[str] = None
     r"""The name to display on the trace. If not specified, the default system name will be used."""
 
-    retry: Optional[CreateChatCompletionRetry] = None
+    retry: Optional[CreateChatCompletionRouterChatCompletionsRetry] = None
     r"""Retry configuration for the request"""
 
-    fallbacks: Optional[List[Fallbacks]] = None
+    fallbacks: Optional[List[CreateChatCompletionRouterChatCompletionsFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
     prompt: Optional[Prompt] = None
     r"""Prompt configuration for the request"""
 
-    identity: Optional[PublicContact] = None
+    identity: Optional[PublicIdentity] = None
     r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
 
-    contact: Optional[CreateChatCompletionContact] = None
+    contact: Annotated[
+        Optional[PublicContact],
+        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 identity instead. Information about the contact making the request."""
 
     thread: Optional[CreateChatCompletionThread] = None
     r"""Thread information to group related requests"""
@@ -1899,17 +2416,50 @@ class CreateChatCompletionOrq(BaseModel):
     inputs: Optional[Inputs] = None
     r"""Values to replace in the prompt messages using {{variableName}} syntax"""
 
-    cache: Optional[Cache] = None
+    cache: Optional[CreateChatCompletionRouterChatCompletionsCache] = None
     r"""Cache configuration for the request."""
 
     knowledge_bases: Optional[List[CreateChatCompletionKnowledgeBases]] = None
 
-    load_balancer: Optional[List[LoadBalancer]] = None
+    load_balancer: Optional[CreateChatCompletionRouterChatCompletionsLoadBalancer] = (
+        None
+    )
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[Timeout] = None
+    timeout: Optional[CreateChatCompletionRouterChatCompletionsTimeout] = 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 = set(
+            [
+                "name",
+                "retry",
+                "fallbacks",
+                "prompt",
+                "identity",
+                "contact",
+                "thread",
+                "inputs",
+                "cache",
+                "knowledge_bases",
+                "load_balancer",
+                "timeout",
+            ]
+        )
+        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 CreateChatCompletionRequestBodyTypedDict(TypedDict):
     messages: List[CreateChatCompletionMessagesTypedDict]
@@ -1974,6 +2524,16 @@ class CreateChatCompletionRequestBodyTypedDict(TypedDict):
     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[CreateChatCompletionGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[CreateChatCompletionFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreateChatCompletionRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreateChatCompletionCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreateChatCompletionLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreateChatCompletionTimeoutTypedDict]
+    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."""
     orq: NotRequired[CreateChatCompletionOrqTypedDict]
     r"""Leverage Orq's intelligent routing capabilities to enhance your AI application with enterprise-grade reliability and observability. Orq provides automatic request management including retries on failures, model fallbacks for high availability, identity-level analytics tracking, conversation threading, and dynamic prompt templating with variable substitution."""
     stream: NotRequired[bool]
@@ -2068,86 +2628,110 @@ class CreateChatCompletionRequestBody(BaseModel):
     guardrails: Optional[List[CreateChatCompletionGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
-    orq: Optional[CreateChatCompletionOrq] = None
+    fallbacks: Optional[List[CreateChatCompletionFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreateChatCompletionRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreateChatCompletionCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreateChatCompletionLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreateChatCompletionTimeout] = 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."""
+
+    orq: Annotated[
+        Optional[CreateChatCompletionOrq],
+        pydantic.Field(
+            deprecated="warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+        ),
+    ] = None
     r"""Leverage Orq's intelligent routing capabilities to enhance your AI application with enterprise-grade reliability and observability. Orq provides automatic request management including retries on failures, model fallbacks for high availability, identity-level analytics tracking, conversation threading, and dynamic prompt templating with variable substitution."""
 
     stream: Optional[bool] = False
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "metadata",
-            "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",
-            "tools",
-            "tool_choice",
-            "parallel_tool_calls",
-            "modalities",
-            "guardrails",
-            "orq",
-            "stream",
-        ]
-        nullable_fields = [
-            "audio",
-            "frequency_penalty",
-            "max_tokens",
-            "max_completion_tokens",
-            "logprobs",
-            "top_logprobs",
-            "n",
-            "presence_penalty",
-            "seed",
-            "stop",
-            "stream_options",
-            "temperature",
-            "top_p",
-            "top_k",
-            "modalities",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "metadata",
+                "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",
+                "tools",
+                "tool_choice",
+                "parallel_tool_calls",
+                "modalities",
+                "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
+                "orq",
+                "stream",
+            ]
+        )
+        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
 
 
-CreateChatCompletionRouterFinishReason = Literal[
+CreateChatCompletionRouterChatCompletionsFinishReason = Literal[
     "stop",
     "length",
     "tool_calls",
@@ -2157,7 +2741,7 @@ CreateChatCompletionRouterFinishReason = Literal[
 r"""The reason the model stopped generating tokens."""
 
 
-class CreateChatCompletionRouterResponseTopLogprobsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsResponseTopLogprobsTypedDict(TypedDict):
     token: str
     r"""The token."""
     logprob: float
@@ -2166,7 +2750,7 @@ class CreateChatCompletionRouterResponseTopLogprobsTypedDict(TypedDict):
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
 
-class CreateChatCompletionRouterResponseTopLogprobs(BaseModel):
+class CreateChatCompletionRouterChatCompletionsResponseTopLogprobs(BaseModel):
     token: str
     r"""The token."""
 
@@ -2178,47 +2762,33 @@ class CreateChatCompletionRouterResponseTopLogprobs(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-class CreateChatCompletionRouterContentTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsContentTypedDict(TypedDict):
     token: str
     r"""The token."""
     logprob: float
     r"""The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely."""
     bytes_: Nullable[List[float]]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
-    top_logprobs: List[CreateChatCompletionRouterResponseTopLogprobsTypedDict]
+    top_logprobs: List[
+        CreateChatCompletionRouterChatCompletionsResponseTopLogprobsTypedDict
+    ]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
 
-class CreateChatCompletionRouterContent(BaseModel):
+class CreateChatCompletionRouterChatCompletionsContent(BaseModel):
     token: str
     r"""The token."""
 
@@ -2228,41 +2798,27 @@ class CreateChatCompletionRouterContent(BaseModel):
     bytes_: Annotated[Nullable[List[float]], pydantic.Field(alias="bytes")]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
-    top_logprobs: List[CreateChatCompletionRouterResponseTopLogprobs]
+    top_logprobs: List[CreateChatCompletionRouterChatCompletionsResponseTopLogprobs]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-class CreateChatCompletionRouterResponse200TopLogprobsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsResponse200TopLogprobsTypedDict(
+    TypedDict
+):
     token: str
     r"""The token."""
     logprob: float
@@ -2271,7 +2827,7 @@ class CreateChatCompletionRouterResponse200TopLogprobsTypedDict(TypedDict):
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
 
-class CreateChatCompletionRouterResponse200TopLogprobs(BaseModel):
+class CreateChatCompletionRouterChatCompletionsResponse200TopLogprobs(BaseModel):
     token: str
     r"""The token."""
 
@@ -2283,47 +2839,33 @@ class CreateChatCompletionRouterResponse200TopLogprobs(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-class CreateChatCompletionRouterRefusalTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsRefusalTypedDict(TypedDict):
     token: str
     r"""The token."""
     logprob: float
     r"""The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely."""
     bytes_: Nullable[List[float]]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
-    top_logprobs: List[CreateChatCompletionRouterResponse200TopLogprobsTypedDict]
+    top_logprobs: List[
+        CreateChatCompletionRouterChatCompletionsResponse200TopLogprobsTypedDict
+    ]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
 
-class CreateChatCompletionRouterRefusal(BaseModel):
+class CreateChatCompletionRouterChatCompletionsRefusal(BaseModel):
     token: str
     r"""The token."""
 
@@ -2333,140 +2875,142 @@ class CreateChatCompletionRouterRefusal(BaseModel):
     bytes_: Annotated[Nullable[List[float]], pydantic.Field(alias="bytes")]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
-    top_logprobs: List[CreateChatCompletionRouterResponse200TopLogprobs]
+    top_logprobs: List[CreateChatCompletionRouterChatCompletionsResponse200TopLogprobs]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-class CreateChatCompletionRouterLogprobsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsLogprobsTypedDict(TypedDict):
     r"""Log probability information for the choice."""
 
-    content: Nullable[List[CreateChatCompletionRouterContentTypedDict]]
+    content: Nullable[List[CreateChatCompletionRouterChatCompletionsContentTypedDict]]
     r"""A list of message content tokens with log probability information."""
-    refusal: Nullable[List[CreateChatCompletionRouterRefusalTypedDict]]
+    refusal: Nullable[List[CreateChatCompletionRouterChatCompletionsRefusalTypedDict]]
     r"""A list of message refusal tokens with log probability information."""
 
 
-class CreateChatCompletionRouterLogprobs(BaseModel):
+class CreateChatCompletionRouterChatCompletionsLogprobs(BaseModel):
     r"""Log probability information for the choice."""
 
-    content: Nullable[List[CreateChatCompletionRouterContent]]
+    content: Nullable[List[CreateChatCompletionRouterChatCompletionsContent]]
     r"""A list of message content tokens with log probability information."""
 
-    refusal: Nullable[List[CreateChatCompletionRouterRefusal]]
+    refusal: Nullable[List[CreateChatCompletionRouterChatCompletionsRefusal]]
     r"""A list of message refusal tokens with log probability information."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["content", "refusal"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-CreateChatCompletionRouterResponse200Type = Literal["function",]
+CreateChatCompletionRouterChatCompletionsResponse200Type = Literal["function",]
 r"""The type of the tool. Currently, only `function` is supported."""
 
 
-class CreateChatCompletionRouterResponseFunctionTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsResponseFunctionTypedDict(TypedDict):
     name: NotRequired[str]
     r"""The name of the function."""
     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 CreateChatCompletionRouterResponseFunction(BaseModel):
+class CreateChatCompletionRouterChatCompletionsResponseFunction(BaseModel):
     name: Optional[str] = None
     r"""The name of the function."""
 
     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
 
-class CreateChatCompletionRouterToolCallsTypedDict(TypedDict):
+        return m
+
+
+class CreateChatCompletionRouterChatCompletionsToolCallsTypedDict(TypedDict):
     index: NotRequired[float]
     r"""The index of the tool call."""
     id: NotRequired[str]
     r"""The ID of the tool call."""
-    type: NotRequired[CreateChatCompletionRouterResponse200Type]
+    type: NotRequired[CreateChatCompletionRouterChatCompletionsResponse200Type]
     r"""The type of the tool. Currently, only `function` is supported."""
-    function: NotRequired[CreateChatCompletionRouterResponseFunctionTypedDict]
+    function: NotRequired[
+        CreateChatCompletionRouterChatCompletionsResponseFunctionTypedDict
+    ]
     thought_signature: NotRequired[str]
     r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models."""
 
 
-class CreateChatCompletionRouterToolCalls(BaseModel):
+class CreateChatCompletionRouterChatCompletionsToolCalls(BaseModel):
     index: Optional[float] = None
     r"""The index of the tool call."""
 
     id: Optional[str] = None
     r"""The ID of the tool call."""
 
-    type: Optional[CreateChatCompletionRouterResponse200Type] = None
+    type: Optional[CreateChatCompletionRouterChatCompletionsResponse200Type] = None
     r"""The type of the tool. Currently, only `function` is supported."""
 
-    function: Optional[CreateChatCompletionRouterResponseFunction] = None
+    function: Optional[CreateChatCompletionRouterChatCompletionsResponseFunction] = None
 
     thought_signature: Optional[str] = None
     r"""Encrypted representation of the model internal reasoning state during function calling. Required by Gemini 3 models."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["index", "id", "type", "function", "thought_signature"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
 
-CreateChatCompletionRouterRole = Literal["assistant",]
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
+
+CreateChatCompletionRouterChatCompletionsRole = Literal["assistant",]
 
 
-class CreateChatCompletionRouterResponseAudioTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsResponseAudioTypedDict(TypedDict):
     r"""Audio response data in streaming mode."""
 
     id: NotRequired[str]
@@ -2475,7 +3019,7 @@ class CreateChatCompletionRouterResponseAudioTypedDict(TypedDict):
     expires_at: NotRequired[int]
 
 
-class CreateChatCompletionRouterResponseAudio(BaseModel):
+class CreateChatCompletionRouterChatCompletionsResponseAudio(BaseModel):
     r"""Audio response data in streaming mode."""
 
     id: Optional[str] = None
@@ -2486,6 +3030,22 @@ class CreateChatCompletionRouterResponseAudio(BaseModel):
 
     expires_at: Optional[int] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "transcript", "data", "expires_at"])
+        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 DeltaTypedDict(TypedDict):
     r"""A chat completion delta generated by streamed model responses."""
@@ -2493,15 +3053,19 @@ class DeltaTypedDict(TypedDict):
     content: NotRequired[Nullable[str]]
     r"""The contents of the chunk message."""
     refusal: NotRequired[Nullable[str]]
-    tool_calls: NotRequired[List[CreateChatCompletionRouterToolCallsTypedDict]]
-    role: NotRequired[CreateChatCompletionRouterRole]
+    tool_calls: NotRequired[
+        List[CreateChatCompletionRouterChatCompletionsToolCallsTypedDict]
+    ]
+    role: NotRequired[CreateChatCompletionRouterChatCompletionsRole]
     reasoning: NotRequired[str]
     r"""Internal thought process of the model"""
     reasoning_signature: NotRequired[str]
     r"""The signature holds a cryptographic token which verifies that the thinking block was generated by the model, and is verified when thinking is part of a multiturn conversation. This value should not be modified and should always be sent to the API when the reasoning is redacted. Currently only supported by `Anthropic`."""
     redacted_reasoning: NotRequired[str]
     r"""Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context."""
-    audio: NotRequired[Nullable[CreateChatCompletionRouterResponseAudioTypedDict]]
+    audio: NotRequired[
+        Nullable[CreateChatCompletionRouterChatCompletionsResponseAudioTypedDict]
+    ]
     r"""Audio response data in streaming mode."""
 
 
@@ -2513,9 +3077,11 @@ class Delta(BaseModel):
 
     refusal: OptionalNullable[str] = UNSET
 
-    tool_calls: Optional[List[CreateChatCompletionRouterToolCalls]] = None
+    tool_calls: Optional[List[CreateChatCompletionRouterChatCompletionsToolCalls]] = (
+        None
+    )
 
-    role: Optional[CreateChatCompletionRouterRole] = None
+    role: Optional[CreateChatCompletionRouterChatCompletionsRole] = None
 
     reasoning: Optional[str] = None
     r"""Internal thought process of the model"""
@@ -2526,62 +3092,63 @@ class Delta(BaseModel):
     redacted_reasoning: Optional[str] = None
     r"""Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context."""
 
-    audio: OptionalNullable[CreateChatCompletionRouterResponseAudio] = UNSET
+    audio: OptionalNullable[CreateChatCompletionRouterChatCompletionsResponseAudio] = (
+        UNSET
+    )
     r"""Audio response data in streaming mode."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "content",
-            "refusal",
-            "tool_calls",
-            "role",
-            "reasoning",
-            "reasoning_signature",
-            "redacted_reasoning",
-            "audio",
-        ]
-        nullable_fields = ["content", "refusal", "audio"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "content",
+                "refusal",
+                "tool_calls",
+                "role",
+                "reasoning",
+                "reasoning_signature",
+                "redacted_reasoning",
+                "audio",
+            ]
+        )
+        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)
-            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
 
 
-class CreateChatCompletionRouterChoicesTypedDict(TypedDict):
-    finish_reason: Nullable[CreateChatCompletionRouterFinishReason]
+class CreateChatCompletionRouterChatCompletionsChoicesTypedDict(TypedDict):
+    finish_reason: Nullable[CreateChatCompletionRouterChatCompletionsFinishReason]
     r"""The reason the model stopped generating tokens."""
     delta: DeltaTypedDict
     r"""A chat completion delta generated by streamed model responses."""
     index: NotRequired[float]
     r"""The index of the choice in the list of choices."""
-    logprobs: NotRequired[Nullable[CreateChatCompletionRouterLogprobsTypedDict]]
+    logprobs: NotRequired[
+        Nullable[CreateChatCompletionRouterChatCompletionsLogprobsTypedDict]
+    ]
     r"""Log probability information for the choice."""
 
 
-class CreateChatCompletionRouterChoices(BaseModel):
-    finish_reason: Nullable[CreateChatCompletionRouterFinishReason]
+class CreateChatCompletionRouterChatCompletionsChoices(BaseModel):
+    finish_reason: Nullable[CreateChatCompletionRouterChatCompletionsFinishReason]
     r"""The reason the model stopped generating tokens."""
 
     delta: Delta
@@ -2590,48 +3157,45 @@ class CreateChatCompletionRouterChoices(BaseModel):
     index: Optional[float] = 0
     r"""The index of the choice in the list of choices."""
 
-    logprobs: OptionalNullable[CreateChatCompletionRouterLogprobs] = UNSET
+    logprobs: OptionalNullable[CreateChatCompletionRouterChatCompletionsLogprobs] = (
+        UNSET
+    )
     r"""Log probability information for the choice."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["index", "logprobs"]
-        nullable_fields = ["finish_reason", "logprobs"]
-        null_default_fields = []
-
+        optional_fields = set(["index", "logprobs"])
+        nullable_fields = set(["finish_reason", "logprobs"])
         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
 
 
-class CreateChatCompletionRouterPromptTokensDetailsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsPromptTokensDetailsTypedDict(TypedDict):
     cached_tokens: NotRequired[Nullable[int]]
     cache_creation_tokens: NotRequired[Nullable[int]]
     audio_tokens: NotRequired[Nullable[int]]
     r"""The number of audio input tokens consumed by the request."""
 
 
-class CreateChatCompletionRouterPromptTokensDetails(BaseModel):
+class CreateChatCompletionRouterChatCompletionsPromptTokensDetails(BaseModel):
     cached_tokens: OptionalNullable[int] = UNSET
 
     cache_creation_tokens: OptionalNullable[int] = UNSET
@@ -2641,36 +3205,37 @@ class CreateChatCompletionRouterPromptTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
-        nullable_fields = ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
-        null_default_fields = []
-
+        optional_fields = set(
+            ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
+        )
+        nullable_fields = set(
+            ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
+        )
         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
 
 
-class CreateChatCompletionRouterCompletionTokensDetailsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsCompletionTokensDetailsTypedDict(
+    TypedDict
+):
     reasoning_tokens: NotRequired[Nullable[float]]
     accepted_prediction_tokens: NotRequired[Nullable[float]]
     rejected_prediction_tokens: NotRequired[Nullable[float]]
@@ -2678,7 +3243,7 @@ class CreateChatCompletionRouterCompletionTokensDetailsTypedDict(TypedDict):
     r"""The number of audio output tokens produced by the response."""
 
 
-class CreateChatCompletionRouterCompletionTokensDetails(BaseModel):
+class CreateChatCompletionRouterChatCompletionsCompletionTokensDetails(BaseModel):
     reasoning_tokens: OptionalNullable[float] = UNSET
 
     accepted_prediction_tokens: OptionalNullable[float] = UNSET
@@ -2690,46 +3255,45 @@ class CreateChatCompletionRouterCompletionTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "reasoning_tokens",
-            "accepted_prediction_tokens",
-            "rejected_prediction_tokens",
-            "audio_tokens",
-        ]
-        nullable_fields = [
-            "reasoning_tokens",
-            "accepted_prediction_tokens",
-            "rejected_prediction_tokens",
-            "audio_tokens",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "reasoning_tokens",
+                "accepted_prediction_tokens",
+                "rejected_prediction_tokens",
+                "audio_tokens",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "reasoning_tokens",
+                "accepted_prediction_tokens",
+                "rejected_prediction_tokens",
+                "audio_tokens",
+            ]
+        )
         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
 
 
-class CreateChatCompletionRouterUsageTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsUsageTypedDict(TypedDict):
     r"""Usage statistics for the completion request."""
 
     completion_tokens: NotRequired[float]
@@ -2739,14 +3303,16 @@ class CreateChatCompletionRouterUsageTypedDict(TypedDict):
     total_tokens: NotRequired[float]
     r"""Total number of tokens used in the request (prompt + completion)."""
     prompt_tokens_details: NotRequired[
-        Nullable[CreateChatCompletionRouterPromptTokensDetailsTypedDict]
+        Nullable[CreateChatCompletionRouterChatCompletionsPromptTokensDetailsTypedDict]
     ]
     completion_tokens_details: NotRequired[
-        Nullable[CreateChatCompletionRouterCompletionTokensDetailsTypedDict]
+        Nullable[
+            CreateChatCompletionRouterChatCompletionsCompletionTokensDetailsTypedDict
+        ]
     ]
 
 
-class CreateChatCompletionRouterUsage(BaseModel):
+class CreateChatCompletionRouterChatCompletionsUsage(BaseModel):
     r"""Usage statistics for the completion request."""
 
     completion_tokens: Optional[float] = None
@@ -2759,51 +3325,48 @@ class CreateChatCompletionRouterUsage(BaseModel):
     r"""Total number of tokens used in the request (prompt + completion)."""
 
     prompt_tokens_details: OptionalNullable[
-        CreateChatCompletionRouterPromptTokensDetails
+        CreateChatCompletionRouterChatCompletionsPromptTokensDetails
     ] = UNSET
 
     completion_tokens_details: OptionalNullable[
-        CreateChatCompletionRouterCompletionTokensDetails
+        CreateChatCompletionRouterChatCompletionsCompletionTokensDetails
     ] = UNSET
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "completion_tokens",
-            "prompt_tokens",
-            "total_tokens",
-            "prompt_tokens_details",
-            "completion_tokens_details",
-        ]
-        nullable_fields = ["prompt_tokens_details", "completion_tokens_details"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "completion_tokens",
+                "prompt_tokens",
+                "total_tokens",
+                "prompt_tokens_details",
+                "completion_tokens_details",
+            ]
+        )
+        nullable_fields = set(["prompt_tokens_details", "completion_tokens_details"])
         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
 
 
-CreateChatCompletionRouterObject = Literal["chat.completion.chunk",]
+CreateChatCompletionRouterChatCompletionsObject = Literal["chat.completion.chunk",]
 
 
 class CreateChatCompletionDataTypedDict(TypedDict):
@@ -2811,16 +3374,18 @@ class CreateChatCompletionDataTypedDict(TypedDict):
 
     id: str
     r"""A unique identifier for the chat completion."""
-    choices: List[CreateChatCompletionRouterChoicesTypedDict]
+    choices: List[CreateChatCompletionRouterChatCompletionsChoicesTypedDict]
     r"""A list of chat completion choices. Can contain more than one elements if n is greater than 1. Can also be empty for the last chunk if you set stream_options: {\"include_usage\": true}."""
     created: float
     r"""The Unix timestamp (in seconds) of when the chat completion was created."""
     model: str
     r"""The model used for the chat completion."""
-    object: CreateChatCompletionRouterObject
+    object: CreateChatCompletionRouterChatCompletionsObject
     system_fingerprint: NotRequired[Nullable[str]]
     r"""This fingerprint represents the backend configuration that the model runs with."""
-    usage: NotRequired[Nullable[CreateChatCompletionRouterUsageTypedDict]]
+    usage: NotRequired[
+        Nullable[CreateChatCompletionRouterChatCompletionsUsageTypedDict]
+    ]
     r"""Usage statistics for the completion request."""
 
 
@@ -2830,7 +3395,7 @@ class CreateChatCompletionData(BaseModel):
     id: str
     r"""A unique identifier for the chat completion."""
 
-    choices: List[CreateChatCompletionRouterChoices]
+    choices: List[CreateChatCompletionRouterChatCompletionsChoices]
     r"""A list of chat completion choices. Can contain more than one elements if n is greater than 1. Can also be empty for the last chunk if you set stream_options: {\"include_usage\": true}."""
 
     created: float
@@ -2839,58 +3404,69 @@ class CreateChatCompletionData(BaseModel):
     model: str
     r"""The model used for the chat completion."""
 
-    object: CreateChatCompletionRouterObject
+    object: CreateChatCompletionRouterChatCompletionsObject
 
     system_fingerprint: OptionalNullable[str] = UNSET
     r"""This fingerprint represents the backend configuration that the model runs with."""
 
-    usage: OptionalNullable[CreateChatCompletionRouterUsage] = UNSET
+    usage: OptionalNullable[CreateChatCompletionRouterChatCompletionsUsage] = UNSET
     r"""Usage statistics for the completion request."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["system_fingerprint", "usage"]
-        nullable_fields = ["system_fingerprint", "usage"]
-        null_default_fields = []
-
+        optional_fields = set(["system_fingerprint", "usage"])
+        nullable_fields = set(["system_fingerprint", "usage"])
         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
 
 
-class CreateChatCompletionRouterResponseBodyTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsResponseBodyTypedDict(TypedDict):
     r"""Represents a streamed chunk of a chat completion response returned by model, based on the provided input."""
 
     data: NotRequired[CreateChatCompletionDataTypedDict]
     r"""Represents a streamed chunk of a chat completion response returned by model, based on the provided input."""
 
 
-class CreateChatCompletionRouterResponseBody(BaseModel):
+class CreateChatCompletionRouterChatCompletionsResponseBody(BaseModel):
     r"""Represents a streamed chunk of a chat completion response returned by model, based on the provided input."""
 
     data: Optional[CreateChatCompletionData] = None
     r"""Represents a streamed chunk of a chat completion response returned by model, based on the provided input."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["data"])
+        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
+
 
 CreateChatCompletionFinishReason = Literal[
     "stop",
@@ -2902,29 +3478,45 @@ CreateChatCompletionFinishReason = Literal[
 r"""The reason the model stopped generating tokens."""
 
 
-CreateChatCompletionRouterResponseType = Literal["function",]
+CreateChatCompletionRouterChatCompletionsResponseType = Literal["function",]
 
 
-class CreateChatCompletionRouterFunctionTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsFunctionTypedDict(TypedDict):
     name: NotRequired[str]
     r"""The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
     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 CreateChatCompletionRouterFunction(BaseModel):
+class CreateChatCompletionRouterChatCompletionsFunction(BaseModel):
     name: Optional[str] = None
     r"""The name of the function to be called. Must be a-z, A-Z, 0-9, or contain underscores and dashes, with a maximum length of 64."""
 
     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 CreateChatCompletionToolCallsTypedDict(TypedDict):
     index: NotRequired[float]
     id: NotRequired[str]
-    type: NotRequired[CreateChatCompletionRouterResponseType]
-    function: NotRequired[CreateChatCompletionRouterFunctionTypedDict]
+    type: NotRequired[CreateChatCompletionRouterChatCompletionsResponseType]
+    function: NotRequired[CreateChatCompletionRouterChatCompletionsFunctionTypedDict]
     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."""
 
@@ -2934,18 +3526,34 @@ class CreateChatCompletionToolCalls(BaseModel):
 
     id: Optional[str] = None
 
-    type: Optional[CreateChatCompletionRouterResponseType] = None
+    type: Optional[CreateChatCompletionRouterChatCompletionsResponseType] = None
 
-    function: Optional[CreateChatCompletionRouterFunction] = None
+    function: Optional[CreateChatCompletionRouterChatCompletionsFunction] = None
 
     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(["index", "id", "type", "function", "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
+
 
 CreateChatCompletionRole = Literal["assistant",]
 
 
-class CreateChatCompletionRouterAudioTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsAudioTypedDict(TypedDict):
     r"""If the audio output modality is requested, this object contains data about the audio response from the model."""
 
     id: str
@@ -2954,7 +3562,7 @@ class CreateChatCompletionRouterAudioTypedDict(TypedDict):
     transcript: str
 
 
-class CreateChatCompletionRouterAudio(BaseModel):
+class CreateChatCompletionRouterChatCompletionsAudio(BaseModel):
     r"""If the audio output modality is requested, this object contains data about the audio response from the model."""
 
     id: str
@@ -2979,7 +3587,9 @@ class CreateChatCompletionMessageTypedDict(TypedDict):
     r"""The signature holds a cryptographic token which verifies that the thinking block was generated by the model, and is verified when thinking is part of a multiturn conversation. This value should not be modified and should always be sent to the API when the reasoning is redacted. Currently only supported by `Anthropic`."""
     redacted_reasoning: NotRequired[str]
     r"""Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context."""
-    audio: NotRequired[Nullable[CreateChatCompletionRouterAudioTypedDict]]
+    audio: NotRequired[
+        Nullable[CreateChatCompletionRouterChatCompletionsAudioTypedDict]
+    ]
     r"""If the audio output modality is requested, this object contains data about the audio response from the model."""
 
 
@@ -3003,51 +3613,44 @@ class CreateChatCompletionMessage(BaseModel):
     redacted_reasoning: Optional[str] = None
     r"""Occasionally the model's internal reasoning will be flagged by the safety systems of the provider. When this occurs, the provider will encrypt the reasoning. These redacted reasoning is decrypted when passed back to the API, allowing the model to continue its response without losing context."""
 
-    audio: OptionalNullable[CreateChatCompletionRouterAudio] = UNSET
+    audio: OptionalNullable[CreateChatCompletionRouterChatCompletionsAudio] = UNSET
     r"""If the audio output modality is requested, this object contains data about the audio response from the model."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "content",
-            "refusal",
-            "tool_calls",
-            "role",
-            "reasoning",
-            "reasoning_signature",
-            "redacted_reasoning",
-            "audio",
-        ]
-        nullable_fields = [
-            "content",
-            "refusal",
-            "reasoning",
-            "reasoning_signature",
-            "audio",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "content",
+                "refusal",
+                "tool_calls",
+                "role",
+                "reasoning",
+                "reasoning_signature",
+                "redacted_reasoning",
+                "audio",
+            ]
+        )
+        nullable_fields = set(
+            ["content", "refusal", "reasoning", "reasoning_signature", "audio"]
+        )
         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
 
@@ -3073,30 +3676,14 @@ class CreateChatCompletionTopLogprobs(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
@@ -3128,36 +3715,20 @@ class CreateChatCompletionContent(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
 
 
-class CreateChatCompletionRouterTopLogprobsTypedDict(TypedDict):
+class CreateChatCompletionRouterChatCompletionsTopLogprobsTypedDict(TypedDict):
     token: str
     r"""The token."""
     logprob: float
@@ -3166,7 +3737,7 @@ class CreateChatCompletionRouterTopLogprobsTypedDict(TypedDict):
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
 
-class CreateChatCompletionRouterTopLogprobs(BaseModel):
+class CreateChatCompletionRouterChatCompletionsTopLogprobs(BaseModel):
     token: str
     r"""The token."""
 
@@ -3178,30 +3749,14 @@ class CreateChatCompletionRouterTopLogprobs(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
@@ -3214,7 +3769,7 @@ class CreateChatCompletionRefusalTypedDict(TypedDict):
     r"""The log probability of this token, if it is within the top 20 most likely tokens. Otherwise, the value -9999.0 is used to signify that the token is very unlikely."""
     bytes_: Nullable[List[float]]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
-    top_logprobs: List[CreateChatCompletionRouterTopLogprobsTypedDict]
+    top_logprobs: List[CreateChatCompletionRouterChatCompletionsTopLogprobsTypedDict]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
 
@@ -3228,35 +3783,19 @@ class CreateChatCompletionRefusal(BaseModel):
     bytes_: Annotated[Nullable[List[float]], pydantic.Field(alias="bytes")]
     r"""A list of integers representing the UTF-8 bytes representation of the token."""
 
-    top_logprobs: List[CreateChatCompletionRouterTopLogprobs]
+    top_logprobs: List[CreateChatCompletionRouterChatCompletionsTopLogprobs]
     r"""List of the most likely tokens and their log probability, at this token position."""
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["bytes"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
@@ -3282,30 +3821,14 @@ class CreateChatCompletionLogprobs(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = []
-        nullable_fields = ["content", "refusal"]
-        null_default_fields = []
-
         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)
-            ):
+            if val != UNSET_SENTINEL:
                 m[k] = val
 
         return m
@@ -3337,31 +3860,26 @@ class CreateChatCompletionChoices(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["index", "logprobs"]
-        nullable_fields = ["finish_reason", "logprobs"]
-        null_default_fields = []
-
+        optional_fields = set(["index", "logprobs"])
+        nullable_fields = set(["finish_reason", "logprobs"])
         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
 
@@ -3383,31 +3901,30 @@ class CreateChatCompletionPromptTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
-        nullable_fields = ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
-        null_default_fields = []
-
+        optional_fields = set(
+            ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
+        )
+        nullable_fields = set(
+            ["cached_tokens", "cache_creation_tokens", "audio_tokens"]
+        )
         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
 
@@ -3432,41 +3949,40 @@ class CreateChatCompletionCompletionTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "reasoning_tokens",
-            "accepted_prediction_tokens",
-            "rejected_prediction_tokens",
-            "audio_tokens",
-        ]
-        nullable_fields = [
-            "reasoning_tokens",
-            "accepted_prediction_tokens",
-            "rejected_prediction_tokens",
-            "audio_tokens",
-        ]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "reasoning_tokens",
+                "accepted_prediction_tokens",
+                "rejected_prediction_tokens",
+                "audio_tokens",
+            ]
+        )
+        nullable_fields = set(
+            [
+                "reasoning_tokens",
+                "accepted_prediction_tokens",
+                "rejected_prediction_tokens",
+                "audio_tokens",
+            ]
+        )
         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
 
@@ -3510,37 +4026,34 @@ class CreateChatCompletionUsage(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "completion_tokens",
-            "prompt_tokens",
-            "total_tokens",
-            "prompt_tokens_details",
-            "completion_tokens_details",
-        ]
-        nullable_fields = ["prompt_tokens_details", "completion_tokens_details"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "completion_tokens",
+                "prompt_tokens",
+                "total_tokens",
+                "prompt_tokens_details",
+                "completion_tokens_details",
+            ]
+        )
+        nullable_fields = set(["prompt_tokens_details", "completion_tokens_details"])
         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
 
@@ -3591,31 +4104,26 @@ class CreateChatCompletionResponseBody(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["system_fingerprint", "usage"]
-        nullable_fields = ["system_fingerprint", "usage"]
-        null_default_fields = []
-
+        optional_fields = set(["system_fingerprint", "usage"])
+        nullable_fields = set(["system_fingerprint", "usage"])
         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
 
@@ -3625,9 +4133,11 @@ CreateChatCompletionResponseTypedDict = TypeAliasType(
     Union[
         CreateChatCompletionResponseBodyTypedDict,
         Union[
-            eventstreaming.EventStream[CreateChatCompletionRouterResponseBodyTypedDict],
+            eventstreaming.EventStream[
+                CreateChatCompletionRouterChatCompletionsResponseBodyTypedDict
+            ],
             eventstreaming.EventStreamAsync[
-                CreateChatCompletionRouterResponseBodyTypedDict
+                CreateChatCompletionRouterChatCompletionsResponseBodyTypedDict
             ],
         ],
     ],
@@ -3639,8 +4149,12 @@ CreateChatCompletionResponse = TypeAliasType(
     Union[
         CreateChatCompletionResponseBody,
         Union[
-            eventstreaming.EventStream[CreateChatCompletionRouterResponseBody],
-            eventstreaming.EventStreamAsync[CreateChatCompletionRouterResponseBody],
+            eventstreaming.EventStream[
+                CreateChatCompletionRouterChatCompletionsResponseBody
+            ],
+            eventstreaming.EventStreamAsync[
+                CreateChatCompletionRouterChatCompletionsResponseBody
+            ],
         ],
     ],
 )