Model

16 types. Import any of them from opencode.types.

ModelCacheFormat module-attribute

ModelCacheFormat: TypeAlias = OpenEnum[
    Literal["anthropic", "alibaba"]
]

ModelCapabilities

tools instance-attribute

tools: bool

input instance-attribute

input: list[str]

output instance-attribute

output: list[str]

temperature class-attribute instance-attribute

temperature: bool | None = Field(
    default=None, exclude_if=is_none
)

ModelCompatibility

reasoning_field class-attribute instance-attribute

reasoning_field: ModelReasoningField | None = Field(
    default=None,
    validation_alias="reasoningField",
    serialization_alias="reasoningField",
    exclude_if=is_none,
)

require_reasoning class-attribute instance-attribute

require_reasoning: bool | None = Field(
    default=None,
    validation_alias="requireReasoning",
    serialization_alias="requireReasoning",
    exclude_if=is_none,
)

max_tokens_field class-attribute instance-attribute

max_tokens_field: ModelMaxTokensField | None = Field(
    default=None,
    validation_alias="maxTokensField",
    serialization_alias="maxTokensField",
    exclude_if=is_none,
)

require_finish_reason class-attribute instance-attribute

require_finish_reason: bool | None = Field(
    default=None,
    validation_alias="requireFinishReason",
    serialization_alias="requireFinishReason",
    exclude_if=is_none,
)

require_assistant_after_tool class-attribute instance-attribute

require_assistant_after_tool: bool | None = Field(
    default=None,
    validation_alias="requireAssistantAfterTool",
    serialization_alias="requireAssistantAfterTool",
    exclude_if=is_none,
)

supports_prompt_cache_key class-attribute instance-attribute

supports_prompt_cache_key: bool | None = Field(
    default=None,
    validation_alias="supportsPromptCacheKey",
    serialization_alias="supportsPromptCacheKey",
    exclude_if=is_none,
)

stream_usage class-attribute instance-attribute

stream_usage: bool | None = Field(
    default=None,
    validation_alias="streamUsage",
    serialization_alias="streamUsage",
    exclude_if=is_none,
)

cache_format class-attribute instance-attribute

cache_format: ModelCacheFormat | None = Field(
    default=None,
    validation_alias="cacheFormat",
    serialization_alias="cacheFormat",
    exclude_if=is_none,
)

supports_thinking_block_binding class-attribute instance-attribute

supports_thinking_block_binding: bool | None = Field(
    default=None,
    validation_alias="supportsThinkingBlockBinding",
    serialization_alias="supportsThinkingBlockBinding",
    exclude_if=is_none,
)

supports_effort_updates class-attribute instance-attribute

supports_effort_updates: bool | None = Field(
    default=None,
    validation_alias="supportsEffortUpdates",
    serialization_alias="supportsEffortUpdates",
    exclude_if=is_none,
)

ModelCost

tier class-attribute instance-attribute

tier: ModelCostTier | None = Field(
    default=None, exclude_if=is_none
)

input instance-attribute

input: MoneyUSDPerMillionTokens

output instance-attribute

output: MoneyUSDPerMillionTokens

cache instance-attribute

cache: ModelCostCache

ModelCostCache

read instance-attribute

read: MoneyUSDPerMillionTokens

write instance-attribute

write: MoneyUSDPerMillionTokens

ModelCostTier

type class-attribute instance-attribute

type: Literal['context'] = 'context'

size instance-attribute

size: int

ModelDefaultResponse

location instance-attribute

location: LocationPublicRef

data instance-attribute

data: ModelInfo | None

ModelInfo

id instance-attribute

id: str

model_id class-attribute instance-attribute

model_id: str = Field(
    validation_alias="modelID",
    serialization_alias="modelID",
)

provider_id class-attribute instance-attribute

provider_id: ProviderID = Field(
    validation_alias="providerID",
    serialization_alias="providerID",
)

canonical class-attribute instance-attribute

canonical: ProviderID | None = Field(
    default=None, exclude_if=is_none
)

family class-attribute instance-attribute

family: str | None = Field(default=None, exclude_if=is_none)

name instance-attribute

name: str

compatibility class-attribute instance-attribute

compatibility: ModelCompatibility | None = Field(
    default=None, exclude_if=is_none
)

package class-attribute instance-attribute

package: str | None = Field(
    default=None, exclude_if=is_none
)

settings class-attribute instance-attribute

settings: ModelSettings | None = Field(
    default=None, exclude_if=is_none
)

headers class-attribute instance-attribute

headers: dict[str, str] | None = Field(
    default=None, exclude_if=is_none
)

body class-attribute instance-attribute

body: dict[str, Any] | None = Field(
    default=None, exclude_if=is_none
)

capabilities instance-attribute

capabilities: ModelCapabilities

variants instance-attribute

variants: list[ModelVariant]

time instance-attribute

time: ModelInfoTime

cost instance-attribute

cost: list[ModelCost]

status instance-attribute

status: OpenEnum[
    Literal["alpha", "beta", "deprecated", "active"]
]

enabled instance-attribute

enabled: bool

limit instance-attribute

limit: ModelInfoLimit

ModelInfoLimit

context instance-attribute

context: int

input class-attribute instance-attribute

input: int | None = Field(default=None, exclude_if=is_none)

output instance-attribute

output: int

ModelInfoTime

released instance-attribute

released: float

ModelListResponse

location instance-attribute

location: LocationPublicRef

data instance-attribute

data: list[ModelInfo]

ModelMaxTokensField module-attribute

ModelMaxTokensField: TypeAlias = OpenEnum[
    Literal["max_completion_tokens", "max_tokens"]
]

ModelReasoningField module-attribute

ModelReasoningField: TypeAlias = (
    OpenEnum[
        Literal[
            "reasoning",
            "reasoning_content",
            "reasoning_text",
        ]
    ]
    | str
)

ModelRef

id instance-attribute

id: str

provider_id class-attribute instance-attribute

provider_id: ProviderID = Field(
    validation_alias="providerID",
    serialization_alias="providerID",
)

variant class-attribute instance-attribute

variant: str | None = Field(
    default=None, exclude_if=is_none
)

ModelSettings

compaction class-attribute instance-attribute

compaction: ProviderCompaction | None = Field(
    default=None, exclude_if=is_none
)

encoding class-attribute instance-attribute

encoding: ProviderEncoding | None = Field(
    default=None, exclude_if=is_none
)

ModelVariant

id instance-attribute

id: str

settings class-attribute instance-attribute

settings: ModelSettings | None = Field(
    default=None, exclude_if=is_none
)

headers class-attribute instance-attribute

headers: dict[str, str] | None = Field(
    default=None, exclude_if=is_none
)

body class-attribute instance-attribute

body: dict[str, Any] | None = Field(
    default=None, exclude_if=is_none
)