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

orq_ai_sdk/models/listpromptversionsop.py

@@ -111,6 +111,7 @@ ListPromptVersionsModelType = Literal[
     "tts",
     "stt",
     "rerank",
+    "ocr",
     "moderation",
     "vision",
 ]
@@ -717,7 +718,7 @@ ListPromptVersionsContent = 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."""
 
 
-ListPromptVersionsType = Literal["function",]
+ListPromptVersionsPromptsType = Literal["function",]
 
 
 class ListPromptVersionsFunctionTypedDict(TypedDict):
@@ -734,14 +735,14 @@ class ListPromptVersionsFunction(BaseModel):
 
 
 class ListPromptVersionsToolCallsTypedDict(TypedDict):
-    type: ListPromptVersionsType
+    type: ListPromptVersionsPromptsType
     function: ListPromptVersionsFunctionTypedDict
     id: NotRequired[str]
     index: NotRequired[float]
 
 
 class ListPromptVersionsToolCalls(BaseModel):
-    type: ListPromptVersionsType
+    type: ListPromptVersionsPromptsType
 
     function: ListPromptVersionsFunction
 
@@ -1253,6 +1254,154 @@ class ListPromptVersionsGuardrails(BaseModel):
     r"""Determines whether the guardrail runs on the input (user message) or output (model response)."""
 
 
+class ListPromptVersionsFallbacksTypedDict(TypedDict):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListPromptVersionsFallbacks(BaseModel):
+    model: str
+    r"""Fallback model identifier"""
+
+
+class ListPromptVersionsRetryTypedDict(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 ListPromptVersionsRetry(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
+
+
+ListPromptVersionsType = Literal["exact_match",]
+
+
+class ListPromptVersionsCacheTypedDict(TypedDict):
+    r"""Cache configuration for the request."""
+
+    type: ListPromptVersionsType
+    ttl: NotRequired[float]
+    r"""Time to live for cached responses in seconds. Maximum 259200 seconds (3 days)."""
+
+
+class ListPromptVersionsCache(BaseModel):
+    r"""Cache configuration for the request."""
+
+    type: ListPromptVersionsType
+
+    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
+
+
+ListPromptVersionsLoadBalancerType = Literal["weight_based",]
+
+
+class ListPromptVersionsLoadBalancerModelsTypedDict(TypedDict):
+    model: str
+    r"""Model identifier for load balancing"""
+    weight: NotRequired[float]
+    r"""Weight assigned to this model for load balancing"""
+
+
+class ListPromptVersionsLoadBalancerModels(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 ListPromptVersionsLoadBalancer1TypedDict(TypedDict):
+    type: ListPromptVersionsLoadBalancerType
+    models: List[ListPromptVersionsLoadBalancerModelsTypedDict]
+
+
+class ListPromptVersionsLoadBalancer1(BaseModel):
+    type: ListPromptVersionsLoadBalancerType
+
+    models: List[ListPromptVersionsLoadBalancerModels]
+
+
+ListPromptVersionsLoadBalancerTypedDict = ListPromptVersionsLoadBalancer1TypedDict
+r"""Load balancer configuration for the request."""
+
+
+ListPromptVersionsLoadBalancer = ListPromptVersionsLoadBalancer1
+r"""Load balancer configuration for the request."""
+
+
+class ListPromptVersionsTimeoutTypedDict(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 ListPromptVersionsTimeout(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"""
+
+
 ListPromptVersionsMessagesPromptsResponse200Role = Literal["tool",]
 r"""The role of the messages author, in this case tool."""
 
