Struct ExecutionContext 

pub struct ExecutionContext<'a> {
    pub params: Value,
    pub uri_params: HashMap<String, String>,
    pub session: &'a Session,
    pub logger: &'a McpLogger,
    pub environment: Option<&'a dyn Environment>,
    /* private fields */
}

Execution context passed to tools, resources, and prompts during execution

Provides access to:

• Input parameters (for tools) or arguments (for prompts)
• Session information (roles, state, client info)
• Environment state (git status, filesystem)

Example

impl Tool for MyTool {
    async fn execute(&self, ctx: ExecutionContext<'_>) -> Result<Vec<Box<dyn Content>>, ToolError> {
        // Access session info
        if ctx.is_admin() {
            // Admin-only behavior
        }

        // Access parameters
        let name = ctx.params.get("name").and_then(|v| v.as_str());

        // Access environment
        if let Some(env) = ctx.environment {
            if env.has_git_repo() {
                // Git-specific behavior
            }
        }

        Ok(vec![])
    }
}

Fields

params: Value

Input parameters (from tool call or prompt arguments)

uri_params: HashMap<String, String>

URI parameters (extracted from resource URI template)

session: &'a Session

Reference to the current session

logger: &'a McpLogger

Logger for sending log notifications to the client

environment: Option<&'a dyn Environment>

Optional environment state for contextual checks

Implementations

impl<'a> ExecutionContext<'a>

pub fn new(params: Value, session: &'a Session, logger: &'a McpLogger) -> Self

Create a new execution context

pub fn with_environment( params: Value, session: &'a Session, logger: &'a McpLogger, environment: &'a dyn Environment, ) -> Self

Create an execution context with environment

pub fn for_resource( uri_params: HashMap<String, String>, session: &'a Session, logger: &'a McpLogger, ) -> Self

Create an execution context for resources (with URI params)

pub fn for_resource_with_environment( uri_params: HashMap<String, String>, session: &'a Session, logger: &'a McpLogger, environment: &'a dyn Environment, ) -> Self

Create a resource execution context with environment

pub fn with_client_requester(self, requester: ClientRequester) -> Self

Set the client requester for server→client requests

pub fn client_requester(&self) -> Option<&ClientRequester>

Get the client requester for making server→client requests

Returns None if the server hasn’t set up bidirectional communication.

pub fn get_uri_param(&self, name: &str) -> Option<&str>

Get a URI parameter by name

pub fn get_state<T: DeserializeOwned>(&self, key: &str) -> Option<T>

Get a session state value

pub fn has_role(&self, role: &str) -> bool

Check if session has a specific role

pub fn is_admin(&self) -> bool

Check if session is admin

pub fn is_vip(&self) -> bool

Check if session is VIP

pub fn session_id(&self) -> &str

Get session ID

pub fn client_name(&self) -> Option<&str>

Get client name if available

pub fn client_version(&self) -> Option<&str>

Get client version if available

pub fn protocol_version(&self) -> Option<&str>

Get negotiated protocol version if available

pub fn client_capabilities(&self) -> Option<&ClientCapabilities>

Get client capabilities if available

pub fn as_visibility_context(&self) -> VisibilityContext<'a>

Convert to VisibilityContext (for visibility checks)