Struct TapAgent 

pub struct TapAgent {
    pub config: AgentConfig,
    /* private fields */
}

TapAgent implementation using the AgentKeyManager for cryptographic operations.

Fields

config: AgentConfig

Configuration for the agent

Implementations

impl TapAgent

pub fn key_manager(&self) -> &Arc<AgentKeyManager>

Returns a reference to the agent’s key manager

pub fn new(config: AgentConfig, key_manager: Arc<AgentKeyManager>) -> Self

Creates a new TapAgent with the given configuration and AgentKeyManager

pub async fn from_ephemeral_key() -> Result<(Self, String)>

Creates a new TapAgent with an ephemeral key

This function generates a new DID key for temporary use. The key is not persisted to storage and will be lost when the agent is dropped.

Returns

A tuple containing the TapAgent and the DID that was generated

pub async fn from_stored_keys(did: Option<String>, debug: bool) -> Result<Self>

Creates a new TapAgent from stored keys

This function uses the AgentKeyManagerBuilder to load keys from storage

Arguments

• did - Optional DID to use. If None, the default DID from storage is used.
• debug - Whether to enable debug mode

Returns

A Result containing either the created agent or an error if no keys are available

pub async fn from_secret_helper( config: &SecretHelperConfig, did: &str, debug: bool, ) -> Result<(Self, String)>

Creates a new TapAgent from a secret helper

Invokes the secret helper to retrieve the private key for the given DID, then creates a TapAgent using that key.

Arguments

• config - The secret helper configuration
• did - The DID to fetch the key for
• debug - Whether to enable debug mode

pub async fn from_private_key( private_key: &[u8], key_type: KeyType, debug: bool, ) -> Result<(Self, String)>

Creates a new TapAgent from an existing private key

This function creates a new TapAgent using a provided private key, which can be useful for integrating with external key management systems or when keys are generated outside the TAP agent.

Arguments

• private_key - The private key bytes
• key_type - The type of key (Ed25519, P256, or Secp256k1)
• debug - Whether to enable debug mode

Returns

A Result containing either the created agent or an error

pub async fn get_signing_kid(&self) -> Result<String>

Get the signing key ID for this agent

Resolves the DID document and returns the first authentication verification method ID

pub async fn get_encryption_kid(&self, recipient_did: &str) -> Result<String>

Get the encryption key ID for a recipient

Resolves the DID document and returns the appropriate key agreement method ID

pub async fn send_to_endpoint( &self, packed_message: &str, endpoint: &str, ) -> Result<u16>

Send a message to a specific endpoint

Parameters

• packed_message - The packed message to send
• endpoint - The endpoint URL to send the message to

Returns

The HTTP response status code, or error if the request failed

pub async fn create_enhanced_agent( agent_id: String, policies: Vec<String>, metadata: HashMap<String, String>, save_to_storage: bool, ) -> Result<(Self, String)>

Create an agent with enhanced configuration (policies and metadata)

pub async fn create_enhanced_agent_with_path( agent_id: String, policies: Vec<String>, metadata: HashMap<String, String>, save_to_storage: bool, storage_path: Option<PathBuf>, ) -> Result<(Self, String)>

Create an agent with enhanced configuration (policies and metadata) with custom storage path

pub async fn load_enhanced_agent( did: &str, ) -> Result<(Self, Vec<String>, HashMap<String, String>)>

Load an enhanced agent from storage with policies and metadata

pub fn list_enhanced_agents() -> Result<Vec<EnhancedAgentInfo>>

List all enhanced agents with their policies and metadata

pub fn list_enhanced_agents_with_path( storage_path: Option<PathBuf>, ) -> Result<Vec<EnhancedAgentInfo>>

List all enhanced agents with their policies and metadata with custom storage path

Trait Implementations

impl Agent for TapAgent

fn get_agent_did(&self) -> &str

Gets the agent’s DID

fn get_service_endpoint<'life0, 'life1, 'async_trait>( &'life0 self, to: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Gets the service endpoint URL for a recipient

fn send_message<'life0, 'life1, 'life2, 'async_trait, T>( &'life0 self, message: &'life1 T, to: Vec<&'life2 str>, deliver: bool, ) -> Pin<Box<dyn Future<Output = Result<(String, Vec<DeliveryResult>)>> + Send + 'async_trait>>

where T: 'async_trait + TapMessageBody + Serialize + Send + Sync + Debug + 'static, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Sends a message to one or more recipients

fn receive_encrypted_message<'life0, 'life1, 'async_trait>( &'life0 self, jwe_value: &'life1 Value, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Receives an encrypted message (decrypt and process)

fn receive_plain_message<'life0, 'async_trait>( &'life0 self, message: PlainMessage, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Receives a plain message (already verified/decrypted)

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

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Receives a raw message (for standalone usage - handles any message type)

fn create_oob_invitation<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait, T>( &'life0 self, message: &'life1 T, goal_code: &'life2 str, goal: &'life3 str, service_url: &'life4 str, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where T: 'async_trait + TapMessageBody + Serialize + Send + Sync, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Create an Out-of-Band invitation for any TAP message

fn create_payment_link<'life0, 'life1, 'async_trait>( &'life0 self, payment: &'life1 Payment, config: Option<PaymentLinkConfig>, ) -> Pin<Box<dyn Future<Output = Result<String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Create a payment link from a Payment message

fn parse_oob_invitation(&self, url: &str) -> Result<OutOfBandInvitation>

Parse an Out-of-Band invitation from a URL

fn process_oob_invitation<'life0, 'life1, 'async_trait>( &'life0 self, oob_invitation: &'life1 OutOfBandInvitation, ) -> Pin<Box<dyn Future<Output = Result<PlainMessage>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Process an Out-of-Band invitation and extract the attached message

fn send_typed<'life0, 'async_trait, T>( &'life0 self, message: PlainMessage<T>, deliver: bool, ) -> Pin<Box<dyn Future<Output = Result<(String, Vec<DeliveryResult>)>> + Send + 'async_trait>>

where T: 'async_trait + TapMessageBody + Send + Sync + Debug + 'static, Self: Sync + 'async_trait, 'life0: 'async_trait,

Send a strongly-typed message

fn send_with_context<'life0, 'life1, 'async_trait, T>( &'life0 self, message: &'life1 T, deliver: bool, ) -> Pin<Box<dyn Future<Output = Result<(String, Vec<DeliveryResult>)>> + Send + 'async_trait>>

where T: TapMessageBody + MessageContext + Send + Sync + Debug + 'static + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send a message with MessageContext support for automatic routing

fn send_typed_with_context<'life0, 'async_trait, T>( &'life0 self, message: PlainMessage<T>, deliver: bool, ) -> Pin<Box<dyn Future<Output = Result<(String, Vec<DeliveryResult>)>> + Send + 'async_trait>>

where T: TapMessageBody + MessageContext + Send + Sync + Debug + 'static + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait,

Send a typed message with automatic context routing

fn receive_typed<'life0, 'life1, 'async_trait, T>( &'life0 self, raw_message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<PlainMessage<T>>> + Send + 'async_trait>>

where T: 'async_trait + TapMessageBody, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Receive and parse a typed message

impl Clone for TapAgent

fn clone(&self) -> TapAgent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TapAgent

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

Formats the value using the given formatter.