openrouter 0.1.2__py3-none-any.whl → 0.6.0__py3-none-any.whl

openrouter/components/_schema10.py

@@ -0,0 +1,39 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from ._schema14 import Schema14, Schema14TypedDict
+from openrouter.types import BaseModel
+from typing import Any, Optional, Union
+from typing_extensions import NotRequired, TypeAliasType, TypedDict
+
+
+PromptTypedDict = TypeAliasType("PromptTypedDict", Union[float, str, Any])
+
+
+Prompt = TypeAliasType("Prompt", Union[float, str, Any])
+
+
+CompletionTypedDict = TypeAliasType("CompletionTypedDict", Union[float, str, Any])
+
+
+Completion = TypeAliasType("Completion", Union[float, str, Any])
+
+
+class Schema10TypedDict(TypedDict):
+    prompt: NotRequired[PromptTypedDict]
+    completion: NotRequired[CompletionTypedDict]
+    image: NotRequired[Schema14TypedDict]
+    audio: NotRequired[Schema14TypedDict]
+    request: NotRequired[Schema14TypedDict]
+
+
+class Schema10(BaseModel):
+    prompt: Optional[Prompt] = None
+
+    completion: Optional[Completion] = None
+
+    image: Optional[Schema14] = None
+
+    audio: Optional[Schema14] = None
+
+    request: Optional[Schema14] = None

openrouter/components/_schema14.py

@@ -0,0 +1,11 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from typing import Any, Union
+from typing_extensions import TypeAliasType
+
+
+Schema14TypedDict = TypeAliasType("Schema14TypedDict", Union[float, str, Any])
+
+
+Schema14 = TypeAliasType("Schema14", Union[float, str, Any])

openrouter/components/_schema17.py

