Struct EnhancedPluginManager 

pub struct EnhancedPluginManager { /* private fields */ }

Available on crate feature plugin only.

Manages enhanced plugins with priority-based pipeline execution.

Plugins are stored sorted by priority (ascending). All pipeline methods iterate plugins in this order, passing each plugin’s output as input to the next plugin in the chain.

Thread Safety

EnhancedPluginManager is Send + Sync and can be shared across async tasks via Arc<EnhancedPluginManager>.

Implementations

impl EnhancedPluginManager

pub fn new(plugins: Vec<Arc<dyn EnhancedPlugin>>) -> EnhancedPluginManager

Creates a new EnhancedPluginManager with the given plugins.

Plugins are sorted by priority in ascending order using a stable sort, so plugins with the same priority retain their registration order.

Examples

use std::sync::Arc;
use adk_plugin::{EnhancedPluginManager, EnhancedPlugin};

let plugins: Vec<Arc<dyn EnhancedPlugin>> = vec![
    Arc::new(MyPlugin),
];
let manager = EnhancedPluginManager::new(plugins);

pub fn with_config( plugins: Vec<Arc<dyn EnhancedPlugin>>, config: PluginManagerConfig, ) -> EnhancedPluginManager

Creates a new EnhancedPluginManager with custom configuration.

pub fn add_plugin(&mut self, plugin: Arc<dyn EnhancedPlugin>)

Adds a plugin after construction, re-sorting by priority.

The plugin is inserted and the entire list is re-sorted using a stable sort to maintain registration order for same-priority plugins.

pub fn context(&self) -> &Arc<PluginContext>

Returns a reference to the shared plugin context.

The context is shared across all hook invocations and persists for the lifetime of this manager.

pub fn plugin_count(&self) -> usize

Returns the number of registered plugins.

pub fn plugin_names(&self) -> Vec<&str>

Returns the names of all registered plugins in execution order.

pub async fn run_before_tool_call( &self, tool: Arc<dyn Tool>, args: Value, ctx: Arc<dyn CallbackContext>, ) -> Result<BeforeToolCallResult, AdkError>

Executes the before_tool_call pipeline across all plugins in priority order.

Each plugin receives the (possibly modified) arguments from the previous plugin. If a plugin returns ShortCircuit, the pipeline stops and the synthetic result is returned. If a plugin returns an error, the pipeline stops and the error is propagated.

Arguments

• tool - The tool about to be executed
• args - The initial tool call arguments
• ctx - The callback context for the current invocation

Returns

• Ok(BeforeToolCallResult::Continue(args)) — final modified arguments for tool execution
• Ok(BeforeToolCallResult::ShortCircuit(result)) — synthetic result, skip tool execution
• Err(e) — pipeline error, skip tool execution

pub async fn run_after_tool_call( &self, tool: Arc<dyn Tool>, args: &Value, result: Value, ctx: Arc<dyn CallbackContext>, ) -> Result<AfterToolCallResult, AdkError>

Executes the after_tool_call pipeline across all plugins in priority order.

Each plugin receives the (possibly modified) result from the previous plugin. The args parameter contains the final modified arguments from the before-hook pipeline (not the original arguments).

Arguments

• tool - The tool that was executed
• args - The final arguments used for tool execution (after before-hook modifications)
• result - The initial tool execution result
• ctx - The callback context for the current invocation

Returns

• Ok(AfterToolCallResult::Continue(result)) — final modified result
• Err(e) — pipeline error

pub async fn run_before_model_call( &self, request: LlmRequest, ctx: Arc<dyn CallbackContext>, ) -> Result<BeforeModelCallResult, AdkError>

Executes the before_model_call pipeline across all plugins in priority order.

Each plugin receives the (possibly modified) request from the previous plugin. If a plugin returns ShortCircuit, the pipeline stops and the synthetic response is returned. If a plugin returns an error, the pipeline stops and the error is propagated.

Arguments

• request - The initial LLM request
• ctx - The callback context for the current invocation

Returns

• Ok(BeforeModelCallResult::Continue(request)) — final modified request for model call
• Ok(BeforeModelCallResult::ShortCircuit(response)) — synthetic response, skip model call
• Err(e) — pipeline error, skip model call

pub async fn run_after_model_call( &self, response: LlmResponse, ctx: Arc<dyn CallbackContext>, ) -> Result<AfterModelCallResult, AdkError>

Executes the after_model_call pipeline across all plugins in priority order.

Each plugin receives the (possibly modified) response from the previous plugin. If a plugin returns an error, the pipeline stops and the error is propagated.

Arguments

• response - The initial LLM response
• ctx - The callback context for the current invocation

Returns

• Ok(AfterModelCallResult::Continue(response)) — final modified response
• Err(e) — pipeline error

pub async fn close(&self)

Closes all plugins, ignoring individual close errors.

Each plugin’s close() method is called in sequence. Errors during close are logged but do not prevent other plugins from being closed.

Trait Implementations

impl Debug for EnhancedPluginManager

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.