orq-ai-sdk 4.2.17__py3-none-any.whl → 4.3.0rc0__py3-none-any.whl

orq_ai_sdk/models/creatererankop.py

@@ -26,41 +26,6 @@ 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",]
 
 
@@ -97,120 +62,7 @@ class CreateRerankCache(BaseModel):
         return m
 
 
-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):
+class CreateRerankRetryTypedDict(TypedDict):
     r"""Retry configuration for the request"""
 
     count: NotRequired[float]
@@ -219,7 +71,7 @@ class CreateRerankRouterRerankRetryTypedDict(TypedDict):
     r"""HTTP status codes that trigger retry logic"""
 
 
-class CreateRerankRouterRerankRetry(BaseModel):
+class CreateRerankRetry(BaseModel):
     r"""Retry configuration for the request"""
 
     count: Optional[float] = 3
@@ -245,17 +97,17 @@ class CreateRerankRouterRerankRetry(BaseModel):
         return m
 
 
-CreateRerankLoadBalancerRouterRerankType = Literal["weight_based",]
+CreateRerankLoadBalancerType = Literal["weight_based",]
 
 
-class CreateRerankLoadBalancerRouterRerankModelsTypedDict(TypedDict):
+class CreateRerankLoadBalancerModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class CreateRerankLoadBalancerRouterRerankModels(BaseModel):
+class CreateRerankLoadBalancerModels(BaseModel):
     model: str
     r"""Model identifier for load balancing"""
 
@@ -279,35 +131,33 @@ class CreateRerankLoadBalancerRouterRerankModels(BaseModel):
         return m
 
 
-class CreateRerankLoadBalancerRouterRerank1TypedDict(TypedDict):
-    type: CreateRerankLoadBalancerRouterRerankType
-    models: List[CreateRerankLoadBalancerRouterRerankModelsTypedDict]
+class CreateRerankLoadBalancer1TypedDict(TypedDict):
+    type: CreateRerankLoadBalancerType
+    models: List[CreateRerankLoadBalancerModelsTypedDict]
 
 
-class CreateRerankLoadBalancerRouterRerank1(BaseModel):
-    type: CreateRerankLoadBalancerRouterRerankType
+class CreateRerankLoadBalancer1(BaseModel):
+    type: CreateRerankLoadBalancerType
 
-    models: List[CreateRerankLoadBalancerRouterRerankModels]
+    models: List[CreateRerankLoadBalancerModels]
 
 
-CreateRerankRouterRerankLoadBalancerTypedDict = (
-    CreateRerankLoadBalancerRouterRerank1TypedDict
-)
+CreateRerankLoadBalancerTypedDict = CreateRerankLoadBalancer1TypedDict
 r"""Array of models with weights for load balancing requests"""
 
 
-CreateRerankRouterRerankLoadBalancer = CreateRerankLoadBalancerRouterRerank1
+CreateRerankLoadBalancer = CreateRerankLoadBalancer1
 r"""Array of models with weights for load balancing requests"""
 
 
-class CreateRerankRouterRerankTimeoutTypedDict(TypedDict):
+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 CreateRerankRouterRerankTimeout(BaseModel):
+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
@@ -317,19 +167,19 @@ class CreateRerankRouterRerankTimeout(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[CreateRerankRouterRerankFallbacksTypedDict]]
+    fallbacks: NotRequired[List[CreateRerankFallbacksTypedDict]]
     r"""Array of fallback models to use if primary model fails"""
-    cache: NotRequired[CreateRerankRouterRerankCacheTypedDict]
+    cache: NotRequired[CreateRerankCacheTypedDict]
     r"""Cache configuration for the request."""
-    retry: NotRequired[CreateRerankRouterRerankRetryTypedDict]
+    retry: NotRequired[CreateRerankRetryTypedDict]
     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[CreateRerankRouterRerankLoadBalancerTypedDict]
+    load_balancer: NotRequired[CreateRerankLoadBalancerTypedDict]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[CreateRerankRouterRerankTimeoutTypedDict]
+    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."""
 
 
@@ -337,13 +187,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[CreateRerankRouterRerankFallbacks]] = None
+    fallbacks: Optional[List[CreateRerankFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
-    cache: Optional[CreateRerankRouterRerankCache] = None
+    cache: Optional[CreateRerankCache] = None
     r"""Cache configuration for the request."""
 
-    retry: Optional[CreateRerankRouterRerankRetry] = None
+    retry: Optional[CreateRerankRetry] = None
     r"""Retry configuration for the request"""
 
     identity: Optional[PublicIdentity] = None
@@ -357,10 +207,10 @@ class CreateRerankOrq(BaseModel):
     ] = None
     r"""@deprecated Use identity instead. Information about the contact making the request."""
 
-    load_balancer: Optional[CreateRerankRouterRerankLoadBalancer] = None
+    load_balancer: Optional[CreateRerankLoadBalancer] = None
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[CreateRerankRouterRerankTimeout] = None
+    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."""
 
     @model_serializer(mode="wrap")
@@ -404,18 +254,6 @@ 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]
 
 
@@ -437,41 +275,11 @@ 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",
-                "name",
-                "fallbacks",
-                "retry",
-                "cache",
-                "load_balancer",
-                "timeout",
-                "orq",
-            ]
-        )
+        optional_fields = set(["top_n", "filename", "orq"])
         nullable_fields = set(["filename"])
         serialized = handler(self)
         m = {}

