openrouter 0.0.18__py3-none-any.whl → 0.0.19__py3-none-any.whl

openrouter/components/openresponsesstreamevent.py

@@ -59,10 +59,8 @@ from .reasoningtextcontent import ReasoningTextContent, ReasoningTextContentType
 from .responseoutputtext import ResponseOutputText, ResponseOutputTextTypedDict
 from .responsesoutputitem import ResponsesOutputItem, ResponsesOutputItemTypedDict
 from openrouter.types import BaseModel
-from openrouter.utils import get_discriminator
-from pydantic import Discriminator, Tag
 from typing import List, Literal, Union
-from typing_extensions import Annotated, TypeAliasType, TypedDict
+from typing_extensions import TypeAliasType, TypedDict
 
 
 TypeResponseReasoningSummaryPartDone = Literal["response.reasoning_summary_part.done",]
@@ -330,14 +328,10 @@ Part2TypedDict = TypeAliasType(
 )
 
 
-Part2 = Annotated[
-    Union[
-        Annotated[ResponseOutputText, Tag("output_text")],
-        Annotated[ReasoningTextContent, Tag("reasoning_text")],
-        Annotated[OpenAIResponsesRefusalContent, Tag("refusal")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+Part2 = TypeAliasType(
+    "Part2",
+    Union[ReasoningTextContent, OpenAIResponsesRefusalContent, ResponseOutputText],
+)
 
 
 class OpenResponsesStreamEventResponseContentPartDoneTypedDict(TypedDict):
@@ -380,14 +374,10 @@ Part1TypedDict = TypeAliasType(
 )
 
 
-Part1 = Annotated[
-    Union[
-        Annotated[ResponseOutputText, Tag("output_text")],
-        Annotated[ReasoningTextContent, Tag("reasoning_text")],
-        Annotated[OpenAIResponsesRefusalContent, Tag("refusal")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+Part1 = TypeAliasType(
+    "Part1",
+    Union[ReasoningTextContent, OpenAIResponsesRefusalContent, ResponseOutputText],
+)
 
 
 class OpenResponsesStreamEventResponseContentPartAddedTypedDict(TypedDict):
@@ -619,97 +609,36 @@ OpenResponsesStreamEventTypedDict = TypeAliasType(
 r"""Union of all possible event types emitted during response streaming"""
 
 
-OpenResponsesStreamEvent = Annotated[
+OpenResponsesStreamEvent = TypeAliasType(
+    "OpenResponsesStreamEvent",
     Union[
-        Annotated[OpenResponsesStreamEventResponseCreated, Tag("response.created")],
-        Annotated[
-            OpenResponsesStreamEventResponseInProgress, Tag("response.in_progress")
-        ],
-        Annotated[OpenResponsesStreamEventResponseCompleted, Tag("response.completed")],
-        Annotated[
-            OpenResponsesStreamEventResponseIncomplete, Tag("response.incomplete")
-        ],
-        Annotated[OpenResponsesStreamEventResponseFailed, Tag("response.failed")],
-        Annotated[OpenResponsesErrorEvent, Tag("error")],
-        Annotated[
-            OpenResponsesStreamEventResponseOutputItemAdded,
-            Tag("response.output_item.added"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseOutputItemDone,
-            Tag("response.output_item.done"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseContentPartAdded,
-            Tag("response.content_part.added"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseContentPartDone,
-            Tag("response.content_part.done"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseOutputTextDelta,
-            Tag("response.output_text.delta"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseOutputTextDone,
-            Tag("response.output_text.done"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseRefusalDelta, Tag("response.refusal.delta")
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseRefusalDone, Tag("response.refusal.done")
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseOutputTextAnnotationAdded,
-            Tag("response.output_text.annotation.added"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseFunctionCallArgumentsDelta,
-            Tag("response.function_call_arguments.delta"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseFunctionCallArgumentsDone,
-            Tag("response.function_call_arguments.done"),
-        ],
-        Annotated[
-            OpenResponsesReasoningDeltaEvent, Tag("response.reasoning_text.delta")
-        ],
-        Annotated[OpenResponsesReasoningDoneEvent, Tag("response.reasoning_text.done")],
-        Annotated[
-            OpenResponsesReasoningSummaryPartAddedEvent,
-            Tag("response.reasoning_summary_part.added"),
-        ],
-        Annotated[
-            OpenResponsesStreamEventResponseReasoningSummaryPartDone,
-            Tag("response.reasoning_summary_part.done"),
-        ],
-        Annotated[
-            OpenResponsesReasoningSummaryTextDeltaEvent,
-            Tag("response.reasoning_summary_text.delta"),
-        ],
-        Annotated[
-            OpenResponsesReasoningSummaryTextDoneEvent,
-            Tag("response.reasoning_summary_text.done"),
-        ],
-        Annotated[
-            OpenResponsesImageGenCallInProgress,
-            Tag("response.image_generation_call.in_progress"),
-        ],
-        Annotated[
-            OpenResponsesImageGenCallGenerating,
-            Tag("response.image_generation_call.generating"),
-        ],
-        Annotated[
-            OpenResponsesImageGenCallPartialImage,
-            Tag("response.image_generation_call.partial_image"),
-        ],
-        Annotated[
-            OpenResponsesImageGenCallCompleted,
-            Tag("response.image_generation_call.completed"),
-        ],
+        OpenResponsesStreamEventResponseCreated,
+        OpenResponsesStreamEventResponseInProgress,
+        OpenResponsesStreamEventResponseCompleted,
+        OpenResponsesStreamEventResponseIncomplete,
+        OpenResponsesStreamEventResponseFailed,
+        OpenResponsesStreamEventResponseOutputItemAdded,
+        OpenResponsesStreamEventResponseOutputItemDone,
+        OpenResponsesImageGenCallCompleted,
+        OpenResponsesImageGenCallGenerating,
+        OpenResponsesImageGenCallInProgress,
+        OpenResponsesErrorEvent,
+        OpenResponsesStreamEventResponseFunctionCallArgumentsDelta,
+        OpenResponsesStreamEventResponseRefusalDelta,
+        OpenResponsesReasoningSummaryPartAddedEvent,
+        OpenResponsesStreamEventResponseContentPartAdded,
+        OpenResponsesImageGenCallPartialImage,
+        OpenResponsesStreamEventResponseFunctionCallArgumentsDone,
+        OpenResponsesReasoningDeltaEvent,
+        OpenResponsesReasoningDoneEvent,
+        OpenResponsesStreamEventResponseRefusalDone,
+        OpenResponsesStreamEventResponseReasoningSummaryPartDone,
+        OpenResponsesReasoningSummaryTextDeltaEvent,
+        OpenResponsesReasoningSummaryTextDoneEvent,
+        OpenResponsesStreamEventResponseContentPartDone,
+        OpenResponsesStreamEventResponseOutputTextDelta,
+        OpenResponsesStreamEventResponseOutputTextDone,
+        OpenResponsesStreamEventResponseOutputTextAnnotationAdded,
     ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+)
 r"""Union of all possible event types emitted during response streaming"""

openrouter/components/outputmessage.py

@@ -7,10 +7,8 @@ from .openairesponsesrefusalcontent import (
 )
 from .responseoutputtext import ResponseOutputText, ResponseOutputTextTypedDict
 from openrouter.types import BaseModel
-from openrouter.utils import get_discriminator
-from pydantic import Discriminator, Tag
 from typing import List, Literal, Optional, Union
-from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
 
 
 OutputMessageRole = Literal["assistant",]
@@ -54,13 +52,9 @@ OutputMessageContentTypedDict = TypeAliasType(
 )
 
 
-OutputMessageContent = Annotated[
-    Union[
-        Annotated[ResponseOutputText, Tag("output_text")],
-        Annotated[OpenAIResponsesRefusalContent, Tag("refusal")],
-    ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+OutputMessageContent = TypeAliasType(
+    "OutputMessageContent", Union[OpenAIResponsesRefusalContent, ResponseOutputText]
+)
 
 
 class OutputMessageTypedDict(TypedDict):

openrouter/components/parameter.py

@@ -28,7 +28,6 @@ Parameter = Union[
         "parallel_tool_calls",
         "include_reasoning",
         "reasoning",
-        "reasoning_effort",
         "web_search_options",
         "verbosity",
     ],

openrouter/components/providername.py

@@ -11,14 +11,12 @@ ProviderName = Union[
         "AionLabs",
         "Alibaba",
         "Amazon Bedrock",
-        "Amazon Nova",
         "Anthropic",
-        "Arcee AI",
+        "Arcee",
         "AtlasCloud",
         "Avian",
         "Azure",
         "BaseTen",
-        "BytePlus",
         "Black Forest Labs",
         "Cerebras",
         "Chutes",
@@ -38,12 +36,10 @@ ProviderName = Union[
         "Groq",
         "Hyperbolic",
         "Inception",
-        "Inceptron",
         "InferenceNet",
         "Infermatic",
         "Inflection",
         "Liquid",
-        "Mara",
         "Mancer 2",
         "Minimax",
         "ModelRun",
@@ -63,17 +59,13 @@ ProviderName = Union[
         "Phala",
         "Relace",
         "SambaNova",
-        "Seed",
         "SiliconFlow",
-        "Sourceful",
         "Stealth",
-        "StreamLake",
         "Switchpoint",
+        "Targon",
         "Together",
-        "Upstage",
         "Venice",
         "WandB",
-        "Xiaomi",
         "xAI",
         "Z.AI",
         "FakeProvider",

openrouter/components/providersort.py

@@ -13,3 +13,4 @@ ProviderSort = Union[
     ],
     UnrecognizedStr,
 ]
+r"""The sorting strategy to use for this request, if \"order\" is not specified. When set, no load balancing is performed."""

openrouter/components/publicendpoint.py

@@ -3,80 +3,79 @@
 from __future__ import annotations
 from .endpointstatus import EndpointStatus
 from .parameter import Parameter
-from .percentilestats import PercentileStats, PercentileStatsTypedDict
 from .providername import ProviderName
 from openrouter.types import BaseModel, Nullable, UNSET_SENTINEL, UnrecognizedStr
 from openrouter.utils import validate_open_enum
 from pydantic import model_serializer
 from pydantic.functional_validators import PlainValidator
-from typing import List, Literal, Optional, Union
+from typing import Any, List, Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypedDict
 
 
 class PricingTypedDict(TypedDict):
-    prompt: str
-    r"""A value in string format that is a large number"""
-    completion: str
-    r"""A value in string format that is a large number"""
-    request: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image_token: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image_output: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    audio: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_audio_cache: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    web_search: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    internal_reasoning: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_cache_read: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_cache_write: NotRequired[str]
-    r"""A value in string format that is a large number"""
+    prompt: Any
+    r"""A value in string or number format that is a large number"""
+    completion: Any
+    r"""A value in string or number format that is a large number"""
+    request: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image_token: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image_output: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    audio: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_audio_cache: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    web_search: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    internal_reasoning: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_cache_read: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_cache_write: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
     discount: NotRequired[float]
 
 
 class Pricing(BaseModel):
-    prompt: str
-    r"""A value in string format that is a large number"""
+    prompt: Any
+    r"""A value in string or number format that is a large number"""
 
-    completion: str
-    r"""A value in string format that is a large number"""
+    completion: Any
+    r"""A value in string or number format that is a large number"""
 
-    request: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    request: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image_token: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image_token: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image_output: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image_output: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    audio: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    audio: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_audio_cache: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_audio_cache: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    web_search: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    web_search: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    internal_reasoning: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    internal_reasoning: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_cache_read: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_cache_read: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_cache_write: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_cache_write: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
     discount: Optional[float] = None
 
@@ -112,9 +111,6 @@ class PublicEndpointTypedDict(TypedDict):
     supported_parameters: List[Parameter]
     uptime_last_30m: Nullable[float]
     supports_implicit_caching: bool
-    latency_last_30m: Nullable[PercentileStatsTypedDict]
-    r"""Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests."""
-    throughput_last_30m: Nullable[PercentileStatsTypedDict]
     status: NotRequired[EndpointStatus]
 
 
@@ -149,11 +145,6 @@ class PublicEndpoint(BaseModel):
 
     supports_implicit_caching: bool
 
-    latency_last_30m: Nullable[PercentileStats]
-    r"""Latency percentiles in milliseconds over the last 30 minutes. Latency measures time to first token. Only visible when authenticated with an API key or cookie; returns null for unauthenticated requests."""
-
-    throughput_last_30m: Nullable[PercentileStats]
-
     status: Annotated[
         Optional[EndpointStatus], PlainValidator(validate_open_enum(True))
     ] = None
@@ -166,8 +157,6 @@ class PublicEndpoint(BaseModel):
             "max_completion_tokens",
             "max_prompt_tokens",
             "uptime_last_30m",
-            "latency_last_30m",
-            "throughput_last_30m",
         ]
         null_default_fields = []
 

openrouter/components/publicpricing.py

@@ -2,77 +2,77 @@
 
 from __future__ import annotations
 from openrouter.types import BaseModel
-from typing import Optional
+from typing import Any, Optional
 from typing_extensions import NotRequired, TypedDict
 
 
 class PublicPricingTypedDict(TypedDict):
     r"""Pricing information for the model"""
 
-    prompt: str
-    r"""A value in string format that is a large number"""
-    completion: str
-    r"""A value in string format that is a large number"""
-    request: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image_token: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    image_output: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    audio: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_audio_cache: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    web_search: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    internal_reasoning: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_cache_read: NotRequired[str]
-    r"""A value in string format that is a large number"""
-    input_cache_write: NotRequired[str]
-    r"""A value in string format that is a large number"""
+    prompt: Any
+    r"""A value in string or number format that is a large number"""
+    completion: Any
+    r"""A value in string or number format that is a large number"""
+    request: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image_token: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    image_output: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    audio: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_audio_cache: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    web_search: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    internal_reasoning: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_cache_read: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
+    input_cache_write: NotRequired[Any]
+    r"""A value in string or number format that is a large number"""
     discount: NotRequired[float]
 
 
 class PublicPricing(BaseModel):
     r"""Pricing information for the model"""
 
-    prompt: str
-    r"""A value in string format that is a large number"""
+    prompt: Any
+    r"""A value in string or number format that is a large number"""
 
-    completion: str
-    r"""A value in string format that is a large number"""
+    completion: Any
+    r"""A value in string or number format that is a large number"""
 
-    request: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    request: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image_token: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image_token: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    image_output: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    image_output: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    audio: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    audio: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_audio_cache: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_audio_cache: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    web_search: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    web_search: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    internal_reasoning: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    internal_reasoning: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_cache_read: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_cache_read: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
-    input_cache_write: Optional[str] = None
-    r"""A value in string format that is a large number"""
+    input_cache_write: Optional[Any] = None
+    r"""A value in string or number format that is a large number"""
 
     discount: Optional[float] = None

openrouter/components/responseformattextconfig.py

@@ -10,10 +10,8 @@ from .responsesformattextjsonschemaconfig import (
     ResponsesFormatTextJSONSchemaConfig,
     ResponsesFormatTextJSONSchemaConfigTypedDict,
 )
-from openrouter.utils import get_discriminator
-from pydantic import Discriminator, Tag
 from typing import Union
-from typing_extensions import Annotated, TypeAliasType
+from typing_extensions import TypeAliasType
 
 
 ResponseFormatTextConfigTypedDict = TypeAliasType(
@@ -27,12 +25,12 @@ ResponseFormatTextConfigTypedDict = TypeAliasType(
 r"""Text response format configuration"""
 
 
-ResponseFormatTextConfig = Annotated[
+ResponseFormatTextConfig = TypeAliasType(
+    "ResponseFormatTextConfig",
     Union[
-        Annotated[ResponsesFormatText, Tag("text")],
-        Annotated[ResponsesFormatJSONObject, Tag("json_object")],
-        Annotated[ResponsesFormatTextJSONSchemaConfig, Tag("json_schema")],
+        ResponsesFormatText,
+        ResponsesFormatJSONObject,
+        ResponsesFormatTextJSONSchemaConfig,
     ],
-    Discriminator(lambda m: get_discriminator(m, "type", "type")),
-]
+)
 r"""Text response format configuration"""

openrouter/components/responseoutputtext.py

@@ -6,50 +6,17 @@ from .openairesponsesannotation import (
     OpenAIResponsesAnnotationTypedDict,
 )
 from openrouter.types import BaseModel
-import pydantic
 from typing import List, Literal, Optional
-from typing_extensions import Annotated, NotRequired, TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 
 ResponseOutputTextType = Literal["output_text",]
 
 
-class ResponseOutputTextTopLogprobTypedDict(TypedDict):
-    token: str
-    bytes_: List[float]
-    logprob: float
-
-
-class ResponseOutputTextTopLogprob(BaseModel):
-    token: str
-
-    bytes_: Annotated[List[float], pydantic.Field(alias="bytes")]
-
-    logprob: float
-
-
-class LogprobTypedDict(TypedDict):
-    token: str
-    bytes_: List[float]
-    logprob: float
-    top_logprobs: List[ResponseOutputTextTopLogprobTypedDict]
-
-
-class Logprob(BaseModel):
-    token: str
-
-    bytes_: Annotated[List[float], pydantic.Field(alias="bytes")]
-
-    logprob: float
-
-    top_logprobs: List[ResponseOutputTextTopLogprob]
-
-
 class ResponseOutputTextTypedDict(TypedDict):
     type: ResponseOutputTextType
     text: str
     annotations: NotRequired[List[OpenAIResponsesAnnotationTypedDict]]
-    logprobs: NotRequired[List[LogprobTypedDict]]
 
 
 class ResponseOutputText(BaseModel):
@@ -58,5 +25,3 @@ class ResponseOutputText(BaseModel):
     text: str
 
     annotations: Optional[List[OpenAIResponsesAnnotation]] = None
-
-    logprobs: Optional[List[Logprob]] = None