orq-ai-sdk 4.2.0rc48__py3-none-any.whl → 4.2.12__py3-none-any.whl

orq_ai_sdk/models/listagentsop.py

@@ -668,9 +668,159 @@ class ListAgentsAgentsGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class ListAgentsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListAgentsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListAgentsAgentsRetryTypedDict(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 ListAgentsAgentsRetry(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
+
+
+ListAgentsType = Literal["exact_match",]
+
+
+class ListAgentsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: ListAgentsType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class ListAgentsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: ListAgentsType
+
+    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
+
+
+ListAgentsLoadBalancerType = Literal["weight_based",]
+
+
+class ListAgentsLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class ListAgentsLoadBalancerModels(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 ListAgentsLoadBalancer1TypedDict(TypedDict):
+    type: ListAgentsLoadBalancerType
+    models: List[ListAgentsLoadBalancerModelsTypedDict]
+
+
+class ListAgentsLoadBalancer1(BaseModel):
+    type: ListAgentsLoadBalancerType
+
+    models: List[ListAgentsLoadBalancerModels]
+
+
+ListAgentsLoadBalancerTypedDict = ListAgentsLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+ListAgentsLoadBalancer = ListAgentsLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class ListAgentsTimeoutTypedDict(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 ListAgentsTimeout(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 ListAgentsParametersTypedDict(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[ListAgentsAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -725,11 +875,24 @@ class ListAgentsParametersTypedDict(TypedDict):
     r"""Output types that you would like the model to generate. Most models are capable of generating text, which is the default: [\"text\"]. The gpt-4o-audio-preview model can also be used to generate audio. To request that this model generate both text and audio responses, you can use: [\"text\", \"audio\"]."""
     guardrails: NotRequired[List[ListAgentsAgentsGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[ListAgentsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[ListAgentsAgentsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[ListAgentsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[ListAgentsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[ListAgentsTimeoutTypedDict]
+    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 ListAgentsParameters(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[ListAgentsAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -806,10 +969,26 @@ class ListAgentsParameters(BaseModel):
     guardrails: Optional[List[ListAgentsAgentsGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[ListAgentsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[ListAgentsAgentsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[ListAgentsCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[ListAgentsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[ListAgentsTimeout] = 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")
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -832,6 +1011,11 @@ class ListAgentsParameters(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
             ]
         )
         nullable_fields = set(
@@ -1269,9 +1453,161 @@ class ListAgentsFallbackModelConfigurationGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class ListAgentsFallbackModelConfigurationFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListAgentsFallbackModelConfigurationFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListAgentsFallbackModelConfigurationAgentsRetryTypedDict(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 ListAgentsFallbackModelConfigurationAgentsRetry(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
+
+
+ListAgentsFallbackModelConfigurationType = Literal["exact_match",]
+
+
+class ListAgentsFallbackModelConfigurationCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: ListAgentsFallbackModelConfigurationType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class ListAgentsFallbackModelConfigurationCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: ListAgentsFallbackModelConfigurationType
+
+    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
+
+
+ListAgentsLoadBalancerAgentsType = Literal["weight_based",]
+
+
+class ListAgentsLoadBalancerAgentsModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class ListAgentsLoadBalancerAgentsModels(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 ListAgentsLoadBalancerAgents1TypedDict(TypedDict):
+    type: ListAgentsLoadBalancerAgentsType
+    models: List[ListAgentsLoadBalancerAgentsModelsTypedDict]
+
+
+class ListAgentsLoadBalancerAgents1(BaseModel):
+    type: ListAgentsLoadBalancerAgentsType
+
+    models: List[ListAgentsLoadBalancerAgentsModels]
+
+
+ListAgentsFallbackModelConfigurationLoadBalancerTypedDict = (
+    ListAgentsLoadBalancerAgents1TypedDict
+)
+r"""Load balancer configuration for the request."""
+
+
+ListAgentsFallbackModelConfigurationLoadBalancer = ListAgentsLoadBalancerAgents1
+r"""Load balancer configuration for the request."""
+
+
+class ListAgentsFallbackModelConfigurationTimeoutTypedDict(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 ListAgentsFallbackModelConfigurationTimeout(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 ListAgentsFallbackModelConfigurationParametersTypedDict(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[ListAgentsFallbackModelConfigurationAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -1334,11 +1670,26 @@ class ListAgentsFallbackModelConfigurationParametersTypedDict(TypedDict):
         List[ListAgentsFallbackModelConfigurationGuardrailsTypedDict]
     ]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[ListAgentsFallbackModelConfigurationFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[ListAgentsFallbackModelConfigurationAgentsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[ListAgentsFallbackModelConfigurationCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[
+        ListAgentsFallbackModelConfigurationLoadBalancerTypedDict
+    ]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[ListAgentsFallbackModelConfigurationTimeoutTypedDict]
+    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 ListAgentsFallbackModelConfigurationParameters(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[ListAgentsFallbackModelConfigurationAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -1421,10 +1772,26 @@ class ListAgentsFallbackModelConfigurationParameters(BaseModel):
     guardrails: Optional[List[ListAgentsFallbackModelConfigurationGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[ListAgentsFallbackModelConfigurationFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[ListAgentsFallbackModelConfigurationAgentsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[ListAgentsFallbackModelConfigurationCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[ListAgentsFallbackModelConfigurationLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[ListAgentsFallbackModelConfigurationTimeout] = 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")
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -1447,6 +1814,11 @@ class ListAgentsFallbackModelConfigurationParameters(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
             ]
         )
         nullable_fields = set(

orq_ai_sdk/models/listdatasetdatapointsop.py

@@ -776,7 +776,7 @@ class ListDatasetDatapointsEvaluations3(BaseModel):
 
     source: Optional[ListDatasetDatapointsEvaluationsDatasetsSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-20T13:00:33.349Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-27T09:10:46.896Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -846,7 +846,7 @@ class ListDatasetDatapointsEvaluations2(BaseModel):
 
     source: Optional[ListDatasetDatapointsEvaluationsSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-20T13:00:33.348Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-27T09:10:46.896Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -914,7 +914,7 @@ class ListDatasetDatapointsEvaluations1(BaseModel):
 
     source: Optional[ListDatasetDatapointsEvaluationsDatasetsResponseSource] = "orq"
 
-    reviewed_at: Optional[datetime] = parse_datetime("2026-01-20T13:00:33.348Z")
+    reviewed_at: Optional[datetime] = parse_datetime("2026-01-27T09:10:46.895Z")
     r"""The date and time the item was reviewed"""
 
     @model_serializer(mode="wrap")
@@ -1013,7 +1013,7 @@ class ListDatasetDatapointsData(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-20T13:00:20.021Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-27T09:10:34.517Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/listdatasetsop.py

@@ -113,7 +113,7 @@ class ListDatasetsData(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-20T13:00:20.021Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-27T09:10:34.517Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/listdatasourcesop.py

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

orq_ai_sdk/models/listidentitiesop.py

@@ -208,7 +208,7 @@ class ListIdentitiesData(BaseModel):
     created: Optional[datetime] = None
     r"""The date and time the resource was created"""
 
-    updated: Optional[datetime] = parse_datetime("2026-01-20T13:00:20.021Z")
+    updated: Optional[datetime] = parse_datetime("2026-01-27T09:10:34.517Z")
     r"""The date and time the resource was last updated"""
 
     @model_serializer(mode="wrap")

orq_ai_sdk/models/listmodelsop.py

@@ -17,6 +17,7 @@ ListModelsType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]