orq_ai_sdk/models/createspeechop.py

@@ -21,16 +21,6 @@ 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"""
 
@@ -66,114 +56,12 @@ class CreateSpeechRetry(BaseModel):
         return m
 
 
-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):
+class CreateSpeechFallbacksTypedDict(TypedDict):
     model: str
     r"""Fallback model identifier"""
 
 
-class CreateSpeechRouterAudioSpeechFallbacks(BaseModel):
+class CreateSpeechFallbacks(BaseModel):
     model: str
     r"""Fallback model identifier"""
 
@@ -213,17 +101,17 @@ class CreateSpeechThread(BaseModel):
         return m
 
 
-CreateSpeechLoadBalancerRouterAudioSpeechType = Literal["weight_based",]
+CreateSpeechLoadBalancerType = Literal["weight_based",]
 
 
-class CreateSpeechLoadBalancerRouterAudioSpeechModelsTypedDict(TypedDict):
+class CreateSpeechLoadBalancerModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class CreateSpeechLoadBalancerRouterAudioSpeechModels(BaseModel):
+class CreateSpeechLoadBalancerModels(BaseModel):
     model: str
     r"""Model identifier for load balancing"""
 
@@ -247,35 +135,33 @@ class CreateSpeechLoadBalancerRouterAudioSpeechModels(BaseModel):
         return m
 
 
-class CreateSpeechLoadBalancerRouterAudioSpeech1TypedDict(TypedDict):
-    type: CreateSpeechLoadBalancerRouterAudioSpeechType
-    models: List[CreateSpeechLoadBalancerRouterAudioSpeechModelsTypedDict]
+class CreateSpeechLoadBalancer1TypedDict(TypedDict):
+    type: CreateSpeechLoadBalancerType
+    models: List[CreateSpeechLoadBalancerModelsTypedDict]
 
 
-class CreateSpeechLoadBalancerRouterAudioSpeech1(BaseModel):
-    type: CreateSpeechLoadBalancerRouterAudioSpeechType
+class CreateSpeechLoadBalancer1(BaseModel):
+    type: CreateSpeechLoadBalancerType
 
-    models: List[CreateSpeechLoadBalancerRouterAudioSpeechModels]
+    models: List[CreateSpeechLoadBalancerModels]
 
 
-CreateSpeechRouterAudioSpeechLoadBalancerTypedDict = (
-    CreateSpeechLoadBalancerRouterAudioSpeech1TypedDict
-)
+CreateSpeechLoadBalancerTypedDict = CreateSpeechLoadBalancer1TypedDict
 r"""Array of models with weights for load balancing requests"""
 
 
-CreateSpeechRouterAudioSpeechLoadBalancer = CreateSpeechLoadBalancerRouterAudioSpeech1
+CreateSpeechLoadBalancer = CreateSpeechLoadBalancer1
 r"""Array of models with weights for load balancing requests"""
 
 
-class CreateSpeechRouterAudioSpeechTimeoutTypedDict(TypedDict):
+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 CreateSpeechRouterAudioSpeechTimeout(BaseModel):
+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
@@ -283,9 +169,9 @@ class CreateSpeechRouterAudioSpeechTimeout(BaseModel):
 
 
 class CreateSpeechOrqTypedDict(TypedDict):
-    retry: NotRequired[CreateSpeechRouterAudioSpeechRetryTypedDict]
+    retry: NotRequired[CreateSpeechRetryTypedDict]
     r"""Retry configuration for the request"""
-    fallbacks: NotRequired[List[CreateSpeechRouterAudioSpeechFallbacksTypedDict]]
+    fallbacks: NotRequired[List[CreateSpeechFallbacksTypedDict]]
     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."""
@@ -295,17 +181,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[CreateSpeechRouterAudioSpeechLoadBalancerTypedDict]
+    load_balancer: NotRequired[CreateSpeechLoadBalancerTypedDict]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[CreateSpeechRouterAudioSpeechTimeoutTypedDict]
+    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."""
 
 
 class CreateSpeechOrq(BaseModel):
-    retry: Optional[CreateSpeechRouterAudioSpeechRetry] = None
+    retry: Optional[CreateSpeechRetry] = None
     r"""Retry configuration for the request"""
 
-    fallbacks: Optional[List[CreateSpeechRouterAudioSpeechFallbacks]] = None
+    fallbacks: Optional[List[CreateSpeechFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
     name: Optional[str] = None
@@ -325,10 +211,10 @@ class CreateSpeechOrq(BaseModel):
     thread: Optional[CreateSpeechThread] = None
     r"""Thread information to group related requests"""
 
-    load_balancer: Optional[CreateSpeechRouterAudioSpeechLoadBalancer] = None
+    load_balancer: Optional[CreateSpeechLoadBalancer] = None
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[CreateSpeechRouterAudioSpeechTimeout] = None
+    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."""
 
     @model_serializer(mode="wrap")
@@ -381,16 +267,6 @@ 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]
 
 
@@ -421,37 +297,11 @@ 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",
-                "name",
-                "fallbacks",
-                "retry",
-                "load_balancer",
-                "timeout",
-                "orq",
-            ]
-        )
+        optional_fields = set(["response_format", "speed", "orq"])
         serialized = handler(self)
         m = {}