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

orq_ai_sdk/models/deploymentstreamop.py

@@ -10,6 +10,7 @@ from .imagecontentpartschema import (
     ImageContentPartSchema,
     ImageContentPartSchemaTypedDict,
 )
+from .publicidentity import PublicIdentity, PublicIdentityTypedDict
 from .reasoningpartschema import ReasoningPartSchema, ReasoningPartSchemaTypedDict
 from .redactedreasoningpartschema import (
     RedactedReasoningPartSchema,
@@ -49,6 +50,22 @@ class DeploymentStreamGlobals(BaseModel):
         FieldMetadata(header=HeaderMetadata(style="simple", explode=False)),
     ] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["environment", "contactId"])
+        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
+
 
 DeploymentStreamPrefixMessagesDeploymentsRequestRequestBody5Role = Literal["tool",]
 r"""The role of the messages author, in this case tool."""
@@ -119,6 +136,22 @@ class DeploymentStreamPrefixMessagesCacheControl(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 DeploymentStreamPrefixMessagesToolMessageTypedDict(TypedDict):
     role: DeploymentStreamPrefixMessagesDeploymentsRequestRequestBody5Role
@@ -146,31 +179,26 @@ class DeploymentStreamPrefixMessagesToolMessage(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
 
@@ -249,6 +277,22 @@ class DeploymentStreamPrefixMessagesFunction(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 DeploymentStreamPrefixMessagesToolCallsTypedDict(TypedDict):
     id: str
@@ -272,6 +316,22 @@ class DeploymentStreamPrefixMessagesToolCalls(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 DeploymentStreamPrefixMessagesAssistantMessageTypedDict(TypedDict):
     role: DeploymentStreamPrefixMessagesDeploymentsRequestRequestBodyRole
@@ -315,31 +375,26 @@ class DeploymentStreamPrefixMessagesAssistantMessage(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
 
@@ -395,6 +450,22 @@ class DeploymentStream2CacheControl(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 DeploymentStream24TypedDict(TypedDict):
     type: DeploymentStream2Type
@@ -413,6 +484,22 @@ class DeploymentStream24(BaseModel):
 
     cache_control: Optional[DeploymentStream2CacheControl] = 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
+
 
 DeploymentStreamContent2TypedDict = TypeAliasType(
     "DeploymentStreamContent2TypedDict",
@@ -469,6 +556,22 @@ class DeploymentStreamPrefixMessagesUserMessage(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
+
 
 DeploymentStreamPrefixMessagesDeploymentsRole = Literal["developer",]
 r"""The role of the messages author, in this case  `developer`."""
@@ -507,6 +610,22 @@ class DeploymentStreamPrefixMessagesDeveloperMessage(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
+
 
 DeploymentStreamPrefixMessagesRole = Literal["system",]
 r"""The role of the messages author, in this case `system`."""
@@ -548,6 +667,22 @@ class DeploymentStreamPrefixMessagesSystemMessage(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
+
 
 DeploymentStreamPrefixMessagesTypedDict = TypeAliasType(
     "DeploymentStreamPrefixMessagesTypedDict",
@@ -645,6 +780,22 @@ class DeploymentStreamMessagesCacheControl(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 DeploymentStreamMessagesToolMessageTypedDict(TypedDict):
     role: DeploymentStreamMessagesDeploymentsRequestRequestBody5Role
@@ -670,31 +821,26 @@ class DeploymentStreamMessagesToolMessage(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
 
@@ -774,6 +920,22 @@ class DeploymentStreamMessagesFunction(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 DeploymentStreamMessagesToolCallsTypedDict(TypedDict):
     id: str
@@ -797,6 +959,22 @@ class DeploymentStreamMessagesToolCalls(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 DeploymentStreamMessagesAssistantMessageTypedDict(TypedDict):
     role: DeploymentStreamMessagesDeploymentsRequestRequestBodyRole
@@ -838,31 +1016,26 @@ class DeploymentStreamMessagesAssistantMessage(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
 
@@ -918,6 +1091,22 @@ class DeploymentStream2DeploymentsCacheControl(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 DeploymentStream2Deployments4TypedDict(TypedDict):
     type: DeploymentStream2DeploymentsRequestType
@@ -936,6 +1125,22 @@ class DeploymentStream2Deployments4(BaseModel):
 
     cache_control: Optional[DeploymentStream2DeploymentsCacheControl] = 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
+
 
 DeploymentStreamContentDeploymentsRequestRequestBody2TypedDict = TypeAliasType(
     "DeploymentStreamContentDeploymentsRequestRequestBody2TypedDict",
@@ -992,6 +1197,22 @@ class DeploymentStreamMessagesUserMessage(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
+
 
 DeploymentStreamMessagesDeploymentsRole = Literal["developer",]
 r"""The role of the messages author, in this case  `developer`."""
@@ -1030,6 +1251,22 @@ class DeploymentStreamMessagesDeveloperMessage(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
+
 
 DeploymentStreamMessagesRole = Literal["system",]
 r"""The role of the messages author, in this case `system`."""
@@ -1071,6 +1308,22 @@ class DeploymentStreamMessagesSystemMessage(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
+
 
 DeploymentStreamMessagesTypedDict = TypeAliasType(
     "DeploymentStreamMessagesTypedDict",
@@ -1119,6 +1372,22 @@ class DeploymentStreamMetadata(BaseModel):
     page_number: Optional[float] = None
     r"""The page number the text is from."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["file_name", "file_type", "page_number"])
+        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 DeploymentStreamDocumentsTypedDict(TypedDict):
     text: str
@@ -1134,6 +1403,22 @@ class DeploymentStreamDocuments(BaseModel):
     metadata: Optional[DeploymentStreamMetadata] = None
     r"""Metadata about the document"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["metadata"])
+        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 DeploymentStreamInvokeOptionsTypedDict(TypedDict):
     include_retrievals: NotRequired[bool]
@@ -1154,6 +1439,22 @@ class DeploymentStreamInvokeOptions(BaseModel):
     mock_response: Optional[str] = None
     r"""A mock response to use instead of calling the LLM API. This is useful for testing purposes. When provided, the system will return a response object with this content as the completion, without making an actual API call to the LLM provider. This works for both streaming and non-streaming requests. Mock responses will not generate logs, traces or be counted for your plan usage."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["include_retrievals", "include_usage", "mock_response"])
+        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 DeploymentStreamThreadTypedDict(TypedDict):
     id: str
@@ -1169,6 +1470,22 @@ class DeploymentStreamThread(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 DeploymentStreamOrExistsTypedDict(TypedDict):
     r"""Exists"""
@@ -1513,6 +1830,64 @@ class DeploymentStreamAndEq(BaseModel):
     eq: DeploymentStreamAndDeploymentsEq
 
 
+DeploymentStream1DeploymentsInTypedDict = TypeAliasType(
+    "DeploymentStream1DeploymentsInTypedDict", Union[str, float, bool]
+)
+
+
+DeploymentStream1DeploymentsIn = TypeAliasType(
+    "DeploymentStream1DeploymentsIn", Union[str, float, bool]
+)
+
+
+class DeploymentStream1InTypedDict(TypedDict):
+    r"""In"""
+
+    in_: List[DeploymentStream1DeploymentsInTypedDict]
+
+
+class DeploymentStream1In(BaseModel):
+    r"""In"""
+
+    in_: Annotated[List[DeploymentStream1DeploymentsIn], pydantic.Field(alias="in")]
+
+
+class DeploymentStream1LteTypedDict(TypedDict):
+    r"""Less than or equal to"""
+
+    lte: float
+
+
+class DeploymentStream1Lte(BaseModel):
+    r"""Less than or equal to"""
+
+    lte: float
+
+
+class DeploymentStream1LtTypedDict(TypedDict):
+    r"""Less than"""
+
+    lt: float
+
+
+class DeploymentStream1Lt(BaseModel):
+    r"""Less than"""
+
+    lt: float
+
+
+class DeploymentStream1GteTypedDict(TypedDict):
+    r"""Greater than or equal to"""
+
+    gte: float
+
+
+class DeploymentStream1Gte(BaseModel):
+    r"""Greater than or equal to"""
+
+    gte: float
+
+
 DeploymentStreamKnowledgeFilterDeploymentsAndTypedDict = TypeAliasType(
     "DeploymentStreamKnowledgeFilterDeploymentsAndTypedDict",
     Union[
@@ -1594,64 +1969,6 @@ class DeploymentStream1Nin(BaseModel):
     nin: List[DeploymentStream1DeploymentsNin]
 
 
-DeploymentStream1DeploymentsInTypedDict = TypeAliasType(
-    "DeploymentStream1DeploymentsInTypedDict", Union[str, float, bool]
-)
-
-
-DeploymentStream1DeploymentsIn = TypeAliasType(
-    "DeploymentStream1DeploymentsIn", Union[str, float, bool]
-)
-
-
-class DeploymentStream1InTypedDict(TypedDict):
-    r"""In"""
-
-    in_: List[DeploymentStream1DeploymentsInTypedDict]
-
-
-class DeploymentStream1In(BaseModel):
-    r"""In"""
-
-    in_: Annotated[List[DeploymentStream1DeploymentsIn], pydantic.Field(alias="in")]
-
-
-class DeploymentStream1LteTypedDict(TypedDict):
-    r"""Less than or equal to"""
-
-    lte: float
-
-
-class DeploymentStream1Lte(BaseModel):
-    r"""Less than or equal to"""
-
-    lte: float
-
-
-class DeploymentStream1LtTypedDict(TypedDict):
-    r"""Less than"""
-
-    lt: float
-
-
-class DeploymentStream1Lt(BaseModel):
-    r"""Less than"""
-
-    lt: float
-
-
-class DeploymentStream1GteTypedDict(TypedDict):
-    r"""Greater than or equal to"""
-
-    gte: float
-
-
-class DeploymentStream1Gte(BaseModel):
-    r"""Greater than or equal to"""
-
-    gte: float
-
-
 class DeploymentStream1GtTypedDict(TypedDict):
     r"""Greater than"""
 
@@ -1773,6 +2090,8 @@ class DeploymentStreamRequestBodyTypedDict(TypedDict):
     r"""A list of messages to include after the `System` message, but before the  `User` and `Assistant` pairs configured in your deployment."""
     messages: NotRequired[List[DeploymentStreamMessagesTypedDict]]
     r"""A list of messages to send to the deployment."""
+    identity: NotRequired[PublicIdentityTypedDict]
+    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
     file_ids: NotRequired[List[str]]
     r"""A list of file IDs that are associated with the deployment request."""
     metadata: NotRequired[Dict[str, Any]]
@@ -1803,6 +2122,9 @@ class DeploymentStreamRequestBody(BaseModel):
     messages: Optional[List[DeploymentStreamMessages]] = None
     r"""A list of messages to send to the deployment."""
 
+    identity: Optional[PublicIdentity] = None
+    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
+
     file_ids: Optional[List[str]] = None
     r"""A list of file IDs that are associated with the deployment request."""
 
@@ -1822,6 +2144,37 @@ class DeploymentStreamRequestBody(BaseModel):
     knowledge_filter: Optional[DeploymentStreamKnowledgeFilter] = None
     r"""A filter to apply to the knowledge base chunk metadata when using  knowledge bases in the deployment."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            [
+                "inputs",
+                "context",
+                "prefix_messages",
+                "messages",
+                "identity",
+                "file_ids",
+                "metadata",
+                "extra_params",
+                "documents",
+                "invoke_options",
+                "thread",
+                "knowledge_filter",
+            ]
+        )
+        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
+
 
 DeploymentStreamObject = Literal[
     "chat",
@@ -1897,31 +2250,26 @@ class DeploymentStreamDeploymentsMetadata(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["rerank_score"]
-        nullable_fields = ["page_number"]
-        null_default_fields = []
-
+        optional_fields = set(["rerank_score"])
+        nullable_fields = set(["page_number"])
         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
 
@@ -1950,31 +2298,26 @@ class DeploymentStreamPromptTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["cached_tokens"]
-        nullable_fields = ["cached_tokens"]
-        null_default_fields = []
-
+        optional_fields = set(["cached_tokens"])
+        nullable_fields = set(["cached_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
 
@@ -1988,31 +2331,26 @@ class DeploymentStreamCompletionTokensDetails(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["reasoning_tokens"]
-        nullable_fields = ["reasoning_tokens"]
-        null_default_fields = []
-
+        optional_fields = set(["reasoning_tokens"])
+        nullable_fields = set(["reasoning_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
 
@@ -2046,37 +2384,34 @@ class DeploymentStreamUsage(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "total_tokens",
-            "prompt_tokens",
-            "completion_tokens",
-            "prompt_tokens_details",
-            "completion_tokens_details",
-        ]
-        nullable_fields = ["completion_tokens_details"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "total_tokens",
+                "prompt_tokens",
+                "completion_tokens",
+                "prompt_tokens_details",
+                "completion_tokens_details",
+            ]
+        )
+        nullable_fields = set(["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
 
@@ -2161,31 +2496,28 @@ class DeploymentStreamMessage2(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["reasoning", "reasoning_signature", "redacted_reasoning"]
-        nullable_fields = ["content"]
-        null_default_fields = []
-
+        optional_fields = set(
+            ["reasoning", "reasoning_signature", "redacted_reasoning"]
+        )
+        nullable_fields = set(["content"])
         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
 
@@ -2238,6 +2570,22 @@ class DeploymentStreamMessageToolCalls(BaseModel):
 
     index: Optional[float] = None
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["id", "index"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+
+            if val != UNSET_SENTINEL:
+                if val is not None or k not in optional_fields:
+                    m[k] = val
+
+        return m
+
 
 class DeploymentStreamMessage1TypedDict(TypedDict):
     type: DeploymentStreamMessageType
@@ -2274,36 +2622,28 @@ class DeploymentStreamMessage1(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "content",
-            "reasoning",
-            "reasoning_signature",
-            "redacted_reasoning",
-        ]
-        nullable_fields = ["content"]
-        null_default_fields = []
-
+        optional_fields = set(
+            ["content", "reasoning", "reasoning_signature", "redacted_reasoning"]
+        )
+        nullable_fields = set(["content"])
         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
 
@@ -2343,31 +2683,26 @@ class DeploymentStreamChoices(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["finish_reason"]
-        nullable_fields = ["finish_reason"]
-        null_default_fields = []
-
+        optional_fields = set(["finish_reason"])
+        nullable_fields = set(["finish_reason"])
         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
 
@@ -2443,38 +2778,35 @@ class DeploymentStreamData(BaseModel):
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = [
-            "integration_id",
-            "finalized",
-            "system_fingerprint",
-            "retrievals",
-            "provider_response",
-            "usage",
-        ]
-        nullable_fields = ["system_fingerprint", "usage"]
-        null_default_fields = []
-
+        optional_fields = set(
+            [
+                "integration_id",
+                "finalized",
+                "system_fingerprint",
+                "retrievals",
+                "provider_response",
+                "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
 
@@ -2489,3 +2821,19 @@ class DeploymentStreamResponseBody(BaseModel):
     r"""Successful operation"""
 
     data: Optional[DeploymentStreamData] = None
+
+    @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