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

orq_ai_sdk/models/conversationresponse.py

@@ -104,7 +104,7 @@ class ConversationResponse(BaseModel):
     r"""Unix timestamp in milliseconds when the conversation was last modified."""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "conv_01kfvjh98xpq7txy94b17s96kw"
+        "conv_01kfx9bgb1839ewgg9511964xe"
     )
     r"""Unique conversation identifier with `conv_` prefix."""
 

orq_ai_sdk/models/conversationwithmessagesresponse.py

@@ -110,7 +110,7 @@ class ConversationWithMessagesResponse(BaseModel):
     r"""Conversation messages ordered chronologically (oldest first)."""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "conv_01kfvjh992xegc77y1g4epck6h"
+        "conv_01kfx9bgb74064wnw21p55gase"
     )
     r"""Unique conversation identifier with `conv_` prefix."""
 

orq_ai_sdk/models/createagentrequestop.py

@@ -511,6 +511,8 @@ class Timeout(BaseModel):
 class ParametersTypedDict(TypedDict):
     r"""Model behavior parameters that control how the model generates responses. Common parameters: `temperature` (0-1, randomness), `max_completion_tokens` (max output length), `top_p` (sampling diversity). Advanced: `frequency_penalty`, `presence_penalty`, `response_format` (JSON/structured), `reasoning_effort`, `seed` (reproducibility). Support varies by model - consult AI Gateway documentation."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[ModelConfigurationAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -582,6 +584,9 @@ class ParametersTypedDict(TypedDict):
 class Parameters(BaseModel):
     r"""Model behavior parameters that control how the model generates responses. Common parameters: `temperature` (0-1, randomness), `max_completion_tokens` (max output length), `top_p` (sampling diversity). Advanced: `frequency_penalty`, `presence_penalty`, `response_format` (JSON/structured), `reasoning_effort`, `seed` (reproducibility). Support varies by model - consult AI Gateway documentation."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[ModelConfigurationAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -677,6 +682,7 @@ class Parameters(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -1348,6 +1354,8 @@ class FallbackModelConfigurationTimeout(BaseModel):
 class FallbackModelConfigurationParametersTypedDict(TypedDict):
     r"""Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[FallbackModelConfigurationAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -1419,6 +1427,9 @@ class FallbackModelConfigurationParametersTypedDict(TypedDict):
 class FallbackModelConfigurationParameters(BaseModel):
     r"""Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[FallbackModelConfigurationAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -1514,6 +1525,7 @@ class FallbackModelConfigurationParameters(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -3496,6 +3508,8 @@ class CreateAgentRequestTimeout(BaseModel):
 class CreateAgentRequestParametersTypedDict(TypedDict):
     r"""Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[CreateAgentRequestAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -3565,6 +3579,9 @@ class CreateAgentRequestParametersTypedDict(TypedDict):
 class CreateAgentRequestParameters(BaseModel):
     r"""Model behavior parameters (snake_case) stored as part of the agent configuration. These become the default parameters used when the agent is executed. Commonly used: temperature (0-1, controls randomness), max_completion_tokens (response length), top_p (nucleus sampling). Advanced: frequency_penalty, presence_penalty, response_format (JSON/structured output), reasoning_effort (for o1/thinking models), seed (reproducibility), stop sequences. Model-specific support varies. Runtime parameters in agent execution requests can override these defaults."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[CreateAgentRequestAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -3660,6 +3677,7 @@ class CreateAgentRequestParameters(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -4309,6 +4327,8 @@ class CreateAgentRequestFallbackModelConfigurationTimeout(BaseModel):
 class CreateAgentRequestFallbackModelConfigurationParametersTypedDict(TypedDict):
     r"""Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[
         Nullable[CreateAgentRequestFallbackModelConfigurationAudioTypedDict]
     ]
@@ -4400,6 +4420,9 @@ class CreateAgentRequestFallbackModelConfigurationParametersTypedDict(TypedDict)
 class CreateAgentRequestFallbackModelConfigurationParameters(BaseModel):
     r"""Optional model parameters specific to this fallback model. Overrides primary model parameters if this fallback is used."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[CreateAgentRequestFallbackModelConfigurationAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -4511,6 +4534,7 @@ class CreateAgentRequestFallbackModelConfigurationParameters(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",

orq_ai_sdk/models/createchatcompletionop.py

@@ -2468,6 +2468,8 @@ class CreateChatCompletionRequestBodyTypedDict(TypedDict):
     r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-haiku-4-5-20251001`. The AI Gateway offers a wide range of models with different capabilities, performance characteristics, and price points. Refer to the (Supported models)[/docs/proxy/supported-models] to browse available models."""
     metadata: NotRequired[Dict[str, str]]
     r"""Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format. Keys can have a maximum length of 64 characters and values can have a maximum length of 512 characters."""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[CreateChatCompletionAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -2549,6 +2551,9 @@ class CreateChatCompletionRequestBody(BaseModel):
     metadata: Optional[Dict[str, str]] = None
     r"""Set of 16 key-value pairs that can be attached to an object. This can be useful for storing additional information about the object in a structured format. Keys can have a maximum length of 64 characters and values can have a maximum length of 512 characters."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[CreateChatCompletionAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -2658,6 +2663,7 @@ class CreateChatCompletionRequestBody(BaseModel):
         optional_fields = set(
             [
                 "metadata",
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",

orq_ai_sdk/models/createcompletionop.py

@@ -33,6 +33,16 @@ CreateCompletionStop = TypeAliasType("CreateCompletionStop", Union[str, List[str
 r"""Up to 4 sequences where the API will stop generating further tokens. The returned text will not contain the stop sequence."""
 
 
+class CreateCompletionFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreateCompletionFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
 class CreateCompletionRetryTypedDict(TypedDict):
     r"""Retry configuration for the request"""
 
@@ -68,12 +78,150 @@ class CreateCompletionRetry(BaseModel):
         return m
 
 
-class CreateCompletionFallbacksTypedDict(TypedDict):
+CreateCompletionType = Literal["exact_match",]
+
+
+class CreateCompletionCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreateCompletionType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreateCompletionCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: CreateCompletionType
+
+    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
+
+
+CreateCompletionLoadBalancerType = Literal["weight_based",]
+
+
+class CreateCompletionLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreateCompletionLoadBalancerModels(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 CreateCompletionLoadBalancer1TypedDict(TypedDict):
+    type: CreateCompletionLoadBalancerType
+    models: List[CreateCompletionLoadBalancerModelsTypedDict]
+
+
+class CreateCompletionLoadBalancer1(BaseModel):
+    type: CreateCompletionLoadBalancerType
+
+    models: List[CreateCompletionLoadBalancerModels]
+
+
+CreateCompletionLoadBalancerTypedDict = CreateCompletionLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreateCompletionLoadBalancer = CreateCompletionLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class CreateCompletionTimeoutTypedDict(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 CreateCompletionTimeout(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 CreateCompletionRouterCompletionsRetryTypedDict(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 CreateCompletionRouterCompletionsRetry(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 CreateCompletionRouterCompletionsFallbacksTypedDict(TypedDict):
     model: str
     r"""Fallback model identifier"""
 
 
-class CreateCompletionFallbacks(BaseModel):
+class CreateCompletionRouterCompletionsFallbacks(BaseModel):
     model: str
     r"""Fallback model identifier"""
 
@@ -179,21 +327,21 @@ CreateCompletionInputs = TypeAliasType(
 r"""Values to replace in the prompt messages using {{variableName}} syntax"""
 
 
-CreateCompletionType = Literal["exact_match",]
+CreateCompletionRouterCompletionsType = Literal["exact_match",]
 
 
-class CreateCompletionCacheTypedDict(TypedDict):
+class CreateCompletionRouterCompletionsCacheTypedDict(TypedDict):
     r"""Cache configuration for the request."""
 
-    type: CreateCompletionType
+    type: CreateCompletionRouterCompletionsType
     ttl: NotRequired[float]
     r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
 
 
-class CreateCompletionCache(BaseModel):
+class CreateCompletionRouterCompletionsCache(BaseModel):
     r"""Cache configuration for the request."""
 
-    type: CreateCompletionType
+    type: CreateCompletionRouterCompletionsType
 
     ttl: Optional[float] = 1800
     r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
@@ -992,17 +1140,17 @@ class CreateCompletionKnowledgeBases(BaseModel):
         return m
 
 
-CreateCompletionLoadBalancerType = Literal["weight_based",]
+CreateCompletionLoadBalancerRouterCompletionsType = Literal["weight_based",]
 
 
-class CreateCompletionLoadBalancerModelsTypedDict(TypedDict):
+class CreateCompletionLoadBalancerRouterCompletionsModelsTypedDict(TypedDict):
     model: str
     r"""Model identifier for load balancing"""
     weight: NotRequired[float]
     r"""Weight assigned to this model for load balancing"""
 
 
-class CreateCompletionLoadBalancerModels(BaseModel):
+class CreateCompletionLoadBalancerRouterCompletionsModels(BaseModel):
     model: str
     r"""Model identifier for load balancing"""
 
@@ -1026,33 +1174,37 @@ class CreateCompletionLoadBalancerModels(BaseModel):
         return m
 
 
-class CreateCompletionLoadBalancer1TypedDict(TypedDict):
-    type: CreateCompletionLoadBalancerType
-    models: List[CreateCompletionLoadBalancerModelsTypedDict]
+class CreateCompletionLoadBalancerRouterCompletions1TypedDict(TypedDict):
+    type: CreateCompletionLoadBalancerRouterCompletionsType
+    models: List[CreateCompletionLoadBalancerRouterCompletionsModelsTypedDict]
 
 
-class CreateCompletionLoadBalancer1(BaseModel):
-    type: CreateCompletionLoadBalancerType
+class CreateCompletionLoadBalancerRouterCompletions1(BaseModel):
+    type: CreateCompletionLoadBalancerRouterCompletionsType
 
-    models: List[CreateCompletionLoadBalancerModels]
+    models: List[CreateCompletionLoadBalancerRouterCompletionsModels]
 
 
-CreateCompletionLoadBalancerTypedDict = CreateCompletionLoadBalancer1TypedDict
+CreateCompletionRouterCompletionsLoadBalancerTypedDict = (
+    CreateCompletionLoadBalancerRouterCompletions1TypedDict
+)
 r"""Array of models with weights for load balancing requests"""
 
 
-CreateCompletionLoadBalancer = CreateCompletionLoadBalancer1
+CreateCompletionRouterCompletionsLoadBalancer = (
+    CreateCompletionLoadBalancerRouterCompletions1
+)
 r"""Array of models with weights for load balancing requests"""
 
 
-class CreateCompletionTimeoutTypedDict(TypedDict):
+class CreateCompletionRouterCompletionsTimeoutTypedDict(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 CreateCompletionTimeout(BaseModel):
+class CreateCompletionRouterCompletionsTimeout(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
@@ -1067,9 +1219,9 @@ class CreateCompletionOrqTypedDict(TypedDict):
 
     name: NotRequired[str]
     r"""The name to display on the trace. If not specified, the default system name will be used."""
-    retry: NotRequired[CreateCompletionRetryTypedDict]
+    retry: NotRequired[CreateCompletionRouterCompletionsRetryTypedDict]
     r"""Retry configuration for the request"""
-    fallbacks: NotRequired[List[CreateCompletionFallbacksTypedDict]]
+    fallbacks: NotRequired[List[CreateCompletionRouterCompletionsFallbacksTypedDict]]
     r"""Array of fallback models to use if primary model fails"""
     prompt: NotRequired[CreateCompletionPromptTypedDict]
     r"""Prompt configuration for the request"""
@@ -1081,12 +1233,12 @@ class CreateCompletionOrqTypedDict(TypedDict):
     r"""Thread information to group related requests"""
     inputs: NotRequired[CreateCompletionInputsTypedDict]
     r"""Values to replace in the prompt messages using {{variableName}} syntax"""
-    cache: NotRequired[CreateCompletionCacheTypedDict]
+    cache: NotRequired[CreateCompletionRouterCompletionsCacheTypedDict]
     r"""Cache configuration for the request."""
     knowledge_bases: NotRequired[List[CreateCompletionKnowledgeBasesTypedDict]]
-    load_balancer: NotRequired[CreateCompletionLoadBalancerTypedDict]
+    load_balancer: NotRequired[CreateCompletionRouterCompletionsLoadBalancerTypedDict]
     r"""Array of models with weights for load balancing requests"""
-    timeout: NotRequired[CreateCompletionTimeoutTypedDict]
+    timeout: NotRequired[CreateCompletionRouterCompletionsTimeoutTypedDict]
     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."""
 
 
@@ -1099,10 +1251,10 @@ class CreateCompletionOrq(BaseModel):
     name: Optional[str] = None
     r"""The name to display on the trace. If not specified, the default system name will be used."""
 
-    retry: Optional[CreateCompletionRetry] = None
+    retry: Optional[CreateCompletionRouterCompletionsRetry] = None
     r"""Retry configuration for the request"""
 
-    fallbacks: Optional[List[CreateCompletionFallbacks]] = None
+    fallbacks: Optional[List[CreateCompletionRouterCompletionsFallbacks]] = None
     r"""Array of fallback models to use if primary model fails"""
 
     prompt: Optional[CreateCompletionPrompt] = None
@@ -1125,15 +1277,15 @@ class CreateCompletionOrq(BaseModel):
     inputs: Optional[CreateCompletionInputs] = None
     r"""Values to replace in the prompt messages using {{variableName}} syntax"""
 
-    cache: Optional[CreateCompletionCache] = None
+    cache: Optional[CreateCompletionRouterCompletionsCache] = None
     r"""Cache configuration for the request."""
 
     knowledge_bases: Optional[List[CreateCompletionKnowledgeBases]] = None
 
-    load_balancer: Optional[CreateCompletionLoadBalancer] = None
+    load_balancer: Optional[CreateCompletionRouterCompletionsLoadBalancer] = None
     r"""Array of models with weights for load balancing requests"""
 
-    timeout: Optional[CreateCompletionTimeout] = None
+    timeout: Optional[CreateCompletionRouterCompletionsTimeout] = 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")
@@ -1193,6 +1345,18 @@ class CreateCompletionRequestBodyTypedDict(TypedDict):
     r"""How many completions to generate for each prompt. Note: Because this parameter generates many completions, it can quickly consume your token quota."""
     user: NotRequired[str]
     r"""A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse."""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+    fallbacks: NotRequired[List[CreateCompletionFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreateCompletionRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreateCompletionCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreateCompletionLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreateCompletionTimeoutTypedDict]
+    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[CreateCompletionOrqTypedDict]
     r"""Leverage Orq's intelligent routing capabilities to enhance your AI application with enterprise-grade reliability and observability. Orq provides automatic request management including retries on failures, model fallbacks for high availability, identity-level analytics tracking, conversation threading, and dynamic prompt templating with variable substitution."""
     stream: NotRequired[bool]
@@ -1235,6 +1399,24 @@ class CreateCompletionRequestBody(BaseModel):
     user: Optional[str] = None
     r"""A unique identifier representing your end-user, which can help OpenAI to monitor and detect abuse."""
 
+    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[CreateCompletionFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreateCompletionRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreateCompletionCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreateCompletionLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreateCompletionTimeout] = None
+    r"""Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured."""
+
     orq: Annotated[
         Optional[CreateCompletionOrq],
         pydantic.Field(
@@ -1259,6 +1441,12 @@ class CreateCompletionRequestBody(BaseModel):
                 "top_p",
                 "n",
                 "user",
+                "name",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
                 "orq",
                 "stream",
             ]

orq_ai_sdk/models/createcontactop.py

@@ -132,7 +132,7 @@ class CreateContactResponseBody(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-25T21:56:21.657Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-26T13:54:24.067Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/createconversationop.py

@@ -199,7 +199,7 @@ class CreateConversationResponseBody(BaseModel):
     r"""Unix timestamp in milliseconds when the conversation was last modified."""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "conv_01kfvjh98z6b5qsr5af3sr1c69"
+        "conv_01kfx9bgb48qctkc6mmvyz4sm5"
     )
     r"""Unique conversation identifier with `conv_` prefix."""
 

orq_ai_sdk/models/createconversationresponseop.py

@@ -119,7 +119,7 @@ class CreateConversationResponsePartReasoningPart(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_01kfvjh9a1s2nqtxrehsab13cd"
+        "reasoning_01kfx9bgby6na67cpc20ek4eqy"
     )
     r"""Unique identifier for the part. Format: reasoning_{ulid} (e.g., reasoning_01hxyz...)"""
 
@@ -211,7 +211,7 @@ class DeltaReasoningPart(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_01kfvjh99sbd2ynq0r65y5n5hj"
+        "reasoning_01kfx9bgbrjkd2645ybrar3bz8"
     )
     r"""Unique identifier for the part. Format: reasoning_{ulid} (e.g., reasoning_01hxyz...)"""
 

orq_ai_sdk/models/createdatasetitemop.py

@@ -1434,7 +1434,7 @@ class Evaluations3(BaseModel):
 
     source: Optional[CreateDatasetItemEvaluationsDatasetsSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-25T21:56:35.353Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-26T13:54:37.692Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -1502,7 +1502,7 @@ class Evaluations2(BaseModel):
 
     source: Optional[CreateDatasetItemEvaluationsSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-25T21:56:35.352Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-26T13:54:37.691Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -1570,7 +1570,7 @@ class Evaluations1(BaseModel):
 
     source: Optional[EvaluationsSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-25T21:56:35.352Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-26T13:54:37.690Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -1665,7 +1665,7 @@ class CreateDatasetItemResponseBody(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-25T21:56:21.657Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-26T13:54:24.067Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/createdatasetop.py

@@ -94,7 +94,7 @@ class CreateDatasetResponseBody(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-25T21:56:21.657Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-26T13:54:24.067Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/createdatasourceop.py

@@ -314,7 +314,7 @@ class CreateDatasourceResponseBody(BaseModel):
     r"""The number of chunks in the datasource"""
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "01KFVJH9RXNFN8BFTPY72M9XCJ"
+        "01KFX9BGWEPA9CZB0JRC31VCXM"
     )
     r"""The unique identifier of the data source"""