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

orq_ai_sdk/models/publiccontact.py

@@ -1,13 +1,17 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
 from typing import Any, Dict, List, Optional
-from typing_extensions import NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict, deprecated
 
 
+@deprecated(
+    "warning: ** DEPRECATED ** - This will be removed in a future release, please migrate away from it as soon as possible."
+)
 class PublicContactTypedDict(TypedDict):
-    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
+    r"""@deprecated Use identity instead. Information about the contact making the request."""
 
     id: str
     r"""Unique identifier for the contact"""
@@ -23,8 +27,11 @@ class PublicContactTypedDict(TypedDict):
     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 PublicContact(BaseModel):
-    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
+    r"""@deprecated Use identity instead. Information about the contact making the request."""
 
     id: str
     r"""Unique identifier for the contact"""
@@ -43,3 +50,19 @@ class PublicContact(BaseModel):
 
     tags: Optional[List[str]] = None
     r"""A list of tags associated with the contact"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["display_name", "email", "metadata", "logo_url", "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

orq_ai_sdk/models/publicidentity.py

@@ -0,0 +1,62 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
+from typing import Any, Dict, List, Optional
+from typing_extensions import NotRequired, TypedDict
+
+
+class PublicIdentityTypedDict(TypedDict):
+    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
+
+    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"""
+
+
+class PublicIdentity(BaseModel):
+    r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
+
+    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"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["display_name", "email", "metadata", "logo_url", "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

orq_ai_sdk/models/reasoningpart.py

@@ -1,8 +1,9 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
 import pydantic
+from pydantic import model_serializer
 from typing import Any, Dict, Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -36,7 +37,7 @@ class ReasoningPart(BaseModel):
     r"""The reasoning or thought process behind the response. Used for chain-of-thought or extended thinking."""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "reasoning_01kexrj7d0czkmbw9a0wjyr6d4"
+        "reasoning_01kftttqrsjfpz1fk19h5qh6zm"
     )
     r"""Unique identifier for the part. Format: reasoning_{ulid} (e.g., reasoning_01hxyz...)"""
 
@@ -45,3 +46,19 @@ class ReasoningPart(BaseModel):
 
     signature: Optional[str] = None
     r"""Optional cryptographic signature to verify the authenticity and integrity of the reasoning content"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["_id", "metadata", "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

orq_ai_sdk/models/refusalpartschema.py

@@ -1,7 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
 from typing import Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
@@ -27,3 +28,19 @@ class RefusalPartSchema(BaseModel):
 
     refusal: Optional[str] = None
     r"""The refusal message generated by the model."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["refusal"])
+        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

orq_ai_sdk/models/remoteconfigsgetconfigop.py

@@ -1,7 +1,8 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
+from pydantic import model_serializer
 from typing import Any, Dict, Literal, Optional
 from typing_extensions import NotRequired, TypedDict
 
@@ -25,6 +26,22 @@ class RemoteConfigsGetConfigRequestBody(BaseModel):
     metadata: Optional[Dict[str, Any]] = None
     r"""Key-value pairs to attach to the log generated by this request."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["context", "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
+
 
 RemoteConfigsGetConfigType = Literal[
     "boolean",
@@ -53,3 +70,19 @@ class RemoteConfigsGetConfigResponseBody(BaseModel):
     r"""The return type of the rule"""
 
     value: Optional[Any] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["value"])
+        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

orq_ai_sdk/models/responsedoneevent.py

@@ -17,7 +17,7 @@ from typing_extensions import Annotated, NotRequired, TypedDict
 ResponseDoneEventType = Literal["response.done",]
 
 
-FinishReason = Literal[
+ResponseDoneEventFinishReason = Literal[
     "stop",
     "length",
     "tool_calls",
@@ -46,31 +46,30 @@ class ResponseDoneEventPromptTokensDetails(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
 
@@ -95,41 +94,40 @@ class ResponseDoneEventCompletionTokensDetails(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
 
@@ -173,37 +171,34 @@ class ResponseDoneEventUsage(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
 
@@ -211,58 +206,93 @@ class ResponseDoneEventUsage(BaseModel):
 ResponseDoneEventDataType = Literal["function",]
 
 
-class FunctionTypedDict(TypedDict):
+class ResponseDoneEventFunctionTypedDict(TypedDict):
     name: NotRequired[str]
     r"""The name of the function to call"""
     arguments: NotRequired[str]
     r"""The arguments to pass to the function as JSON string"""
 
 
-class Function(BaseModel):
+class ResponseDoneEventFunction(BaseModel):
     name: Optional[str] = None
     r"""The name of the function to call"""
 
     arguments: Optional[str] = None
     r"""The arguments to pass to the function as JSON string"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["name", "arguments"])
