# `BB.Jido.Action.Command`
[🔗](https://github.com/beam-bots/bb_jido/blob/main/lib/bb/jido/action/command.ex#L5)

Jido action that executes a Beam Bots command.

Bridges Jido's action system to BB's command infrastructure: starts the
named command on the robot, awaits its result with `BB.Command.await/2`,
and maps the outcome into the canonical bb_jido error taxonomy.

## Schema

- `:robot` — the robot module (required).
- `:command` — the command name as an atom (required).
- `:goal` — the goal map passed to the command (default `%{}`).
- `:timeout` — millisecond timeout for `BB.Command.await/2` (default
  `30_000`).

## Returns

- `{:ok, %{command: ..., goal: ..., outcome: ..., robot: ...}}` on success.
- `{:error, :safety_disarmed}` if the command exited because the robot was
  disarmed.
- `{:error, {:command_failed, reason}}` for any other command failure or
  process termination.

# `__action_metadata__`

Returns the Action metadata. Alias for to_json/0.

# `category`

Returns the category of the Action.

# `description`

Returns the description of the Action.

# `name`

Returns the name of the Action.

# `on_after_run`

Lifecycle hook called after Action execution.

# `on_after_validate_output`

Lifecycle hook called after output validation.

# `on_after_validate_params`

Lifecycle hook called after parameter validation.

# `on_before_validate_output`

Lifecycle hook called before output validation.

# `on_before_validate_params`

Lifecycle hook called before parameter validation.

# `on_error`

Lifecycle hook called when an error occurs.

# `output_schema`

Returns the output schema of the Action.

# `run`

Executes the Action with the given parameters and context.

The `run/2` function must be implemented in the module using Jido.Action.

# `schema`

Returns the input schema of the Action.

# `tags`

Returns the tags associated with the Action.

# `to_json`

Returns the Action metadata as a JSON-serializable map.

# `to_tool`

Converts the Action to an LLM-compatible tool format.

# `validate_output`

```elixir
@spec validate_output(map()) :: {:ok, map()} | {:error, String.t()}
```

Validates the output result for the Action.

## Examples

    iex> defmodule ExampleAction do
    ...>   use Jido.Action,
    ...>     name: "example_action",
    ...>     output_schema: [
    ...>       result: [type: :string, required: true]
    ...>     ]
    ...> end
    ...> ExampleAction.validate_output(%{result: "test", extra: "ignored"})
    {:ok, %{result: "test", extra: "ignored"}}

    iex> ExampleAction.validate_output(%{extra: "ignored"})
    {:error, "Invalid output for Action: Required key :result not found"}

# `validate_params`

```elixir
@spec validate_params(map()) :: {:ok, map()} | {:error, String.t()}
```

Validates the input parameters for the Action.

## Examples

    iex> defmodule ExampleAction do
    ...>   use Jido.Action,
    ...>     name: "example_action",
    ...>     schema: [
    ...>       input: [type: :string, required: true]
    ...>     ]
    ...> end
    ...> ExampleAction.validate_params(%{input: "test"})
    {:ok, %{input: "test"}}

    iex> ExampleAction.validate_params(%{})
    {:error, "Invalid parameters for Action: Required key :input not found"}

# `vsn`

Returns the version of the Action.

---

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