@@ -0,0 +1,154 @@
+"""Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
+
+from __future__ import annotations
+from openrouter.types import BaseModel, UnrecognizedStr
+from openrouter.utils import get_discriminator, validate_const, validate_open_enum
+import pydantic
+from pydantic import Discriminator, Tag
+from pydantic.functional_validators import AfterValidator, PlainValidator
+from typing import List, Literal, Optional, Union
+from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
+
+
+class Schema17ResponseHealingTypedDict(TypedDict):
+    id: Literal["response-healing"]
+    enabled: NotRequired[bool]
+
+
+class Schema17ResponseHealing(BaseModel):
+    ID: Annotated[
+        Annotated[
+            Literal["response-healing"],
+            AfterValidator(validate_const("response-healing")),
+        ],
+        pydantic.Field(alias="id"),
+    ] = "response-healing"
+
+    enabled: Optional[bool] = None
+
+
+PdfEngine = Union[
+    Literal[
+        "mistral-ocr",
+        "pdf-text",
+        "native",
+    ],
+    UnrecognizedStr,
+]
+
+
+class PdfTypedDict(TypedDict):
+    engine: NotRequired[PdfEngine]
+
+
+class Pdf(BaseModel):
+    engine: Annotated[
+        Optional[PdfEngine], PlainValidator(validate_open_enum(False))
+    ] = None
+
+
+class Schema17FileParserTypedDict(TypedDict):
+    id: Literal["file-parser"]
+    enabled: NotRequired[bool]
+    pdf: NotRequired[PdfTypedDict]
+
+
+class Schema17FileParser(BaseModel):
+    ID: Annotated[
+        Annotated[
+            Literal["file-parser"], AfterValidator(validate_const("file-parser"))
+        ],
+        pydantic.Field(alias="id"),
+    ] = "file-parser"
+
+    enabled: Optional[bool] = None
+
+    pdf: Optional[Pdf] = None
+
+
+Engine = Union[
+    Literal[
+        "native",
+        "exa",
+    ],
+    UnrecognizedStr,
+]
+
+
+class Schema17WebTypedDict(TypedDict):
+    id: Literal["web"]
+    enabled: NotRequired[bool]
+    max_results: NotRequired[float]
+    search_prompt: NotRequired[str]
+    engine: NotRequired[Engine]
+
+
+class Schema17Web(BaseModel):
+    ID: Annotated[
+        Annotated[Literal["web"], AfterValidator(validate_const("web"))],
+        pydantic.Field(alias="id"),
+    ] = "web"
+
+    enabled: Optional[bool] = None
+
+    max_results: Optional[float] = None
+
+    search_prompt: Optional[str] = None
+
+    engine: Annotated[Optional[Engine], PlainValidator(validate_open_enum(False))] = (
+        None
+    )
+
+
+class Schema17ModerationTypedDict(TypedDict):
+    id: Literal["moderation"]
+
+
+class Schema17Moderation(BaseModel):
+    ID: Annotated[
+        Annotated[Literal["moderation"], AfterValidator(validate_const("moderation"))],
+        pydantic.Field(alias="id"),
+    ] = "moderation"
+
+
+class Schema17AutoRouterTypedDict(TypedDict):
+    id: Literal["auto-router"]
+    enabled: NotRequired[bool]
+    allowed_models: NotRequired[List[str]]
+
+
+class Schema17AutoRouter(BaseModel):
+    ID: Annotated[
+        Annotated[
+            Literal["auto-router"], AfterValidator(validate_const("auto-router"))
+        ],
+        pydantic.Field(alias="id"),
+    ] = "auto-router"
+
+    enabled: Optional[bool] = None
+
+    allowed_models: Optional[List[str]] = None
+
+
+Schema17TypedDict = TypeAliasType(
+    "Schema17TypedDict",
+    Union[
+        Schema17ModerationTypedDict,
+        Schema17ResponseHealingTypedDict,
+        Schema17AutoRouterTypedDict,
+        Schema17FileParserTypedDict,
+        Schema17WebTypedDict,
+    ],
+)
+
+
+Schema17 = Annotated[
+    Union[
+        Annotated[Schema17AutoRouter, Tag("auto-router")],
+        Annotated[Schema17Moderation, Tag("moderation")],
+        Annotated[Schema17Web, Tag("web")],
+        Annotated[Schema17FileParser, Tag("file-parser")],
+        Annotated[Schema17ResponseHealing, Tag("response-healing")],
+    ],
+    Discriminator(lambda m: get_discriminator(m, "id", "id")),
+]

openrouter/components/{_schema3.py → _schema19.py}

@@ -17,7 +17,7 @@ from typing import Literal, Optional, Union
 from typing_extensions import Annotated, NotRequired, TypeAliasType, TypedDict
 
 
-Schema5 = Union[
+Schema21 = Union[
     Literal[
         "unknown",
         "openai-responses-v1",
@@ -30,16 +30,16 @@ Schema5 = Union[
 ]
 
 
-class Schema3ReasoningTextTypedDict(TypedDict):
+class Schema19ReasoningTextTypedDict(TypedDict):
     type: Literal["reasoning.text"]
     text: NotRequired[Nullable[str]]
     signature: NotRequired[Nullable[str]]
     id: NotRequired[Nullable[str]]
-    format_: NotRequired[Nullable[Schema5]]
+    format_: NotRequired[Nullable[Schema21]]
     index: NotRequired[float]
 
 
-class Schema3ReasoningText(BaseModel):
+class Schema19ReasoningText(BaseModel):
     TYPE: Annotated[
         Annotated[
             Literal["reasoning.text"], AfterValidator(validate_const("reasoning.text"))
@@ -54,7 +54,9 @@ class Schema3ReasoningText(BaseModel):
     id: OptionalNullable[str] = UNSET
 
     format_: Annotated[
-        Annotated[OptionalNullable[Schema5], PlainValidator(validate_open_enum(False))],
+        Annotated[
+            OptionalNullable[Schema21], PlainValidator(validate_open_enum(False))
+        ],
         pydantic.Field(alias="format"),
     ] = UNSET
 
@@ -91,15 +93,15 @@ class Schema3ReasoningText(BaseModel):
         return m
 
 
-class Schema3ReasoningEncryptedTypedDict(TypedDict):
+class Schema19ReasoningEncryptedTypedDict(TypedDict):
     data: str
     type: Literal["reasoning.encrypted"]
     id: NotRequired[Nullable[str]]
-    format_: NotRequired[Nullable[Schema5]]
+    format_: NotRequired[Nullable[Schema21]]
     index: NotRequired[float]
 
 
-class Schema3ReasoningEncrypted(BaseModel):
+class Schema19ReasoningEncrypted(BaseModel):
     data: str
 
     TYPE: Annotated[
@@ -113,7 +115,9 @@ class Schema3ReasoningEncrypted(BaseModel):
     id: OptionalNullable[str] = UNSET
 
     format_: Annotated[
-        Annotated[OptionalNullable[Schema5], PlainValidator(validate_open_enum(False))],
+        Annotated[
+            OptionalNullable[Schema21], PlainValidator(validate_open_enum(False))
+        ],
         pydantic.Field(alias="format"),
     ] = UNSET
 
@@ -150,15 +154,15 @@ class Schema3ReasoningEncrypted(BaseModel):
         return m
 
 
-class Schema3ReasoningSummaryTypedDict(TypedDict):
+class Schema19ReasoningSummaryTypedDict(TypedDict):
     summary: str
     type: Literal["reasoning.summary"]
     id: NotRequired[Nullable[str]]
-    format_: NotRequired[Nullable[Schema5]]
+    format_: NotRequired[Nullable[Schema21]]
     index: NotRequired[float]
 
 
-class Schema3ReasoningSummary(BaseModel):
+class Schema19ReasoningSummary(BaseModel):
     summary: str
 
     TYPE: Annotated[
@@ -172,7 +176,9 @@ class Schema3ReasoningSummary(BaseModel):
     id: OptionalNullable[str] = UNSET
 
     format_: Annotated[
-        Annotated[OptionalNullable[Schema5], PlainValidator(validate_open_enum(False))],
+        Annotated[
+            OptionalNullable[Schema21], PlainValidator(validate_open_enum(False))
+        ],
         pydantic.Field(alias="format"),
     ] = UNSET
 
@@ -209,21 +215,21 @@ class Schema3ReasoningSummary(BaseModel):
         return m
 
 
-Schema3TypedDict = TypeAliasType(
-    "Schema3TypedDict",
+Schema19TypedDict = TypeAliasType(
+    "Schema19TypedDict",
     Union[
-        Schema3ReasoningSummaryTypedDict,
-        Schema3ReasoningEncryptedTypedDict,
-        Schema3ReasoningTextTypedDict,
+        Schema19ReasoningSummaryTypedDict,
+        Schema19ReasoningEncryptedTypedDict,
+        Schema19ReasoningTextTypedDict,
     ],
 )
 
 
-Schema3 = Annotated[
+Schema19 = Annotated[
     Union[
-        Annotated[Schema3ReasoningSummary, Tag("reasoning.summary")],
-        Annotated[Schema3ReasoningEncrypted, Tag("reasoning.encrypted")],
-        Annotated[Schema3ReasoningText, Tag("reasoning.text")],
+        Annotated[Schema19ReasoningSummary, Tag("reasoning.summary")],
+        Annotated[Schema19ReasoningEncrypted, Tag("reasoning.encrypted")],
+        Annotated[Schema19ReasoningText, Tag("reasoning.text")],
     ],
     Discriminator(lambda m: get_discriminator(m, "type", "type")),
 ]

openrouter/components/{_schema0.py → _schema5.py}

@@ -8,11 +8,12 @@ from typing import Literal, Union
 from typing_extensions import Annotated, TypeAliasType
 
 
-Schema0Enum = Union[
+Schema5Enum = Union[
     Literal[
         "AI21",
         "AionLabs",
         "Alibaba",
+        "Ambient",
         "Amazon Bedrock",
         "Amazon Nova",
         "Anthropic",
@@ -69,6 +70,7 @@ Schema0Enum = Union[
         "Seed",
         "SiliconFlow",
         "Sourceful",
+        "StepFun",
         "Stealth",
         "StreamLake",
         "Switchpoint",
@@ -85,10 +87,10 @@ Schema0Enum = Union[
 ]
 
 
-Schema0TypedDict = TypeAliasType("Schema0TypedDict", Union[Schema0Enum, str])
+Schema5TypedDict = TypeAliasType("Schema5TypedDict", Union[Schema5Enum, str])
 
 
-Schema0 = TypeAliasType(
-    "Schema0",
-    Union[Annotated[Schema0Enum, PlainValidator(validate_open_enum(False))], str],
+Schema5 = TypeAliasType(
+    "Schema5",
+    Union[Annotated[Schema5Enum, PlainValidator(validate_open_enum(False))], str],
 )

openrouter/components/assistantmessage.py

@@ -1,6 +1,7 @@
 """Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT."""
 
 from __future__ import annotations
+from ._schema19 import Schema19, Schema19TypedDict
 from .chatmessagecontentitem import (
     ChatMessageContentItem,
     ChatMessageContentItemTypedDict,
@@ -32,6 +33,22 @@ AssistantMessageContent = TypeAliasType(
 )
 
 
+class AssistantMessageImageURLTypedDict(TypedDict):
+    url: str
+
+
+class AssistantMessageImageURL(BaseModel):
+    url: str
+
+
+class ImageTypedDict(TypedDict):
+    image_url: AssistantMessageImageURLTypedDict
+
+
+class Image(BaseModel):
+    image_url: AssistantMessageImageURL
+
+
 class AssistantMessageTypedDict(TypedDict):
     role: Literal["assistant"]
     content: NotRequired[Nullable[AssistantMessageContentTypedDict]]
@@ -39,6 +56,8 @@ class AssistantMessageTypedDict(TypedDict):
     tool_calls: NotRequired[List[ChatMessageToolCallTypedDict]]
     refusal: NotRequired[Nullable[str]]
     reasoning: NotRequired[Nullable[str]]
+    reasoning_details: NotRequired[List[Schema19TypedDict]]
+    images: NotRequired[List[ImageTypedDict]]
 
 
 class AssistantMessage(BaseModel):
@@ -57,9 +76,21 @@ class AssistantMessage(BaseModel):
 
     reasoning: OptionalNullable[str] = UNSET
 
+    reasoning_details: Optional[List[Schema19]] = None
+
+    images: Optional[List[Image]] = None
+
     @model_serializer(mode="wrap")
     def serialize_model(self, handler):
-        optional_fields = ["content", "name", "tool_calls", "refusal", "reasoning"]
+        optional_fields = [
+            "content",
+            "name",
+            "tool_calls",
+            "refusal",
+            "reasoning",
+            "reasoning_details",
+            "images",
+        ]
         nullable_fields = ["content", "refusal", "reasoning"]
         null_default_fields = []