+        serialized = handler(self)
+        m = {}
 
-class PendingToolCallsTypedDict(TypedDict):
+        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 ResponseDoneEventPendingToolCallsTypedDict(TypedDict):
     id: str
     r"""Unique identifier for the tool call"""
     type: ResponseDoneEventDataType
-    function: FunctionTypedDict
+    function: ResponseDoneEventFunctionTypedDict
 
 
-class PendingToolCalls(BaseModel):
+class ResponseDoneEventPendingToolCalls(BaseModel):
     id: str
     r"""Unique identifier for the tool call"""
 
     type: ResponseDoneEventDataType
 
-    function: Function
+    function: ResponseDoneEventFunction
 
 
 class ResponseDoneEventDataTypedDict(TypedDict):
-    finish_reason: FinishReason
+    finish_reason: ResponseDoneEventFinishReason
     r"""The reason why the agent stopped generating"""
     usage: NotRequired[ResponseDoneEventUsageTypedDict]
     r"""Token usage statistics for the complete response"""
-    pending_tool_calls: NotRequired[List[PendingToolCallsTypedDict]]
+    pending_tool_calls: NotRequired[List[ResponseDoneEventPendingToolCallsTypedDict]]
     r"""Tool calls awaiting user response (when finishReason is function_call)"""
 
 
 class ResponseDoneEventData(BaseModel):
-    finish_reason: Annotated[FinishReason, pydantic.Field(alias="finishReason")]
+    finish_reason: Annotated[
+        ResponseDoneEventFinishReason, pydantic.Field(alias="finishReason")
+    ]
     r"""The reason why the agent stopped generating"""
 
     usage: Optional[ResponseDoneEventUsage] = None
     r"""Token usage statistics for the complete response"""
 
     pending_tool_calls: Annotated[
-        Optional[List[PendingToolCalls]], pydantic.Field(alias="pendingToolCalls")
+        Optional[List[ResponseDoneEventPendingToolCalls]],
+        pydantic.Field(alias="pendingToolCalls"),
     ] = None
     r"""Tool calls awaiting user response (when finishReason is function_call)"""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["usage", "pendingToolCalls"])
+        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 ResponseDoneEventTypedDict(TypedDict):
     r"""Emitted when the agent completes processing. Contains the finish reason and usage statistics."""

orq_ai_sdk/models/responsestartedevent.py

@@ -1,8 +1,9 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
-from orq_ai_sdk.types import BaseModel
+from orq_ai_sdk.types import BaseModel, UNSET_SENTINEL
 import pydantic
+from pydantic import model_serializer
 from typing import Literal, Optional
 from typing_extensions import Annotated, NotRequired, TypedDict
 
@@ -54,6 +55,22 @@ class Data(BaseModel):
     ] = None
     r"""Server-generated ID for the assistant message. Use this ID for frontend state consistency."""
 
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["userMessageId", "assistantMessageId"])
+        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 ResponseStartedEventTypedDict(TypedDict):
     r"""Emitted when the agent begins processing. Contains identifiers for tracking the response."""