Struct Caller 

pub struct Caller { /* private fields */ }

The authenticated principal behind a request.

Built only by the transport that authenticated the connection — from the certificate chain a peer presented, or from the admitted identity of a local connection. It is deliberately not Deserialize: a payload cannot assert who sent it.

Implementations

impl Caller

pub fn within(self, reach: Reach) -> Caller

The same caller, asking as part of an invocation admitted to reach reach: what goes further runs only once the person confirmed it. It only narrows. Set only by the host that matched the request to the invocation it continues, never from a payload.

pub const fn ceiling(&self) -> Option<Reach>

How far this caller’s requests reach without the person being asked, when they continue an invocation (Self::within).

impl Caller

pub fn authenticated( user_public_key: [u8; 32], device_public_key: [u8; 32], ) -> Caller

A remote device whose certificate the transport verified to chain to user_public_key.

pub fn local_person(principal: impl Into<String>) -> Caller

A person on a connection the host admitted itself, by the policy principal id that admission established.

pub fn local_agent(agent_id: impl Into<String>) -> Caller

A delegated agent on a connection the host admitted itself.

pub fn local_app(app_id: impl Into<String>) -> Caller

An application on a connection the host admitted itself, by the package id that admission established. It holds no role of its own: it may use only what it owns and what a workspace grants it.

pub fn delegated_agent( agent_id: impl Into<String>, user_public_key: [u8; 32], device_public_key: [u8; 32], ) -> Caller

A remote agent device whose certificate the transport verified to chain to user_public_key and whose root-signed delegation names it agent agent_id. It is its own principal, never the person who delegated it.

pub fn agent_turn( agent_id: impl Into<String>, person: impl Into<String>, turn: Turn, ) -> Caller

An agent acting inside a turn: person’s message in turn’s conversation caused it, and the agent takes part there. It may do exactly what that person may, held to the editor preset and to the bound its own record carries, and nothing outside a turn. Every op it makes carries the turn, so the receiving device checks the cause it arrived with. Set only by the host that admitted the turn.

pub fn bot( installation: impl Into<String>, user_public_key: [u8; 32], device_public_key: [u8; 32], ) -> Caller

A bot device whose certificate chains to user_public_key (its installer) and whose root-signed delegation names it installation installation. It acts for its installer and is never that person.

pub fn in_new_execution(self) -> Caller

Give an already admitted connection its own execution scope. The host mints the identifier; no payload, display name or history run selects it. This changes invocation ownership, never the caller’s permissions.

pub fn in_execution(self, execution: ExecutionLease) -> Caller

Retain a host-issued execution when projecting the same transport into another verified action door. A lease conveys ownership and lifetime, never certificate custody or additional permissions.

pub fn execution_id(&self) -> Option<Uuid>

Host-issued execution identity. An identifier alone conveys no authority.

pub fn execution_lease(&self) -> Option<ExecutionLease>

pub fn execution_is_live(&self) -> bool

pub fn retire_execution(&self)

A transport ends its own run; retained caller clones cannot reopen it.

pub fn from_foreign_device(self, foreign: bool) -> Caller

Mark whether the caller acts from a foreign device: a Tilo runtime on an operating system Tilo does not control, as its certificate says. Workspaces it does not govern cap such a caller’s role.

pub fn acting_for(self, person: impl Into<String>) -> Caller

The caller acts for person, by that person’s policy principal id: an agent, a Shortcut or an app the person started. Set only by the host that admitted the delegation, never from a payload. It names who the actor works for in presence and history; it widens nothing.

pub fn delegated_to(self, agent_id: impl Into<String>) -> Caller

This person’s own device hands the connection to agent agent_id, acting for them: an MCP client, a local assistant. The agent is the principal (its edits, presence and history are the agent’s, for the person) and it may do only what both the person and the delegation a device gives its agents allow. A caller that is not a person is returned as it is. Set only by the host that admitted the person.

pub fn is_session_delegated(&self) -> bool

Whether this agent is one the person’s own device handed its session to (Self::delegated_to): it carries the delegation a device gives its agents. An agent admitted as a member that acts for a person (Self::acting_for) carries only what the workspace grants it.

pub fn turn(&self) -> Option<&Turn>

The turn this agent acts inside (Self::agent_turn), when it was admitted as one: the message whose conversation caused its ops, which every door it reaches decides it against.

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

The person this caller acts for, when it is not that person.

pub fn running_shortcut(self, id: impl Into<String>) -> Caller

The caller’s invocations are the steps of Shortcut id’s run: still the person’s authority (bounded by the Shortcut’s own grants, which the runner applies), but the Shortcut is who acts, for the person. Set only by the host’s Shortcut runner.

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

The Shortcut whose run this invocation is a step of.

pub fn actor(&self) -> InteractionActor

Who acts, as presence and history name them: the kind of actor, its id, and the person it acts for when that is someone else.

pub fn in_workspace(self, workspace: impl Into<String>) -> Caller

Confine the caller to one workspace: the connection was admitted to that workspace only, so nothing outside it is offered or reachable.

pub const fn principal(&self) -> &CallerPrincipal

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

The workspace this caller is confined to, if any.

pub const fn user_public_key(&self) -> Option<&[u8; 32]>

The user root a remote device chains to.

pub const fn is_foreign_device(&self) -> bool

pub const fn device_public_key(&self) -> Option<&[u8; 32]>

The remote device that sent the request.

Trait Implementations

impl Clone for Caller

fn clone(&self) -> Caller

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Caller

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

Formats the value using the given formatter.

impl Hash for Caller

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Caller

fn eq(&self, other: &Caller) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Caller

impl StructuralPartialEq for Caller