# `ASM.ProviderRegistry`
[🔗](https://github.com/nshkrdotcom/agent_session_manager/blob/v0.9.2/lib/asm/provider_registry.ex#L1)

Resolves providers to backend lanes and runtime metadata.

Lane selection is discovery-driven and independent from execution mode:

- `provider_info/1` describes the provider and installed runtime-kit surface
- `lane_info/2` resolves the preferred lane from `:auto | :core | :sdk`
- `resolve/2` applies execution-mode compatibility to produce the effective backend

# `execution_mode`

```elixir
@type execution_mode() :: :local | :remote_node
```

# `lane`

```elixir
@type lane() :: :auto | :core | :sdk
```

# `lane_info`

```elixir
@type lane_info() :: %{
  provider: ASM.Provider.t(),
  requested_lane: lane(),
  preferred_lane: :core | :sdk,
  backend: module(),
  core_profile: module(),
  core_profile_id: atom(),
  sdk_runtime: module() | nil,
  sdk_available?: boolean(),
  available_lanes: [atom()],
  capabilities: [atom()],
  lane_reason: atom(),
  observability: map()
}
```

# `provider_info`

```elixir
@type provider_info() :: %{
  provider: ASM.Provider.t(),
  core_profile: module(),
  core_profile_id: atom(),
  sdk_runtime: module() | nil,
  sdk_available?: boolean(),
  available_lanes: [atom()],
  default_lane: :auto,
  core_capabilities: [atom()],
  sdk_capabilities: [atom()],
  observability: map()
}
```

# `resolution`

```elixir
@type resolution() :: %{
  provider: ASM.Provider.t(),
  requested_lane: lane(),
  preferred_lane: :core | :sdk,
  lane: :core | :sdk,
  backend: module(),
  sdk_available?: boolean(),
  core_profile: module(),
  core_profile_id: atom(),
  sdk_runtime: module() | nil,
  capabilities: [atom()],
  execution_mode: execution_mode(),
  lane_reason: atom(),
  lane_fallback_reason: atom() | nil,
  observability: map()
}
```

# `core_profile_id`

```elixir
@spec core_profile_id(atom()) :: {:ok, atom()} | {:error, ASM.Error.t()}
```

# `fetch`

```elixir
@spec fetch(atom() | ASM.Provider.t()) ::
  {:ok, ASM.Provider.t()} | {:error, ASM.Error.t()}
```

# `lane_info`

```elixir
@spec lane_info(
  atom() | ASM.Provider.t(),
  keyword()
) :: {:ok, lane_info()} | {:error, ASM.Error.t()}
```

# `provider_info`

```elixir
@spec provider_info(atom() | ASM.Provider.t()) ::
  {:ok, provider_info()} | {:error, ASM.Error.t()}
```

# `resolve`

```elixir
@spec resolve(
  atom(),
  keyword()
) :: {:ok, resolution()} | {:error, ASM.Error.t()}
```

# `resolve_lane`

```elixir
@spec resolve_lane(
  atom() | ASM.Provider.t(),
  keyword()
) :: {:ok, :core | :sdk} | {:error, ASM.Error.t()}
```

# `sdk_available?`

```elixir
@spec sdk_available?(atom() | ASM.Provider.t()) :: boolean()
```

# `supported_providers`

```elixir
@spec supported_providers() :: [atom()]
```

---

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