Struct ToolExecutionContext 

pub struct ToolExecutionContext<'a> {
    pub session_id: Option<&'a str>,
    pub tool_call_id: &'a str,
    pub event_tx: Option<&'a Sender<AgentEvent>>,
    pub available_tool_schemas: Option<&'a [ToolSchema]>,
    pub bypass_permissions: bool,
    pub can_async_resume: bool,
    pub bash_completion_sink: Option<&'a Arc<dyn BashCompletionSink>>,
    pub pre_parsed_args: Option<&'a Value>,
}

Context passed to tools during execution.

All fields are optional and should be treated as best-effort hints.

⚠️ Real tool dispatch must build this via ToolExecutionContext::for_dispatch (both agent loops do), NOT a struct literal — that routes every per-session flag through ToolExecutionSessionFlags so a new flag can’t be wired into one loop and silently skipped in the other. Struct literals are for tests and tools that synthesize a child context.

Fields

session_id: Option<&'a str>

Bamboo session id that is executing the tool.

tool_call_id: &'a str

Tool call id from the model (ToolCall.id).

event_tx: Option<&'a Sender<AgentEvent>>

Event sender for streaming progress to clients (agent SSE stream).

available_tool_schemas: Option<&'a [ToolSchema]>

Snapshot of tools currently available to the executing session.

bypass_permissions: bool

When true, the executing session is in “bypass permissions” mode, so tool permission checks are skipped. Sourced per-session from the session’s runtime state (runtime.json), not the global checker.

can_async_resume: bool

When true, the executing agent loop can suspend the current turn for a backgrounded shell and self-resume once it finishes (i.e. a bash_resume_hook AND persistence are wired). The Bash tool uses this to decide whether its auto path (run_in_background omitted) may promote a long command to background: when false, the auto path stays purely synchronous so the command’s output is never orphaned on a loop that can’t resume it (issue #84, phase 2d). Derived from the loop config at the dispatch site — NOT session-derived — so it is a direct for_dispatch parameter rather than a ToolExecutionSessionFlags field.

bash_completion_sink: Option<&'a Arc<dyn BashCompletionSink>>

Loop-facing sink invoked once when a background Bash shell owned by this session completes (issue #84 Phase 2b follow-up). When wired, the Bash tool hands it to the background completion-poll task so the shell’s result is pushed into the loop (injected at the next round boundary while it is actively looping, or via a resume when it is idle) — instead of the model having to poll BashOutput. Borrowed like event_tx (kept Copy) and cloned into the spawned task via Self::cloned_bash_completion_sink. Derived from the loop config at the dispatch site — NOT session-derived — so it is a direct for_dispatch parameter, not a session flag. None leaves the push inert (the durable end-of-turn poll backstop still runs).

pre_parsed_args: Option<&'a Value>

The tool call’s function.arguments JSON string, already parsed once by the dispatching agent loop (which also parses it to populate the ToolStart event). When Some, downstream executors should reuse this instead of calling parse_tool_args_best_effort on the raw string a second time — the value here is the exact output of that same parser on the same input, so reuse is behavior-preserving (issue #106, deferred B1 from #17). When None (e.g. none() contexts, tests, or executors that synthesize a child call), executors parse the raw string themselves, preserving the original single-parse-per-consumer behavior.

Implementations

impl<'a> ToolExecutionContext<'a>

pub fn none(tool_call_id: &'a str) -> ToolExecutionContext<'a>

pub fn for_dispatch( session_id: &'a str, tool_call_id: &'a str, event_tx: &'a Sender<AgentEvent>, available_tool_schemas: &'a [ToolSchema], flags: ToolExecutionSessionFlags, can_async_resume: bool, bash_completion_sink: Option<&'a Arc<dyn BashCompletionSink>>, pre_parsed_args: Option<&'a Value>, ) -> ToolExecutionContext<'a>

Build a context for a real tool dispatch, applying every per-session flag from ToolExecutionSessionFlags. This is the SINGLE place that maps session flags onto the context, and the only constructor the agent loops use — keep both loops (per_call.rs, result_handler.rs) on it so a new per-session field reaches all dispatch paths without per-site edits.

pub fn cloned_sender(&self) -> Option<Sender<AgentEvent>>

Clone the sender (when present) for use in spawned tasks.

pub fn cloned_bash_completion_sink(&self) -> Option<Arc<dyn BashCompletionSink>>

Clone the background-Bash completion sink (when present) into an owned handle for a spawned task — mirrors Self::cloned_sender. Returns an owned Arc so the shell’s detached completion-poll task can outlive the borrowed dispatch context.

pub fn to_tool_ctx(&self) -> ToolCtx

TRANSITIONAL bridge to the owned ToolCtx that the rewritten Tool::invoke takes. Clones this borrowed dispatch context into owned/Arc form at the concrete-executor seam, so the trait + dispatch path keep using ToolExecutionContext (no wide ripple) while tools run on ToolCtx. Removed in Phase B when the dispatch path adopts ToolCtx directly.

pub async fn emit(&self, event: AgentEvent)

Best-effort emit of an event (ignored if no sender).

pub async fn emit_tool_token(&self, content: impl Into<String>)

Convenience helper for streaming tool-scoped output.

Trait Implementations

impl<'a> Clone for ToolExecutionContext<'a>

fn clone(&self) -> ToolExecutionContext<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Copy for ToolExecutionContext<'a>

impl Debug for ToolExecutionContext<'_>

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

Formats the value using the given formatter.