Struct ComputerUseMcpRuntime 

pub struct ComputerUseMcpRuntime<S>
where
    S: Service<RoleClient> + Send + Sync + 'static,
{ /* private fields */ }

Available on crate feature computer-use only.

ComputerUseRuntime implementation backed by a live computer-use-mcp server.

The adapter is bound to a single authenticated session via ComputerUseMcpConfig. It forwards every observation through the governed execute_action shadow facade and re-checks the principal/session identity on each response so that graph or model state can never substitute a different authority.

Errors

Methods return ComputerUseError: transport faults become ComputerUseError::Mcp, decode failures become ComputerUseError::Decode, and identity re-checks become ComputerUseError::IdentityMismatch.

Implementations

impl<S> ComputerUseMcpRuntime<S>

where S: Service<RoleClient> + Send + Sync + 'static,

pub fn new( toolset: Arc<McpToolset<S>>, config: ComputerUseMcpConfig, ) -> ComputerUseMcpRuntime<S>

Create an adapter bound to the supplied MCP toolset and session config.

pub async fn observe_tool( &self, tool: &str, arguments: Value, ) -> Result<Value, ComputerUseError>

Run a read-only desktop tool through the governed shadow facade.

Useful for bootstrapping exact target evidence before graph execution.

Errors

Returns ComputerUseError::Mcp if the underlying MCP call fails.

pub async fn delete_terminal_session( &self, ) -> Result<SessionDeletionResult, ComputerUseError>

Permanently remove this adapter’s terminal runtime session through the authenticated MCP principal. The server, not graph state, owns identity.

Errors

Returns ComputerUseError::Mcp or ComputerUseError::Decode if the call fails or the deletion result cannot be decoded.

pub async fn prune_terminal_sessions( &self, older_than: &str, limit: u32, ) -> Result<Vec<SessionDeletionResult>, ComputerUseError>

Explicitly prune caller-owned terminal sessions before the supplied timestamp. The MCP server enforces principal ownership and the limit.

Errors

Returns ComputerUseError::Mcp or ComputerUseError::Decode on transport or decoding failure.

pub async fn get_follow_ups( &self, after_sequence: u64, limit: u32, ) -> Result<SessionFollowUpPage, ComputerUseError>

Consume remote/local steering with a monotonic cursor. The server binds both the session and returned instructions to the authenticated principal.

Errors

Returns ComputerUseError::InvalidRequest if limit is outside 1..=1000, ComputerUseError::IdentityMismatch if any returned follow-up does not match the authenticated context, or a transport/decode error otherwise.

pub async fn submit_follow_up( &self, instruction: &str, ) -> Result<SessionFollowUp, ComputerUseError>

Submit steering through the same principal-bound MCP boundary. Hosts normally call this; exposing it here supports supervisor/graph tests.

Errors

Returns ComputerUseError::IdentityMismatch if the returned follow-up does not match the authenticated context, or a transport/decode error otherwise.

Trait Implementations

impl<S> ComputerUseRuntime for ComputerUseMcpRuntime<S>

where S: Service<RoleClient> + Send + Sync + 'static,

fn discover_capabilities<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Enumerate the execution capabilities available for the target.

fn observe_visual<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Capture a fresh visual (screenshot/annotation) observation frame.

fn observe_semantic<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Capture a fresh semantic (accessibility/window-tree) observation frame.

fn preview_action<'life0, 'async_trait>( &'life0 self, proposed_action: Value, ) -> Pin<Box<dyn Future<Output = Result<ActionPreview, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Preview a proposed action, returning the runtime-bound envelope, policy, and route.

fn acquire_lease<'life0, 'life1, 'async_trait>( &'life0 self, envelope: &'life1 ActionEnvelope, ) -> Pin<Box<dyn Future<Output = Result<ControlLease, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Acquire the one-writer control lease required before any mutation.

fn reserve_target<'life0, 'life1, 'async_trait>( &'life0 self, envelope: &'life1 ActionEnvelope, ) -> Pin<Box<dyn Future<Output = Result<Option<TargetReservation>, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Reserve a non-authoritative planner intent for multi-agent conflict checks.

fn release_target<'life0, 'life1, 'async_trait>( &'life0 self, reservation: &'life1 TargetReservation, ) -> Pin<Box<dyn Future<Output = Result<(), ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Release a previously acquired TargetReservation.

fn execute_action<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, envelope: &'life1 ActionEnvelope, lease: &'life2 ControlLease, approval_grant_id: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = Result<ExecutionReceipt, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Execute the previewed action exactly once under the supplied lease.

fn verify<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, receipt: &'life1 ExecutionReceipt, postcondition: Option<&'life2 ActionPostcondition>, ) -> Pin<Box<dyn Future<Output = Result<VerificationOutcome, ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Report whether the action’s postcondition was independently observed to hold.

fn pause_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Pause the session’s desktop authority. Defaults to unsupported.

fn stop_session<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, session_id: &'life1 str, reason: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Stop the session’s desktop authority. Defaults to unsupported.

fn emergency_stop<'life0, 'life1, 'async_trait>( &'life0 self, reason: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), ComputerUseError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, ComputerUseMcpRuntime<S>: 'async_trait,

Revoke all desktop authority immediately. Defaults to unsupported.