orq-ai-sdk 4.2.0rc49__py3-none-any.whl → 4.2.15__py3-none-any.whl

orq_ai_sdk/models/updatepromptop.py

@@ -973,6 +973,154 @@ class UpdatePromptGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class UpdatePromptFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class UpdatePromptFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class UpdatePromptRetryTypedDict(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 UpdatePromptRetry(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
+
+
+UpdatePromptType = Literal["exact_match",]
+
+
+class UpdatePromptCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: UpdatePromptType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class UpdatePromptCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: UpdatePromptType
+
+    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
+
+
+UpdatePromptLoadBalancerType = Literal["weight_based",]
+
+
+class UpdatePromptLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class UpdatePromptLoadBalancerModels(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 UpdatePromptLoadBalancer1TypedDict(TypedDict):
+    type: UpdatePromptLoadBalancerType
+    models: List[UpdatePromptLoadBalancerModelsTypedDict]
+
+
+class UpdatePromptLoadBalancer1(BaseModel):
+    type: UpdatePromptLoadBalancerType
+
+    models: List[UpdatePromptLoadBalancerModels]
+
+
+UpdatePromptLoadBalancerTypedDict = UpdatePromptLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+UpdatePromptLoadBalancer = UpdatePromptLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class UpdatePromptTimeoutTypedDict(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 UpdatePromptTimeout(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 UpdatePromptPromptInputTypedDict(TypedDict):
     r"""Prompt configuration with model and messages. Use this to update the prompt."""
 
@@ -980,6 +1128,8 @@ class UpdatePromptPromptInputTypedDict(TypedDict):
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
     model: NotRequired[Nullable[str]]
     r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[UpdatePromptAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -1034,6 +1184,16 @@ class UpdatePromptPromptInputTypedDict(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[UpdatePromptGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[UpdatePromptFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[UpdatePromptRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[UpdatePromptCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[UpdatePromptLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[UpdatePromptTimeoutTypedDict]
+    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 UpdatePromptPromptInput(BaseModel):
@@ -1045,6 +1205,9 @@ class UpdatePromptPromptInput(BaseModel):
     model: OptionalNullable[str] = UNSET
     r"""Model ID used to generate the response, like `openai/gpt-4o` or `anthropic/claude-3-5-sonnet-20241022`. For private models, use format: `{workspaceKey}@{provider}/{model}`. The full list of models can be found at https://docs.orq.ai/docs/ai-gateway-supported-models. Only chat models are supported."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[UpdatePromptAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -1121,12 +1284,28 @@ class UpdatePromptPromptInput(BaseModel):
     guardrails: Optional[List[UpdatePromptGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[UpdatePromptFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[UpdatePromptRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[UpdatePromptCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[UpdatePromptLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[UpdatePromptTimeout] = 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(
             [
                 "messages",
                 "model",
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -1149,6 +1328,11 @@ class UpdatePromptPromptInput(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
             ]
         )
         nullable_fields = set(
@@ -1420,7 +1604,7 @@ class UpdatePromptResponseBody(OrqError):
         object.__setattr__(self, "data", data)
 
 
-UpdatePromptType = Literal["prompt",]
+UpdatePromptPromptsType = Literal["prompt",]
 
 
 UpdatePromptModelType = Literal[
@@ -1431,6 +1615,7 @@ UpdatePromptModelType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]
@@ -2038,7 +2223,7 @@ UpdatePromptContent = TypeAliasType(
 r"""The contents of the user message. Either the text content of the message or an array of content parts with a defined type, each can be of type `text` or `image_url` when passing in images. You can pass multiple images by adding multiple `image_url` content parts. Can be null for tool messages in certain scenarios."""
 
 
-UpdatePromptPromptsType = Literal["function",]
+UpdatePromptPromptsResponse200Type = Literal["function",]
 
 
 class UpdatePromptFunctionTypedDict(TypedDict):
@@ -2055,14 +2240,14 @@ class UpdatePromptFunction(BaseModel):
 
 
 class UpdatePromptToolCallsTypedDict(TypedDict):
-    type: UpdatePromptPromptsType
+    type: UpdatePromptPromptsResponse200Type
     function: UpdatePromptFunctionTypedDict
     id: NotRequired[str]
     index: NotRequired[float]
 
 
 class UpdatePromptToolCalls(BaseModel):
-    type: UpdatePromptPromptsType
+    type: UpdatePromptPromptsResponse200Type
 
     function: UpdatePromptFunction
 
@@ -2580,6 +2765,154 @@ class UpdatePromptPromptsGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class UpdatePromptPromptsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class UpdatePromptPromptsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class UpdatePromptPromptsRetryTypedDict(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 UpdatePromptPromptsRetry(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
+
+
+UpdatePromptPromptsResponseType = Literal["exact_match",]
+
+
+class UpdatePromptPromptsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: UpdatePromptPromptsResponseType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class UpdatePromptPromptsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: UpdatePromptPromptsResponseType
+
+    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
+
+
+UpdatePromptLoadBalancerPromptsType = Literal["weight_based",]
+
+
+class UpdatePromptLoadBalancerPromptsModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class UpdatePromptLoadBalancerPromptsModels(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 UpdatePromptLoadBalancerPrompts1TypedDict(TypedDict):
+    type: UpdatePromptLoadBalancerPromptsType
+    models: List[UpdatePromptLoadBalancerPromptsModelsTypedDict]
+
+
+class UpdatePromptLoadBalancerPrompts1(BaseModel):
+    type: UpdatePromptLoadBalancerPromptsType
+
+    models: List[UpdatePromptLoadBalancerPromptsModels]
+
+
+UpdatePromptPromptsLoadBalancerTypedDict = UpdatePromptLoadBalancerPrompts1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+UpdatePromptPromptsLoadBalancer = UpdatePromptLoadBalancerPrompts1
+r"""Load balancer configuration for the request."""
+
+
+class UpdatePromptPromptsTimeoutTypedDict(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 UpdatePromptPromptsTimeout(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"""
+
+
 UpdatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyRole = Literal["tool",]
 r"""The role of the messages author, in this case tool."""
 
@@ -3176,6 +3509,8 @@ UpdatePromptPromptsResponseMessages = Annotated[
 class UpdatePromptPromptFieldTypedDict(TypedDict):
     r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
 
+    name: NotRequired[str]
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
     audio: NotRequired[Nullable[UpdatePromptPromptsAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -3230,6 +3565,16 @@ class UpdatePromptPromptFieldTypedDict(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[UpdatePromptPromptsGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[UpdatePromptPromptsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[UpdatePromptPromptsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[UpdatePromptPromptsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[UpdatePromptPromptsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[UpdatePromptPromptsTimeoutTypedDict]
+    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."""
     messages: NotRequired[List[UpdatePromptPromptsResponseMessagesTypedDict]]
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
     model: NotRequired[Nullable[str]]
@@ -3240,6 +3585,9 @@ class UpdatePromptPromptFieldTypedDict(TypedDict):
 class UpdatePromptPromptField(BaseModel):
     r"""Prompt configuration with model and messages. Use this instead of prompt_config."""
 
+    name: Optional[str] = None
+    r"""The name to display on the trace. If not specified, the default system name will be used."""
+
     audio: OptionalNullable[UpdatePromptPromptsAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -3316,6 +3664,21 @@ class UpdatePromptPromptField(BaseModel):
     guardrails: Optional[List[UpdatePromptPromptsGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[UpdatePromptPromptsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[UpdatePromptPromptsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[UpdatePromptPromptsCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[UpdatePromptPromptsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[UpdatePromptPromptsTimeout] = 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."""
+
     messages: Optional[List[UpdatePromptPromptsResponseMessages]] = None
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
 
@@ -3328,6 +3691,7 @@ class UpdatePromptPromptField(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -3350,6 +3714,11 @@ class UpdatePromptPromptField(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
                 "messages",
                 "model",
                 "version",
@@ -3477,7 +3846,7 @@ class UpdatePromptPromptTypedDict(TypedDict):
     r"""A prompt entity with configuration, metadata, and versioning."""
 
     id: str
-    type: UpdatePromptType
+    type: UpdatePromptPromptsType
     owner: str
     domain_id: str
     created: str
@@ -3500,7 +3869,7 @@ class UpdatePromptPrompt(BaseModel):
 
     id: Annotated[str, pydantic.Field(alias="_id")]
 
-    type: UpdatePromptType
+    type: UpdatePromptPromptsType
 
     owner: str
 

orq_ai_sdk/models/updatetoolop.py

@@ -259,7 +259,7 @@ class RequestBodyTools(BaseModel):
 
     schema_: Annotated[UpdateToolRequestBodyToolsSchema, pydantic.Field(alias="schema")]
 
-    id: Optional[str] = "01KFDS3BQN44Z6570MCK3FWKDY"
+    id: Optional[str] = "01KG2GN22V3X563SZMVFHPYQF8"
 
     description: Optional[str] = None
 
@@ -1214,7 +1214,7 @@ class UpdateToolResponseBodyCodeExecutionTool(BaseModel):
     code_tool: UpdateToolResponseBodyCodeTool
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KFDS3BPTR32X9Z64YG2KDHB2"
+        "tool_01KG2GN22N7KZ8Q1C8QMMEGGMF"
     )
 
     display_name: Optional[str] = None
@@ -1345,7 +1345,7 @@ class UpdateToolResponseBodyTools(BaseModel):
         UpdateToolResponseBodyToolsSchema, pydantic.Field(alias="schema")
     ]
 
-    id: Optional[str] = "01KFDS3BPQ8DPSB6G586JMCKAG"
+    id: Optional[str] = "01KG2GN22MH45GSTAYXXG3009H"
 
     description: Optional[str] = None
 
@@ -1476,7 +1476,7 @@ class UpdateToolResponseBodyMCPTool(BaseModel):
     mcp: UpdateToolResponseBodyMcp
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KFDS3BPJN44V5ZHVYRSKW0JA"
+        "tool_01KG2GN22KWGHKBXE19Z1RAWMH"
     )
 
     display_name: Optional[str] = None
@@ -1777,7 +1777,7 @@ class UpdateToolResponseBodyHTTPTool(BaseModel):
     http: UpdateToolResponseBodyHTTP
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KFDS3BPA4HPP11QXTKSGZXT1"
+        "tool_01KG2GN22H6HDWZGXMAPJ70XQD"
     )
 
     display_name: Optional[str] = None
@@ -1972,7 +1972,7 @@ class UpdateToolResponseBodyJSONSchemaTool(BaseModel):
     json_schema: UpdateToolResponseBodyJSONSchema
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KFDS3BP36SV0D44PRQ2V0D2J"
+        "tool_01KG2GN22GH5ACSHZDZS8748MW"
     )
 
     display_name: Optional[str] = None
@@ -2171,7 +2171,7 @@ class UpdateToolResponseBodyFunctionTool(BaseModel):
     function: UpdateToolResponseBodyFunction
 
     id: Annotated[Optional[str], pydantic.Field(alias="_id")] = (
-        "tool_01KFDS3BNXQ1SFWH1EGMFR9T2S"
+        "tool_01KG2GN22F7DAZ551QPG1JRBHH"
     )
 
     display_name: Optional[str] = None