@@ -1831,6 +1980,8 @@ ListPromptVersionsPromptsMessages = Annotated[
 class ListPromptVersionsPromptFieldTypedDict(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[ListPromptVersionsAudioTypedDict]]
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
     frequency_penalty: NotRequired[Nullable[float]]
@@ -1885,6 +2036,16 @@ class ListPromptVersionsPromptFieldTypedDict(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[ListPromptVersionsGuardrailsTypedDict]]
     r"""A list of guardrails to apply to the request."""
+    fallbacks: NotRequired[List[ListPromptVersionsFallbacksTypedDict]]
+    r"""Array of fallback models to use if primary model fails"""
+    retry: NotRequired[ListPromptVersionsRetryTypedDict]
+    r"""Retry configuration for the request"""
+    cache: NotRequired[ListPromptVersionsCacheTypedDict]
+    r"""Cache configuration for the request."""
+    load_balancer: NotRequired[ListPromptVersionsLoadBalancerTypedDict]
+    r"""Load balancer configuration for the request."""
+    timeout: NotRequired[ListPromptVersionsTimeoutTypedDict]
+    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[ListPromptVersionsPromptsMessagesTypedDict]]
     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]]
@@ -1895,6 +2056,9 @@ class ListPromptVersionsPromptFieldTypedDict(TypedDict):
 class ListPromptVersionsPromptField(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[ListPromptVersionsAudio] = UNSET
     r"""Parameters for audio output. Required when audio output is requested with modalities: [\"audio\"]. Learn more."""
 
@@ -1971,6 +2135,21 @@ class ListPromptVersionsPromptField(BaseModel):
     guardrails: Optional[List[ListPromptVersionsGuardrails]] = None
     r"""A list of guardrails to apply to the request."""
 
+    fallbacks: Optional[List[ListPromptVersionsFallbacks]] = None
+    r"""Array of fallback models to use if primary model fails"""
+
+    retry: Optional[ListPromptVersionsRetry] = None
+    r"""Retry configuration for the request"""
+
+    cache: Optional[ListPromptVersionsCache] = None
+    r"""Cache configuration for the request."""
+
+    load_balancer: Optional[ListPromptVersionsLoadBalancer] = None
+    r"""Load balancer configuration for the request."""
+
+    timeout: Optional[ListPromptVersionsTimeout] = 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[ListPromptVersionsPromptsMessages]] = None
     r"""Array of messages that make up the conversation. Each message has a role (system, user, assistant, or tool) and content."""
 
