Jido.Plugin.Requirements (Jido v2.3.0)

Validates plugin requirements at agent creation time.

Plugins can declare requirements in their configuration:

{:config, key} - Ensure resolved config has this key with non-nil value
{:app, app_name} - Ensure the OTP application is available
{:plugin, plugin_name} - Ensure another mounted plugin has this name

Example

defmodule MyApp.SlackPlugin do
  use Jido.Plugin,
    name: "slack",
    requires: [
      {:config, :token},
      {:config, :channel},
      {:app, :req}
    ]
end

If requirements are not met, agent compilation will fail with a descriptive error.

Summary

Types

context()

requirement()

Functions

format_error(missing_by_plugin)

Formats missing requirements into a human-readable error message.

validate_all_requirements(instances, config_map)

Validates requirements for all plugin instances.

validate_requirements(instance, context)

Validates requirements for a single plugin instance.

Types

context()

@type context() :: %{
  mounted_plugins: [Jido.Plugin.Instance.t()],
  resolved_config: map()
}

requirement()

@type requirement() ::
  {:config, atom()} | {:app, atom()} | {:plugin, String.t() | atom()}

Functions

format_error(missing_by_plugin)

@spec format_error(%{required(String.t()) => [requirement()]}) :: String.t()

Formats missing requirements into a human-readable error message.

Examples

iex> format_error(%{"slack" => [{:config, :token}, {:app, :req}]})
"Missing requirements for plugins: slack requires {:config, :token}, {:app, :req}"

validate_all_requirements(instances, config_map)

@spec validate_all_requirements([Jido.Plugin.Instance.t()], map()) ::
  {:ok, :valid} | {:error, %{required(String.t()) => [requirement()]}}

Validates requirements for all plugin instances.

Returns a single error listing all missing requirements grouped by plugin.

Parameters

instances - List of plugin instances
config_map - Map of state_key => resolved_config for each plugin

Returns

{:ok, :valid} - All requirements for all plugins are met
{:error, missing_by_plugin} - Map of plugin name => missing requirements

Examples

iex> validate_all_requirements(instances, config_map)
{:ok, :valid}

iex> validate_all_requirements([slack_instance], %{})
{:error, %{"slack" => [{:config, :token}]}}

validate_requirements(instance, context)

@spec validate_requirements(Jido.Plugin.Instance.t(), context()) ::
  {:ok, :valid} | {:error, [requirement()]}

Validates requirements for a single plugin instance.

Parameters

instance - The plugin instance with manifest containing requirements
context - Map with :mounted_plugins and :resolved_config

Returns

{:ok, :valid} - All requirements are met
{:error, missing_requirements} - List of unmet requirements

Examples

iex> validate_requirements(slack_instance, context)
{:ok, :valid}

iex> validate_requirements(slack_instance, %{mounted_plugins: [], resolved_config: %{}})
{:error, [{:config, :token}, {:app, :req}]}