# `Codex.Models`
[🔗](https://github.com/nshkrdotcom/codex_sdk/blob/v0.18.1/lib/codex/models.ex#L1)

Codex model metadata projected from `cli_subprocess_core`.

# `client_version`

```elixir
@type client_version() :: {non_neg_integer(), non_neg_integer(), non_neg_integer()}
```

# `model_preset`

```elixir
@type model_preset() :: %{
  id: String.t(),
  model: String.t(),
  display_name: String.t(),
  description: String.t(),
  default_reasoning_effort: reasoning_effort(),
  supported_reasoning_efforts: [reasoning_effort_preset()],
  is_default: boolean(),
  upgrade: model_upgrade() | nil,
  show_in_picker: boolean(),
  supported_in_api: boolean(),
  family: String.t() | nil
}
```

# `model_upgrade`

```elixir
@type model_upgrade() :: %{
  id: String.t(),
  reasoning_effort_mapping:
    %{required(reasoning_effort()) => reasoning_effort()} | nil,
  migration_config_key: String.t(),
  model_link: String.t() | nil,
  upgrade_copy: String.t() | nil
}
```

# `reasoning_effort`

```elixir
@type reasoning_effort() ::
  :none
  | :minimal
  | :low
  | :medium
  | :high
  | :xhigh
  | :max
  | :ultra
  | String.t()
```

# `reasoning_effort_preset`

```elixir
@type reasoning_effort_preset() :: %{
  effort: reasoning_effort(),
  description: String.t()
}
```

# `coerce_reasoning_effort`

```elixir
@spec coerce_reasoning_effort(String.t() | atom() | nil, reasoning_effort() | nil) ::
  reasoning_effort() | nil
```

Coerces a reasoning effort to the nearest supported value for a model.

Returns the input effort unchanged when the model is unknown or already supports it.

# `default_model`

```elixir
@spec default_model(:api | :chatgpt) :: String.t()
```

Returns the SDK default model from the shared core registry.

# `default_reasoning_effort`

```elixir
@spec default_reasoning_effort(String.t() | atom() | nil) :: reasoning_effort() | nil
```

Returns the default reasoning effort for the given model (or the default model).

# `description`

```elixir
@spec description(String.t() | atom()) :: String.t() | nil
```

Returns the description for a model, if known.

# `display_name`

```elixir
@spec display_name(String.t() | atom()) :: String.t() | nil
```

Returns the display name for a model, if known.

# `get_upgrade`

```elixir
@spec get_upgrade(String.t()) :: model_upgrade() | nil
```

Returns the upgrade information for a model, if available.

# `list`

```elixir
@spec list() :: [model_preset()]
```

Returns the list of supported models visible for the inferred auth mode.

# `list_visible`

```elixir
@spec list_visible(
  :api | :chatgpt,
  keyword()
) :: [model_preset()]
```

Returns models visible in the model picker.

# `normalize_reasoning_effort`

```elixir
@spec normalize_reasoning_effort(String.t() | atom() | nil) ::
  {:ok, reasoning_effort() | nil} | {:error, term()}
```

Parses a reasoning effort value into its canonical atom form.

# `reasoning_effort_to_string`

```elixir
@spec reasoning_effort_to_string(reasoning_effort()) :: String.t()
```

Renders a normalized reasoning effort as the CLI-friendly string value.

# `reasoning_efforts`

```elixir
@spec reasoning_efforts() :: [
  :none | :minimal | :low | :medium | :high | :xhigh | :max | :ultra,
  ...
]
```

Lists the valid reasoning effort values understood by the SDK.

# `supported_in_api?`

```elixir
@spec supported_in_api?(String.t()) :: boolean()
```

Returns true if a model is supported via API key authentication.

# `supported_reasoning_efforts`

```elixir
@spec supported_reasoning_efforts(String.t()) :: [reasoning_effort_preset()]
```

Returns the supported reasoning efforts for a model.

# `tool_enabled?`

```elixir
@spec tool_enabled?(String.t() | atom() | nil) :: boolean()
```

Returns `true` when the given model supports tool execution.

---

*Consult [api-reference.md](api-reference.md) for complete listing*