@@ -1983,6 +2162,7 @@ class ListPromptVersionsPromptField(BaseModel):
     def serialize_model(self, handler):
         optional_fields = set(
             [
+                "name",
                 "audio",
                 "frequency_penalty",
                 "max_tokens",
@@ -2005,6 +2185,11 @@ class ListPromptVersionsPromptField(BaseModel):
                 "parallel_tool_calls",
                 "modalities",
                 "guardrails",
+                "fallbacks",
+                "retry",
+                "cache",
+                "load_balancer",
+                "timeout",
                 "messages",
                 "model",
                 "version",

orq_ai_sdk/models/partdoneevent.py

@@ -40,7 +40,7 @@ class PartReasoningPart(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_01kfdqw5s0ew32wbwe4z0sb99b"
+        "reasoning_01kfzbgfh56wjv31gw3712s28r"
     )
     r"""Unique identifier for the part. Format: reasoning_{ulid} (e.g., reasoning_01hxyz...)"""
 

orq_ai_sdk/models/post_v2_router_ocrop.py

@@ -0,0 +1,408 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from orq_ai_sdk.types import (
+    BaseModel,
+    Nullable,
+    OptionalNullable,
+    UNSET,
+    UNSET_SENTINEL,
+)
+from orq_ai_sdk.utils import get_discriminator
+from pydantic import Discriminator, Tag, model_serializer
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+PostV2RouterOcrDocumentType = Literal["image_url",]
+
+
+class ImageURL2TypedDict(TypedDict):
+    r"""URL of the image to process"""
+
+    url: str
+    detail: NotRequired[str]
+
+
+class ImageURL2(BaseModel):
+    r"""URL of the image to process"""
+
+    url: str
+
+    detail: Optional[str] = None
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["detail"])
+        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
+
+
+DocumentImageURLTypedDict = TypeAliasType(
+    "DocumentImageURLTypedDict", Union[ImageURL2TypedDict, str]
+)
+
+
+DocumentImageURL = TypeAliasType("DocumentImageURL", Union[ImageURL2, str])
+
+
+class Document2TypedDict(TypedDict):
+    type: PostV2RouterOcrDocumentType
+    image_url: DocumentImageURLTypedDict
+
+
+class Document2(BaseModel):
+    type: PostV2RouterOcrDocumentType
+
+    image_url: DocumentImageURL
+
+
+DocumentType = Literal["document_url",]
+
+
+class Document1TypedDict(TypedDict):
+    type: DocumentType
+    document_url: str
+    r"""URL of the document to process"""
+    document_name: NotRequired[str]
+    r"""The name of the document"""
+
+
+class Document1(BaseModel):
+    type: DocumentType
+
+    document_url: str
+    r"""URL of the document to process"""
+
+    document_name: Optional[str] = None
+    r"""The name of the document"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["document_name"])
+        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
+
+
+DocumentTypedDict = TypeAliasType(
+    "DocumentTypedDict", Union[Document2TypedDict, Document1TypedDict]
+)
+r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+
+Document = Annotated[
+    Union[
+        Annotated[Document1, Tag("document_url")],
+        Annotated[Document2, Tag("image_url")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+
+class OcrSettingsTypedDict(TypedDict):
+    r"""Optional settings for the OCR run"""
+
+    include_image_base64: NotRequired[Nullable[bool]]
+    r"""Whether to include image Base64 in the response. Null for default."""
+    max_images_to_include: NotRequired[int]
+    r"""Maximum number of images to extract. Null for no limit."""
+    image_min_size: NotRequired[int]
+    r"""Minimum height and width of image to extract. Null for no minimum."""
+
+
+class OcrSettings(BaseModel):
+    r"""Optional settings for the OCR run"""
+
+    include_image_base64: OptionalNullable[bool] = UNSET
+    r"""Whether to include image Base64 in the response. Null for default."""
+
+    max_images_to_include: Optional[int] = None
+    r"""Maximum number of images to extract. Null for no limit."""
+
+    image_min_size: Optional[int] = None
+    r"""Minimum height and width of image to extract. Null for no minimum."""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(
+            ["include_image_base64", "max_images_to_include", "image_min_size"]
+        )
+        nullable_fields = set(["include_image_base64"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class PostV2RouterOcrRequestBodyTypedDict(TypedDict):
+    r"""input"""
+
+    model: str
+    r"""ID of the model to use for OCR."""
+    document: DocumentTypedDict
+    r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+    pages: NotRequired[Nullable[List[int]]]
+    r"""Specific pages to process. Can be a single number, range, or list. Starts from 0. Null for all pages."""
+    ocr_settings: NotRequired[OcrSettingsTypedDict]
+    r"""Optional settings for the OCR run"""
+
+
+class PostV2RouterOcrRequestBody(BaseModel):
+    r"""input"""
+
+    model: str
+    r"""ID of the model to use for OCR."""
+
+    document: Document
+    r"""Document to run OCR on. Can be a DocumentURLChunk or ImageURLChunk."""
+
+    pages: OptionalNullable[List[int]] = UNSET
+    r"""Specific pages to process. Can be a single number, range, or list. Starts from 0. Null for all pages."""
+
+    ocr_settings: Optional[OcrSettings] = None
+    r"""Optional settings for the OCR run"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["pages", "ocr_settings"])
+        nullable_fields = set(["pages"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class PostV2RouterOcrImagesTypedDict(TypedDict):
+    id: str
+    r"""The id of the image"""
+    image_base64: NotRequired[Nullable[str]]
+    r"""The base64 encoded image"""
+
+
+class PostV2RouterOcrImages(BaseModel):
+    id: str
+    r"""The id of the image"""
+
+    image_base64: OptionalNullable[str] = UNSET
+    r"""The base64 encoded image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["image_base64"])
+        nullable_fields = set(["image_base64"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+class DimensionsTypedDict(TypedDict):
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    dpi: int
+    r"""Dots per inch of the page-image"""
+    height: int
+    r"""Height of the image in pixels"""
+    width: int
+    r"""Width of the image in pixels"""
+
+
+class Dimensions(BaseModel):
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    dpi: int
+    r"""Dots per inch of the page-image"""
+
+    height: int
+    r"""Height of the image in pixels"""
+
+    width: int
+    r"""Width of the image in pixels"""
+
+
+class PagesTypedDict(TypedDict):
+    index: float
+    r"""The page index in a pdf document starting from 0"""
+    markdown: str
+    r"""The markdown string response of the page"""
+    images: List[PostV2RouterOcrImagesTypedDict]
+    dimensions: NotRequired[Nullable[DimensionsTypedDict]]
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+
+class Pages(BaseModel):
+    index: float
+    r"""The page index in a pdf document starting from 0"""
+
+    markdown: str
+    r"""The markdown string response of the page"""
+
+    images: List[PostV2RouterOcrImages]
+
+    dimensions: OptionalNullable[Dimensions] = UNSET
+    r"""The dimensions of the PDF Page's screenshot image"""
+
+    @model_serializer(mode="wrap")
+    def serialize_model(self, handler):
+        optional_fields = set(["dimensions"])
+        nullable_fields = set(["dimensions"])
+        serialized = handler(self)
+        m = {}
+
+        for n, f in type(self).model_fields.items():
+            k = f.alias or n
+            val = serialized.get(k)
+            is_nullable_and_explicitly_set = (
+                k in nullable_fields
+                and (self.__pydantic_fields_set__.intersection({n}))  # pylint: disable=no-member
+            )
+
+            if val != UNSET_SENTINEL:
+                if (
+                    val is not None
+                    or k not in optional_fields
+                    or is_nullable_and_explicitly_set
+                ):
+                    m[k] = val
+
+        return m
+
+
+PostV2RouterOcrUsageType = Literal["tokens",]
+
+
+class Usage2TypedDict(TypedDict):
+    r"""The usage information for the OCR run counted as tokens processed"""
+
+    type: PostV2RouterOcrUsageType
+    tokens_processed: int
+    r"""The number of tokens processed"""
+
+
+class Usage2(BaseModel):
+    r"""The usage information for the OCR run counted as tokens processed"""
+
+    type: PostV2RouterOcrUsageType
+
+    tokens_processed: int
+    r"""The number of tokens processed"""
+
+
+UsageType = Literal["pages",]
+
+
+class Usage1TypedDict(TypedDict):
+    r"""The usage information for the OCR run counted as pages processed"""
+
+    type: UsageType
+    pages_processed: int
+    r"""The number of pages processed"""
+
+
+class Usage1(BaseModel):
+    r"""The usage information for the OCR run counted as pages processed"""
+
+    type: UsageType
+
+    pages_processed: int
+    r"""The number of pages processed"""
+
+
+PostV2RouterOcrUsageTypedDict = TypeAliasType(
+    "PostV2RouterOcrUsageTypedDict", Union[Usage1TypedDict, Usage2TypedDict]
+)
+
+
+PostV2RouterOcrUsage = Annotated[
+    Union[Annotated[Usage1, Tag("pages")], Annotated[Usage2, Tag("tokens")]],
+    Discriminator(lambda m: get_discriminator(m, "type", "type")),
+]
+
+
+class PostV2RouterOcrResponseBodyTypedDict(TypedDict):
+    r"""Represents an OCR response from the API."""
+
+    model: str
+    r"""ID of the model used for OCR."""
+    pages: List[PagesTypedDict]
+    usage: PostV2RouterOcrUsageTypedDict
+
+
+class PostV2RouterOcrResponseBody(BaseModel):
+    r"""Represents an OCR response from the API."""
+
+    model: str
+    r"""ID of the model used for OCR."""
+
+    pages: List[Pages]
+
+    usage: PostV2RouterOcrUsage