# `ASM.Extensions.ProviderSDK`
[🔗](https://github.com/nshkrdotcom/agent_session_manager/blob/v0.9.2/lib/asm/extensions/provider_sdk.ex#L1)

Public discovery API for optional provider-native extension namespaces.

This boundary sits above ASM's normalized kernel. It reports which richer
provider-native surfaces may be present without widening the kernel API or
making provider SDK packages mandatory for core execution.

Use `ASM.ProviderRegistry` for normalized lane/runtime discovery and
`ASM.Extensions.ProviderSDK` for provider-native extension discovery.

Discovery is intentionally split into registered-versus-active views:

- `extensions/0` and `provider_extensions/1` return the static Claude/Codex
  native-extension catalog that ASM knows about
- `available_extensions/0` and `available_provider_extensions/1` return only
  the active subset for the currently installed optional deps
- `provider_report/1` and `capability_report/0` expose both views through
  `registered_namespaces` versus `namespaces`

Gemini and Amp may therefore compose with `sdk_available?: true` while still
reporting no native namespaces, because they currently use only the common
ASM surface plus the optional SDK lane/runtime kit.

# `provider_report`

```elixir
@type provider_report() :: %{
  provider: ASM.Provider.provider_name(),
  composition_mode: :common_surface_only | :native_extension,
  registered_namespaces: [module()],
  namespaces: [module()],
  sdk_available?: boolean(),
  registered_extensions: [ASM.Extensions.ProviderSDK.Extension.t()],
  native_capabilities: [atom()],
  native_surface_modules: [module()],
  extensions: [ASM.Extensions.ProviderSDK.Extension.t()]
}
```

Active and registered provider-native composition facts for one provider.

`registered_namespaces` and `registered_extensions` describe the static
catalog ASM ships for that provider. `namespaces` and `extensions` describe
the active subset for the currently installed optional deps.

# `available?`

```elixir
@spec available?(atom() | module()) :: boolean()
```

Returns whether a registered provider-native extension is active locally.

# `available_extensions`

```elixir
@spec available_extensions() :: [ASM.Extensions.ProviderSDK.Extension.t()]
```

Returns the active provider-native extension catalog for the current deps.

# `available_provider_extensions`

```elixir
@spec available_provider_extensions(ASM.Provider.provider_name() | ASM.Provider.t()) ::
  {:ok, [ASM.Extensions.ProviderSDK.Extension.t()]} | {:error, ASM.Error.t()}
```

Returns the active provider-native extensions for one provider.

Providers with no active native namespace return `{:ok, []}`.

# `capability_report`

```elixir
@spec capability_report() :: %{
  optional(ASM.Provider.provider_name()) => provider_report()
}
```

Returns `provider_report/1` for every ASM provider.

# `extension`

```elixir
@spec extension(atom() | module()) ::
  {:ok, ASM.Extensions.ProviderSDK.Extension.t()} | {:error, ASM.Error.t()}
```

Resolves one registered provider-native extension by provider atom or module.

# `extensions`

```elixir
@spec extensions() :: [ASM.Extensions.ProviderSDK.Extension.t()]
```

Returns ASM's static provider-native extension catalog.

This is the compile-time Claude/Codex catalog that ASM ships, regardless of
whether the matching optional provider SDK deps are active in the current
application.

# `provider_capabilities`

```elixir
@spec provider_capabilities(ASM.Provider.provider_name() | ASM.Provider.t()) ::
  {:ok, [atom()]} | {:error, ASM.Error.t()}
```

Returns the active provider-native capability labels for one provider.

# `provider_extensions`

```elixir
@spec provider_extensions(ASM.Provider.provider_name() | ASM.Provider.t()) ::
  {:ok, [ASM.Extensions.ProviderSDK.Extension.t()]} | {:error, ASM.Error.t()}
```

Returns the registered provider-native extension catalog for one provider.

This reports what ASM knows how to expose for that provider, even if the
matching optional dependency is currently inactive.

# `provider_report`

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

Returns active and registered composition facts for one provider.

`sdk_available?` reports whether the provider runtime kit is loadable for the
current dependency set. `registered_namespaces` reports the static ASM
catalog, while `namespaces` reports the active subset.

---

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