> This page is for version v0.24.1.
> For other versions, use one of these documentation indexes:
> - Latest (default): https://docs.nvidia.com/nemo/guardrails/latest/llms.txt
> - v0.24.1: https://docs.nvidia.com/nemo/guardrails/v0.24.1/llms.txt
> - v0.24.0: https://docs.nvidia.com/nemo/guardrails/v0.24.0/llms.txt
> - v0.23.0: https://docs.nvidia.com/nemo/guardrails/v0.23.0/llms.txt
> - v0.22.0: https://docs.nvidia.com/nemo/guardrails/v0.22.0/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/guardrails/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/guardrails/_mcp/server.

# nemoguardrails.actions.action_dispatcher

Module for the calling proper action endpoints based on events received at action server endpoint

## Module Contents

### Classes

| Name                                                                                     | Description                                                 |
| ---------------------------------------------------------------------------------------- | ----------------------------------------------------------- |
| [`ActionDispatcher`](#nemoguardrails-actions-action_dispatcher-ActionDispatcher)         | -                                                           |
| [`AsyncInvokableAction`](#nemoguardrails-actions-action_dispatcher-AsyncInvokableAction) | -                                                           |
| [`RunnableAction`](#nemoguardrails-actions-action_dispatcher-RunnableAction)             | -                                                           |
| [`_RegisteredActions`](#nemoguardrails-actions-action_dispatcher-_RegisteredActions)     | Read-only view over registered and lazily declared actions. |

### Functions

| Name                                                                         | Description                                                          |
| ---------------------------------------------------------------------------- | -------------------------------------------------------------------- |
| [`is_action_file`](#nemoguardrails-actions-action_dispatcher-is_action_file) | Heuristics for determining if a Python file can have actions or not. |

### Data

[`LEGACY_UNMANIFESTED_LIBRARY_PACKAGES`](#nemoguardrails-actions-action_dispatcher-LEGACY_UNMANIFESTED_LIBRARY_PACKAGES)

[`RegisteredAction`](#nemoguardrails-actions-action_dispatcher-RegisteredAction)

[`log`](#nemoguardrails-actions-action_dispatcher-log)

### API

```python
class nemoguardrails.actions.action_dispatcher.ActionDispatcher(
    load_all_actions: bool = True,
    config_path: typing.Optional[str] = None,
    import_paths: typing.Optional[typing.List[str]] = None,
    rail_catalog: typing.Optional[nemoguardrails.manifests.RailCatalog] = None
)
```

**`_lazy_action_refs`** `Dict[str, ActionRef] = {}`

---

**`_manifest_action_names`** `set[str] = set()`

---

**`_registered_actions`** `Dict[str, RegisteredAction] = {}`

---

**`_registered_actions_view`** `= _RegisteredActions(self)`

---

**`registered_actions`**

Gets the dictionary of registered actions.
Returns:
dict: A dictionary where keys are action names and values are callable action functions.

---

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._action_names() -> tuple[str, ...]
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._find_actions(
    directory
) -> typing.Dict
```

Loop through all the subdirectories and check for the class with @action
decorator and add in action\_classes dict.

**Parameters:**

**`directory`**

The directory to search for actions.

---

**Returns:** `Dict`

Dictionary of found actions.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._has_action_name(
    action_name: str
) -> bool
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._load_actions_from_module(
    filepath: str
)
```

staticmethod

Loads the actions from the specified python module.

**Parameters:**

**`filepath`** `str`

The path of the Python module.

---

**Returns:**

Dictionary of loaded actions.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._load_unmanifested_library_actions(
    library_path: pathlib.Path
) -> None
```

Load pre-manifest library packages that register actions directly.

Manifested library actions are indexed as lazy refs by
`_register_manifest_action_refs`; only the packages in
`LEGACY_UNMANIFESTED_LIBRARY_PACKAGES` still register eagerly.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._normalize_action_name(
    name: str
) -> str
```

Normalize the action name to the required format.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._register_action_ref(
    action_ref: nemoguardrails.manifests.ActionRef,
    override: bool = True
) -> None
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._register_manifest_action_refs() -> None
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._resolve_registered_action(
    action_name: str
) -> typing.Optional[nemoguardrails.actions.action_dispatcher.RegisteredAction]
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher._sanitize_for_log(
    value: typing.Any
) -> str
```

staticmethod

Sanitize values before logging to prevent log injection.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.execute_action(
    action_name: str,
    params: typing.Dict[str, typing.Any]
) -> typing.Tuple[typing.Union[typing.Optional[str], typing.Dict[str, typing.Any]], str]
```

async

Execute a registered action.

**Parameters:**

**`action_name`** `str`

The name of the action to execute.

---

**`params`** `Dict[str, Any]`

Parameters for the action.

---

**Returns:** `Tuple[Union[Optional[str], Dict[str, Any]], str]`

Tuple\[Union\[str, Dict\[str, Any]], str]: A tuple containing the result and status.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.get_action(
    name: str
) -> typing.Optional[nemoguardrails.actions.action_dispatcher.RegisteredAction]
```

Get the registered action by name.

**Parameters:**

**`name`** `str`

The name of the action.

---

**Returns:** `Optional[RegisteredAction]`

The registered action.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.get_registered_actions() -> typing.List[str]
```

Get the list of available actions.

**Returns:** `List[str]`

List\[str]: List of available actions.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.has_registered(
    name: str
) -> bool
```

Check if an action is registered.

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.is_manifest_action(
    name: str
) -> bool
```

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.load_actions_from_path(
    path: pathlib.Path
)
```

Loads all actions from the specified path.

This method loads all actions from the `actions.py` file if it exists and
all actions inside the `actions` folder if it exists.

**Parameters:**

**`path`** `str`

A string representing the path from which to load actions.

---

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.register_action(
    action: nemoguardrails.actions.action_dispatcher.RegisteredAction,
    name: typing.Optional[str] = None,
    override: bool = True
)
```

Registers an action with the given name.

**Parameters:**

**`action`** `RegisteredAction`

The action function or runnable object.

---

**`name`** `Optional[str]` — default: None

The name of the action. Defaults to None.

---

**`override`** `bool` — default: True

If an action already exists, whether it should be overridden or not.

---

```python
nemoguardrails.actions.action_dispatcher.ActionDispatcher.register_actions(
    actions_obj: typing.Any,
    override: bool = True
)
```

Registers all the actions from the given object.

**Parameters:**

**`actions_obj`** `any`

The object containing actions.

---

**`override`** `bool` — default: True

If an action already exists, whether it should be overridden or not.

---

```python
class nemoguardrails.actions.action_dispatcher.AsyncInvokableAction()
```

Protocol

```python
nemoguardrails.actions.action_dispatcher.AsyncInvokableAction.ainvoke(
    args: typing.Any = (),
    kwargs: typing.Any = {}
) -> typing.Awaitable[typing.Any]
```

```python
class nemoguardrails.actions.action_dispatcher.RunnableAction()
```

Protocol

```python
nemoguardrails.actions.action_dispatcher.RunnableAction.run(
    args: typing.Any = (),
    kwargs: typing.Any = {}
) -> typing.Any
```

```python
class nemoguardrails.actions.action_dispatcher._RegisteredActions(
    dispatcher: nemoguardrails.actions.action_dispatcher.ActionDispatcher
)
```

**Bases:** `Mapping[str, RegisteredAction]`

Read-only view over registered and lazily declared actions.

Iteration, `in`, and `len` reflect every registered and lazily declared
action name. Subscripting (and therefore `dict(view)`) resolves a lazy
action on demand, importing its module and raising `KeyError` if it cannot
be resolved. `values` and `items` deliberately expose only actions that
are already resolved, so iterating them never triggers a lazy import or
fails on an action whose optional dependency is missing.

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.__contains__(
    name: object
) -> bool
```

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.__getitem__(
    name: str
) -> nemoguardrails.actions.action_dispatcher.RegisteredAction
```

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.__iter__() -> collections.abc.Iterator[str]
```

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.__len__() -> int
```

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.items() -> collections.abc.ItemsView[str, nemoguardrails.actions.action_dispatcher.RegisteredAction]
```

```python
nemoguardrails.actions.action_dispatcher._RegisteredActions.values() -> collections.abc.ValuesView[nemoguardrails.actions.action_dispatcher.RegisteredAction]
```

```python
nemoguardrails.actions.action_dispatcher.is_action_file(
    filepath
)
```

Heuristics for determining if a Python file can have actions or not.

Currently, it only excludes the \`**init**.py files.

```python
nemoguardrails.actions.action_dispatcher.LEGACY_UNMANIFESTED_LIBRARY_PACKAGES: Tuple[str, ...] = ('attention', 'utils')
```

```python
nemoguardrails.actions.action_dispatcher.RegisteredAction: TypeAlias = Union[Callable[..., Any], Type[Any], AsyncInvokableAction, RunnableAction]
```

```python
nemoguardrails.actions.action_dispatcher.log = logging.getLogger(__name__)
```