# `Vllm.ToolParsers.ToolParserManager`
[🔗](https://github.com/nshkrdotcom/vllm/blob/v0.3.0/lib/snakebridge_generated/vllm/tool_parsers/tool_parser_manager.ex#L7)

Central registry for ToolParser implementations.

Supports two modes:
  - Eager (immediate) registration via `register_module`
  - Lazy registration via `register_lazy_module`

# `t`

```elixir
@opaque t()
```

# `_load_lazy_parser`

```elixir
@spec _load_lazy_parser(SnakeBridge.Ref.t(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Import and register a lazily loaded parser.

## Parameters

- `name` (String.t())

## Returns

- `term()`

# `_register_module`

```elixir
@spec _register_module(SnakeBridge.Ref.t(), term(), [term()], keyword()) ::
  {:ok, nil} | {:error, Snakepit.Error.t()}
```

Register a ToolParser class immediately.

## Parameters

- `module` (term())
- `module_name` (term() default: None)
- `force` (boolean() default: True)

## Returns

- `nil`

# `get_tool_parser`

```elixir
@spec get_tool_parser(SnakeBridge.Ref.t(), String.t(), keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Retrieve a registered or lazily registered ToolParser class.

If the parser is lazily registered,
it will be imported and cached on first access.
Raises KeyError if not found.

## Parameters

- `name` (String.t())

## Returns

- `term()`

# `import_tool_parser`

```elixir
@spec import_tool_parser(SnakeBridge.Ref.t(), String.t(), keyword()) ::
  {:ok, nil} | {:error, Snakepit.Error.t()}
```

Import a user-defined parser file from arbitrary path.

## Parameters

- `plugin_path` (String.t())

## Returns

- `nil`

# `lazy_parsers`

```elixir
@spec lazy_parsers(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

# `list_registered`

```elixir
@spec list_registered(
  SnakeBridge.Ref.t(),
  keyword()
) :: {:ok, [String.t()]} | {:error, Snakepit.Error.t()}
```

Return names of all eagerly and lazily registered tool parsers.

## Returns

- `list(String.t())`

# `new`

```elixir
@spec new(
  [term()],
  keyword()
) :: {:ok, SnakeBridge.Ref.t()} | {:error, Snakepit.Error.t()}
```

Initialize self.  See help(type(self)) for accurate signature.

## Parameters

- `args` (term())
- `kwargs` (term())

# `register_lazy_module`

```elixir
@spec register_lazy_module(
  SnakeBridge.Ref.t(),
  String.t(),
  String.t(),
  String.t(),
  keyword()
) ::
  {:ok, nil} | {:error, Snakepit.Error.t()}
```

Register a lazy module mapping.

## Examples

    ToolParserManager.register_lazy_module(
    name="kimi_k2",
    module_path="vllm.tool_parsers.kimi_k2_parser",
    class_name="KimiK2ToolParser",
    )

## Parameters

- `name` (String.t())
- `module_path` (String.t())
- `class_name` (String.t())

## Returns

- `nil`

# `register_module`

```elixir
@spec register_module(SnakeBridge.Ref.t(), [term()], keyword()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

Register module immediately or lazily (as a decorator).

Usage:
    @ToolParserManager.register_module("kimi_k2")
    class KimiK2ToolParser(ToolParser):
        ...

Or:
    ToolParserManager.register_module(module=SomeToolParser)

## Parameters

- `name` (term() default: None)
- `force` (boolean() default: True)
- `module` (term() default: None)

## Returns

- `term()`

# `tool_parsers`

```elixir
@spec tool_parsers(SnakeBridge.Ref.t()) ::
  {:ok, term()} | {:error, Snakepit.Error.t()}
```

---

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