orq-ai-sdk 4.2.8__py3-none-any.whl → 4.2.9__py3-none-any.whl

orq_ai_sdk/models/creatererankop.py

@@ -26,6 +26,41 @@ class CreateRerankFallbacks(BaseModel):
     r"""Fallback model identifier"""
 
 
+class CreateRerankRetryTypedDict(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 CreateRerankRetry(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
+
+
 CreateRerankType = Literal["exact_match",]
 
 
@@ -62,7 +97,120 @@ class CreateRerankCache(BaseModel):
         return m
 
 
-class CreateRerankRetryTypedDict(TypedDict):
+CreateRerankLoadBalancerType = Literal["weight_based",]
+
+
+class CreateRerankLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreateRerankLoadBalancerModels(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 CreateRerankLoadBalancer1TypedDict(TypedDict):
+    type: CreateRerankLoadBalancerType
+    models: List[CreateRerankLoadBalancerModelsTypedDict]
+
+
+class CreateRerankLoadBalancer1(BaseModel):
+    type: CreateRerankLoadBalancerType
+
+    models: List[CreateRerankLoadBalancerModels]
+
+
+CreateRerankLoadBalancerTypedDict = CreateRerankLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreateRerankLoadBalancer = CreateRerankLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class CreateRerankTimeoutTypedDict(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 CreateRerankTimeout(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 CreateRerankRouterRerankFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreateRerankRouterRerankFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+CreateRerankRouterRerankType = Literal["exact_match",]
+
+
+class CreateRerankRouterRerankCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreateRerankRouterRerankType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreateRerankRouterRerankCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: CreateRerankRouterRerankType
+
+    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
+
+
+class CreateRerankRouterRerankRetryTypedDict(TypedDict):
     r"""Retry configuration for the request"""
 
     count: NotRequired[float]
@@ -71,7 +219,7 @@ class CreateRerankRetryTypedDict(TypedDict):
     r"""HTTP status codes that trigger retry logic"""
 
 
-class CreateRerankRetry(BaseModel):
+class CreateRerankRouterRerankRetry(BaseModel):
     r"""Retry configuration for the request"""
 
     count: Optional[float] = 3
@@ -97,17 +245,17 @@ class CreateRerankRetry(BaseModel):
         return m
 
 
-CreateRerankLoadBalancerType = Literal["weight_based",]
+CreateRerankLoadBalancerRouterRerankType = Literal["weight_based",]
 
 
-class CreateRerankLoadBalancerModelsTypedDict(TypedDict):
+class CreateRerankLoadBalancerRouterRerankModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class CreateRerankLoadBalancerModels(BaseModel):
+class CreateRerankLoadBalancerRouterRerankModels(BaseModel):
     model: str
     r"""Model identifier for load balancing"""
 
@@ -131,33 +279,35 @@ class CreateRerankLoadBalancerModels(BaseModel):
         return m
 
 
-class CreateRerankLoadBalancer1TypedDict(TypedDict):
-    type: CreateRerankLoadBalancerType
-    models: List[CreateRerankLoadBalancerModelsTypedDict]
+class CreateRerankLoadBalancerRouterRerank1TypedDict(TypedDict):
+    type: CreateRerankLoadBalancerRouterRerankType
+    models: List[CreateRerankLoadBalancerRouterRerankModelsTypedDict]
 
 
-class CreateRerankLoadBalancer1(BaseModel):
-    type: CreateRerankLoadBalancerType
+class CreateRerankLoadBalancerRouterRerank1(BaseModel):
+    type: CreateRerankLoadBalancerRouterRerankType
 
-    models: List[CreateRerankLoadBalancerModels]
+    models: List[CreateRerankLoadBalancerRouterRerankModels]
 
 
-CreateRerankLoadBalancerTypedDict = CreateRerankLoadBalancer1TypedDict
+CreateRerankRouterRerankLoadBalancerTypedDict = (
+    CreateRerankLoadBalancerRouterRerank1TypedDict
+)
 r"""Array of models with weights for load balancing requests"""
 
 
-CreateRerankLoadBalancer = CreateRerankLoadBalancer1
+CreateRerankRouterRerankLoadBalancer = CreateRerankLoadBalancerRouterRerank1
 r"""Array of models with weights for load balancing requests"""
 
 
-class CreateRerankTimeoutTypedDict(TypedDict):
+class CreateRerankRouterRerankTimeoutTypedDict(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 CreateRerankTimeout(BaseModel):
+class CreateRerankRouterRerankTimeout(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
@@ -167,19 +317,19 @@ class CreateRerankTimeout(BaseModel):
 class CreateRerankOrqTypedDict(TypedDict):
     name: NotRequired[str]
     r"""The name to display on the trace. If not specified, the default system name will be used."""
-    fallbacks: NotRequired[List[CreateRerankFallbacksTypedDict]]
+    fallbacks: NotRequired[List[CreateRerankRouterRerankFallbacksTypedDict]]
     r"""Array of fallback models to use if primary model fails"""
-    cache: NotRequired[CreateRerankCacheTypedDict]
+    cache: NotRequired[CreateRerankRouterRerankCacheTypedDict]
     r"""Cache configuration for the request."""
-    retry: NotRequired[CreateRerankRetryTypedDict]
+    retry: NotRequired[CreateRerankRouterRerankRetryTypedDict]
     r"""Retry configuration for the request"""
     identity: NotRequired[PublicIdentityTypedDict]
     r"""Information about the identity making the request. If the identity does not exist, it will be created automatically."""
     contact: NotRequired[PublicContactTypedDict]
     r"""@deprecated Use identity instead. Information about the contact making the request."""
-    load_balancer: NotRequired[CreateRerankLoadBalancerTypedDict]
+    load_balancer: NotRequired[CreateRerankRouterRerankLoadBalancerTypedDict]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[CreateRerankTimeoutTypedDict]
+    timeout: NotRequired[CreateRerankRouterRerankTimeoutTypedDict]
     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."""
 
 
@@ -187,13 +337,13 @@ class CreateRerankOrq(BaseModel):
     name: Optional[str] = None
     r"""The name to display on the trace. If not specified, the default system name will be used."""
 
-    fallbacks: Optional[List[CreateRerankFallbacks]] = None
+    fallbacks: Optional[List[CreateRerankRouterRerankFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
-    cache: Optional[CreateRerankCache] = None
+    cache: Optional[CreateRerankRouterRerankCache] = None
     r"""Cache configuration for the request."""
 
-    retry: Optional[CreateRerankRetry] = None
+    retry: Optional[CreateRerankRouterRerankRetry] = None
     r"""Retry configuration for the request"""
 
     identity: Optional[PublicIdentity] = None
@@ -207,10 +357,10 @@ class CreateRerankOrq(BaseModel):
     ] = None
     r"""@deprecated Use identity instead. Information about the contact making the request."""
 
-    load_balancer: Optional[CreateRerankLoadBalancer] = None
+    load_balancer: Optional[CreateRerankRouterRerankLoadBalancer] = None
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[CreateRerankTimeout] = None
+    timeout: Optional[CreateRerankRouterRerankTimeout] = 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")
@@ -254,6 +404,18 @@ class CreateRerankRequestBodyTypedDict(TypedDict):
     r"""The number of most relevant documents or indices to return, defaults to the length of the documents"""
     filename: NotRequired[Nullable[str]]
     r"""The filename of the document to rerank"""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+    fallbacks: NotRequired[List[CreateRerankFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreateRerankRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreateRerankCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreateRerankLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreateRerankTimeoutTypedDict]
+    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[CreateRerankOrqTypedDict]
 
 
@@ -275,11 +437,41 @@ class CreateRerankRequestBody(BaseModel):
     filename: OptionalNullable[str] = UNSET
     r"""The filename of the document to rerank"""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
+    fallbacks: Optional[List[CreateRerankFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreateRerankRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreateRerankCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreateRerankLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreateRerankTimeout] = 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: Optional[CreateRerankOrq] = None
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["top_n", "filename", "orq"])
+        optional_fields = set(
+            [
+                "top_n",
+                "filename",
+                "name",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
+                "orq",
+            ]
+        )
         nullable_fields = set(["filename"])
         serialized = handler(self)
         m = {}

orq_ai_sdk/models/createspeechop.py

@@ -21,6 +21,16 @@ CreateSpeechResponseFormat = Literal[
 r"""The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`, `wav`, and `pcm`. If a format is provided but not supported by the provider, the response will be in the default format. When the provided format is not supported by the provider, the response will be in the default format."""
 
 
+class CreateSpeechFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreateSpeechFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
 class CreateSpeechRetryTypedDict(TypedDict):
     r"""Retry configuration for the request"""
 
@@ -56,12 +66,114 @@ class CreateSpeechRetry(BaseModel):
         return m
 
 
-class CreateSpeechFallbacksTypedDict(TypedDict):
+CreateSpeechLoadBalancerType = Literal["weight_based",]
+
+
+class CreateSpeechLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreateSpeechLoadBalancerModels(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 CreateSpeechLoadBalancer1TypedDict(TypedDict):
+    type: CreateSpeechLoadBalancerType
+    models: List[CreateSpeechLoadBalancerModelsTypedDict]
+
+
+class CreateSpeechLoadBalancer1(BaseModel):
+    type: CreateSpeechLoadBalancerType
+
+    models: List[CreateSpeechLoadBalancerModels]
+
+
+CreateSpeechLoadBalancerTypedDict = CreateSpeechLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreateSpeechLoadBalancer = CreateSpeechLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class CreateSpeechTimeoutTypedDict(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 CreateSpeechTimeout(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 CreateSpeechRouterAudioSpeechRetryTypedDict(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 CreateSpeechRouterAudioSpeechRetry(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 CreateSpeechRouterAudioSpeechFallbacksTypedDict(TypedDict):
     model: str
     r"""Fallback model identifier"""
 
 
-class CreateSpeechFallbacks(BaseModel):
+class CreateSpeechRouterAudioSpeechFallbacks(BaseModel):
     model: str
     r"""Fallback model identifier"""
 
@@ -101,17 +213,17 @@ class CreateSpeechThread(BaseModel):
         return m
 
 
-CreateSpeechLoadBalancerType = Literal["weight_based",]
+CreateSpeechLoadBalancerRouterAudioSpeechType = Literal["weight_based",]
 
 
-class CreateSpeechLoadBalancerModelsTypedDict(TypedDict):
+class CreateSpeechLoadBalancerRouterAudioSpeechModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class CreateSpeechLoadBalancerModels(BaseModel):
+class CreateSpeechLoadBalancerRouterAudioSpeechModels(BaseModel):
     model: str
     r"""Model identifier for load balancing"""
 
@@ -135,33 +247,35 @@ class CreateSpeechLoadBalancerModels(BaseModel):
         return m
 
 
-class CreateSpeechLoadBalancer1TypedDict(TypedDict):
-    type: CreateSpeechLoadBalancerType
-    models: List[CreateSpeechLoadBalancerModelsTypedDict]
+class CreateSpeechLoadBalancerRouterAudioSpeech1TypedDict(TypedDict):
+    type: CreateSpeechLoadBalancerRouterAudioSpeechType
+    models: List[CreateSpeechLoadBalancerRouterAudioSpeechModelsTypedDict]
 
 
-class CreateSpeechLoadBalancer1(BaseModel):
-    type: CreateSpeechLoadBalancerType
+class CreateSpeechLoadBalancerRouterAudioSpeech1(BaseModel):
+    type: CreateSpeechLoadBalancerRouterAudioSpeechType
 
-    models: List[CreateSpeechLoadBalancerModels]
+    models: List[CreateSpeechLoadBalancerRouterAudioSpeechModels]
 
 
-CreateSpeechLoadBalancerTypedDict = CreateSpeechLoadBalancer1TypedDict
+CreateSpeechRouterAudioSpeechLoadBalancerTypedDict = (
+    CreateSpeechLoadBalancerRouterAudioSpeech1TypedDict
+)
 r"""Array of models with weights for load balancing requests"""
 
 
-CreateSpeechLoadBalancer = CreateSpeechLoadBalancer1
+CreateSpeechRouterAudioSpeechLoadBalancer = CreateSpeechLoadBalancerRouterAudioSpeech1
 r"""Array of models with weights for load balancing requests"""
 
 
-class CreateSpeechTimeoutTypedDict(TypedDict):
+class CreateSpeechRouterAudioSpeechTimeoutTypedDict(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 CreateSpeechTimeout(BaseModel):
+class CreateSpeechRouterAudioSpeechTimeout(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
@@ -169,9 +283,9 @@ class CreateSpeechTimeout(BaseModel):
 
 
 class CreateSpeechOrqTypedDict(TypedDict):
-    retry: NotRequired[CreateSpeechRetryTypedDict]
+    retry: NotRequired[CreateSpeechRouterAudioSpeechRetryTypedDict]
     r"""Retry configuration for the request"""
-    fallbacks: NotRequired[List[CreateSpeechFallbacksTypedDict]]
+    fallbacks: NotRequired[List[CreateSpeechRouterAudioSpeechFallbacksTypedDict]]
     r"""Array of fallback models to use if primary model fails"""
     name: NotRequired[str]
     r"""The name to display on the trace. If not specified, the default system name will be used."""
@@ -181,17 +295,17 @@ class CreateSpeechOrqTypedDict(TypedDict):
     r"""@deprecated Use identity instead. Information about the contact making the request."""
     thread: NotRequired[CreateSpeechThreadTypedDict]
     r"""Thread information to group related requests"""
-    load_balancer: NotRequired[CreateSpeechLoadBalancerTypedDict]
+    load_balancer: NotRequired[CreateSpeechRouterAudioSpeechLoadBalancerTypedDict]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[CreateSpeechTimeoutTypedDict]
+    timeout: NotRequired[CreateSpeechRouterAudioSpeechTimeoutTypedDict]
     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."""
 
 
 class CreateSpeechOrq(BaseModel):
-    retry: Optional[CreateSpeechRetry] = None
+    retry: Optional[CreateSpeechRouterAudioSpeechRetry] = None
     r"""Retry configuration for the request"""
 
-    fallbacks: Optional[List[CreateSpeechFallbacks]] = None
+    fallbacks: Optional[List[CreateSpeechRouterAudioSpeechFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
     name: Optional[str] = None
@@ -211,10 +325,10 @@ class CreateSpeechOrq(BaseModel):
     thread: Optional[CreateSpeechThread] = None
     r"""Thread information to group related requests"""
 
-    load_balancer: Optional[CreateSpeechLoadBalancer] = None
+    load_balancer: Optional[CreateSpeechRouterAudioSpeechLoadBalancer] = None
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[CreateSpeechTimeout] = None
+    timeout: Optional[CreateSpeechRouterAudioSpeechTimeout] = 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")
@@ -267,6 +381,16 @@ class CreateSpeechRequestBodyTypedDict(TypedDict):
     r"""The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`, `wav`, and `pcm`. If a format is provided but not supported by the provider, the response will be in the default format. When the provided format is not supported by the provider, the response will be in the default format."""
     speed: NotRequired[float]
     r"""The speed of the generated audio."""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+    fallbacks: NotRequired[List[CreateSpeechFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreateSpeechRetryTypedDict]
+    r"""Retry configuration for the request"""
+    load_balancer: NotRequired[CreateSpeechLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreateSpeechTimeoutTypedDict]
+    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[CreateSpeechOrqTypedDict]
 
 
@@ -297,11 +421,37 @@ class CreateSpeechRequestBody(BaseModel):
     speed: Optional[float] = 1
     r"""The speed of the generated audio."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
+    fallbacks: Optional[List[CreateSpeechFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreateSpeechRetry] = None
+    r"""Retry configuration for the request"""
+
+    load_balancer: Optional[CreateSpeechLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreateSpeechTimeout] = 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: Optional[CreateSpeechOrq] = None
 
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = set(["response_format", "speed", "orq"])
+        optional_fields = set(
+            [
+                "response_format",
+                "speed",
+                "name",
+                "fallbacks",
+                "retry",
+                "load_balancer",
+                "timeout",
+                "orq",
+            ]
+        )
         serialized = handler(self)
         m = {}