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

orq_ai_sdk/models/createpromptop.py

@@ -1041,6 +1041,154 @@ class CreatePromptGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class CreatePromptFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptRetryTypedDict(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 CreatePromptRetry(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
+
+
+CreatePromptType = Literal["exact_match",]
+
+
+class CreatePromptCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreatePromptCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptType
+
+    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
+
+
+CreatePromptLoadBalancerType = Literal["weight_based",]
+
+
+class CreatePromptLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreatePromptLoadBalancerModels(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 CreatePromptLoadBalancer1TypedDict(TypedDict):
+    type: CreatePromptLoadBalancerType
+    models: List[CreatePromptLoadBalancerModelsTypedDict]
+
+
+class CreatePromptLoadBalancer1(BaseModel):
+    type: CreatePromptLoadBalancerType
+
+    models: List[CreatePromptLoadBalancerModels]
+
+
+CreatePromptLoadBalancerTypedDict = CreatePromptLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreatePromptLoadBalancer = CreatePromptLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class CreatePromptTimeoutTypedDict(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 CreatePromptTimeout(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 PromptInputTypedDict(TypedDict):
     r"""Prompt configuration with model and messages."""
 
@@ -1048,6 +1196,8 @@ class PromptInputTypedDict(TypedDict):
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
     model: NotRequired[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[CreatePromptAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -1102,6 +1252,16 @@ class PromptInputTypedDict(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[CreatePromptGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[CreatePromptFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreatePromptRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreatePromptCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreatePromptLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreatePromptTimeoutTypedDict]
+    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 PromptInput(BaseModel):
@@ -1113,6 +1273,9 @@ class PromptInput(BaseModel):
     model: Optional[str] = None
     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[CreatePromptAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -1189,11 +1352,27 @@ class PromptInput(BaseModel):
     guardrails: Optional[List[CreatePromptGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[CreatePromptFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreatePromptRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreatePromptCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreatePromptLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreatePromptTimeout] = 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(
             [
                 "model",
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -1216,6 +1395,11 @@ class PromptInput(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
             ]
         )
         nullable_fields = set(
@@ -1322,7 +1506,7 @@ class CreatePromptRequestBody(BaseModel):
         return m
 
 
-CreatePromptType = Literal["prompt",]
+CreatePromptPromptsType = Literal["prompt",]
 
 
 ModelType = Literal[
@@ -1333,6 +1517,7 @@ ModelType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]
@@ -1940,7 +2125,7 @@ CreatePromptContent = 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."""
 
 
-CreatePromptPromptsType = Literal["function",]
+CreatePromptPromptsResponse200Type = Literal["function",]
 
 
 class CreatePromptFunctionTypedDict(TypedDict):
@@ -1957,14 +2142,14 @@ class CreatePromptFunction(BaseModel):
 
 
 class CreatePromptToolCallsTypedDict(TypedDict):
-    type: CreatePromptPromptsType
+    type: CreatePromptPromptsResponse200Type
     function: CreatePromptFunctionTypedDict
     id: NotRequired[str]
     index: NotRequired[float]
 
 
 class CreatePromptToolCalls(BaseModel):
-    type: CreatePromptPromptsType
+    type: CreatePromptPromptsResponse200Type
 
     function: CreatePromptFunction
 
@@ -2482,6 +2667,154 @@ class CreatePromptPromptsGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class CreatePromptPromptsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptPromptsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class CreatePromptPromptsRetryTypedDict(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 CreatePromptPromptsRetry(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
+
+
+CreatePromptPromptsResponseType = Literal["exact_match",]
+
+
+class CreatePromptPromptsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptPromptsResponseType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class CreatePromptPromptsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: CreatePromptPromptsResponseType
+
+    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
+
+
+CreatePromptLoadBalancerPromptsType = Literal["weight_based",]
+
+
+class CreatePromptLoadBalancerPromptsModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class CreatePromptLoadBalancerPromptsModels(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 CreatePromptLoadBalancerPrompts1TypedDict(TypedDict):
+    type: CreatePromptLoadBalancerPromptsType
+    models: List[CreatePromptLoadBalancerPromptsModelsTypedDict]
+
+
+class CreatePromptLoadBalancerPrompts1(BaseModel):
+    type: CreatePromptLoadBalancerPromptsType
+
+    models: List[CreatePromptLoadBalancerPromptsModels]
+
+
+CreatePromptPromptsLoadBalancerTypedDict = CreatePromptLoadBalancerPrompts1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+CreatePromptPromptsLoadBalancer = CreatePromptLoadBalancerPrompts1
+r"""Load balancer configuration for the request."""
+
+
+class CreatePromptPromptsTimeoutTypedDict(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 CreatePromptPromptsTimeout(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"""
+
+
 CreatePromptMessagesPromptsResponse200ApplicationJSONResponseBodyRole = Literal["tool",]
 r"""The role of the messages author, in this case tool."""
 
@@ -3078,6 +3411,8 @@ CreatePromptPromptsResponseMessages = Annotated[
 class PromptFieldTypedDict(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[CreatePromptPromptsAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -3132,6 +3467,16 @@ class PromptFieldTypedDict(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[CreatePromptPromptsGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[CreatePromptPromptsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[CreatePromptPromptsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[CreatePromptPromptsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[CreatePromptPromptsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[CreatePromptPromptsTimeoutTypedDict]
+    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[CreatePromptPromptsResponseMessagesTypedDict]]
     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]]
@@ -3142,6 +3487,9 @@ class PromptFieldTypedDict(TypedDict):
 class PromptField(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[CreatePromptPromptsAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -3218,6 +3566,21 @@ class PromptField(BaseModel):
     guardrails: Optional[List[CreatePromptPromptsGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[CreatePromptPromptsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[CreatePromptPromptsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[CreatePromptPromptsCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[CreatePromptPromptsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[CreatePromptPromptsTimeout] = 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[CreatePromptPromptsResponseMessages]] = None
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
 
@@ -3230,6 +3593,7 @@ class PromptField(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -3252,6 +3616,11 @@ class PromptField(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
                 "messages",
                 "model",
                 "version",
@@ -3379,7 +3748,7 @@ class CreatePromptPromptTypedDict(TypedDict):
     r"""A prompt entity with configuration, metadata, and versioning."""
 
     id: str
-    type: CreatePromptType
+    type: CreatePromptPromptsType
     owner: str
     domain_id: str
     created: str
@@ -3402,7 +3771,7 @@ class CreatePromptPrompt(BaseModel):
 
     id: Annotated[str, pydantic.Field(alias="_id")]
 
-    type: CreatePromptType
+    type: CreatePromptPromptsType
 
     owner: str