Struct HookBus 

pub struct HookBus { /* private fields */ }

The central hook dispatcher.

Thread-safe: uses RwLock so multiple concurrent emitters can read the handler list, and registration takes a write lock only briefly.

Implementations

impl HookBus

pub fn new() -> HookBus

Create an empty HookBus with no handlers.

pub fn extension_generation(&self, extension_id: &str) -> u64

Current load generation of extension_id (0 until first unloaded).

pub async fn set_session_injection_for(&self, session_id: &str, content: String)

Record context injected by an on_session_start handler for session_id.

Called once per session, by whoever emits the session-start event, after extensions have loaded. Later calls for the same id replace the stored value.

pub async fn session_injection_for(&self, session_id: &str) -> Option<String>

Context injected at session start for session_id, if any. Read on every turn while composing the system prompt.

pub async fn clear_session_injection(&self, session_id: &str)

Drop the injection recorded for session_id (session teardown).

pub async fn set_session_injection(&self, content: String)

👎Deprecated:

use set_session_injection_for

Compatibility shim: writes under the empty key.

pub async fn session_injection(&self) -> Option<String>

👎Deprecated:

use session_injection_for

Compatibility shim: reads the empty key.

pub async fn subscribe( &self, kind: HookKind, handler: Arc<dyn ExtensionHandler>, tool_filter: Option<String>, matcher: Option<HookMatcher>, permissions: PermissionSet, ) -> Result<(), String>

Register a handler for a specific hook kind.

Returns an error if the handler’s permissions don’t allow subscribing to this hook kind.

pub async fn emit(&self, event: &HookEvent) -> HookResult

Emit a hook event to all registered handlers.

Returns the first Block result if any handler blocks, otherwise returns Continue. Handlers are called in registration order.

For before_tool_call only Block ends the chain (#148 I1):

• Modify rewrites the input and the chain continues; every later handler sees (and vets) the modified input, and the final input is returned as Modify unless something blocks or confirms.
• Confirm is recorded and the chain continues, so a later Block wins even when the confirming extension is already latched. Confirms are merged (all sources, all messages) and returned last, carrying any input modified BEFORE the first Confirm.
• A Modify after a pending Confirm is ignored (logged at warn): the user confirms the input as it stood when they were asked.

If no handlers are registered for this hook, returns immediately (the no-extensions fast path).

pub async fn emit_concurrent(&self, event: &HookEvent) -> HookResult

Emit a hook event to all registered handlers concurrently.

All handlers race under a single shared timeout (per_handler_timeout). Results are collected and the first Block wins; injections are merged.

When to use this over emit():

Only safe for hook kinds whose handlers are order-independent — i.e. where no handler’s result depends on another’s execution. Currently that applies to:

• on_session_end: only Continue is a valid result; handlers are fire-and-forget notification calls (deck, d20, jawz-widget, synaps-tasks all write to their own stores independently).

Do NOT use for before_tool_call / after_tool_call / before_message hooks where Block / Modify / Replace / Inject semantics require a defined winner when two handlers disagree — join_all completion order is nondeterministic, so the “winner” would be unstable. Those hooks must use the sequential emit, which enforces first-wins ordering.

With N extensions and a 5 s per-handler timeout, serial emit takes up to N×5 s; concurrent emit collapses that to a single 5 s window regardless of N — critical for teardown budgets.

pub async fn unsubscribe_all(&self, extension_id: &str)

Remove all handlers for a given extension ID.

pub async fn handler_count(&self) -> usize

Number of registered handlers across all hooks.

pub async fn is_empty(&self) -> bool

Check if any handlers are registered (for fast-path decisions).

pub async fn subscriptions_for( &self, extension_id: &str, ) -> Vec<(HookKind, Option<String>)>

Return all (kind, tool_filter) pairs subscribed by the given extension id. Sorted by kind name, then by tool_filter (None first), for stable output.

Trait Implementations

impl Default for HookBus

fn default() -> HookBus

Returns the “default value” for a type.