Struct TPCPNode 

pub struct TPCPNode {
    pub identity: AgentIdentity,
    pub memory: Arc<RwLock<LWWMap>>,
    pub dlq: Arc<DLQ>,
    /* private fields */
}

Async TPCP node backed by tokio and tokio-tungstenite.

Fields

identity: AgentIdentity

memory: Arc<RwLock<LWWMap>>

dlq: Arc<DLQ>

Implementations

impl TPCPNode

pub fn new(identity: AgentIdentity) -> Self

Creates a new TPCPNode with the given identity and no signing key.

Examples found in repository

examples/hello.rs (line 16)

async fn main() {
    // Server
    let server_identity = AgentIdentity {
        agent_id: "server-001".into(),
        framework: "hello-server".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let server = Arc::new(TPCPNode::new(server_identity));

    server.register_handler(Intent::Handshake, |env| {
        println!("Server received HANDSHAKE from {}", env.header.sender_id);
        println!("Payload: {}", env.payload);
    }).await;

    server.listen("127.0.0.1:9001").await.expect("failed to listen");
    sleep(Duration::from_millis(100)).await; // let server bind

    // Client
    let client_identity = AgentIdentity {
        agent_id: "client-001".into(),
        framework: "hello-client".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let client = TPCPNode::new(client_identity);

    client.send_message(
        "ws://127.0.0.1:9001",
        "server-001",
        Intent::Handshake,
        serde_json::json!({"payload_type": "text", "content": "hello from Rust client"}),
    ).await.expect("send failed");

    sleep(Duration::from_millis(200)).await;
    println!("TPCP Rust SDK hello example completed.");
}

pub fn with_signing_key(identity: AgentIdentity, key: SigningKey) -> Self

Creates a TPCPNode that signs all outbound messages.

pub async fn register_peer_key(&self, agent_id: &str, public_key_b64: &str)

Registers a peer’s public key for inbound signature verification.

pub async fn register_handler<F>(&self, intent: Intent, handler: F)

where F: Fn(TPCPEnvelope) + Send + Sync + 'static,

Registers a handler for a specific intent.

Examples found in repository

examples/hello.rs (lines 18-21)

async fn main() {
    // Server
    let server_identity = AgentIdentity {
        agent_id: "server-001".into(),
        framework: "hello-server".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let server = Arc::new(TPCPNode::new(server_identity));

    server.register_handler(Intent::Handshake, |env| {
        println!("Server received HANDSHAKE from {}", env.header.sender_id);
        println!("Payload: {}", env.payload);
    }).await;

    server.listen("127.0.0.1:9001").await.expect("failed to listen");
    sleep(Duration::from_millis(100)).await; // let server bind

    // Client
    let client_identity = AgentIdentity {
        agent_id: "client-001".into(),
        framework: "hello-client".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let client = TPCPNode::new(client_identity);

    client.send_message(
        "ws://127.0.0.1:9001",
        "server-001",
        Intent::Handshake,
        serde_json::json!({"payload_type": "text", "content": "hello from Rust client"}),
    ).await.expect("send failed");

    sleep(Duration::from_millis(200)).await;
    println!("TPCP Rust SDK hello example completed.");
}

pub async fn connect( &self, url: &str, ) -> Result<(), Box<dyn Error + Send + Sync>>

Connects as a WebSocket client to the given URL.

pub async fn listen( &self, addr: &str, ) -> Result<(), Box<dyn Error + Send + Sync>>

Starts listening on the given address (e.g. “127.0.0.1:9001”).

Examples found in repository

examples/hello.rs (line 23)

async fn main() {
    // Server
    let server_identity = AgentIdentity {
        agent_id: "server-001".into(),
        framework: "hello-server".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let server = Arc::new(TPCPNode::new(server_identity));

    server.register_handler(Intent::Handshake, |env| {
        println!("Server received HANDSHAKE from {}", env.header.sender_id);
        println!("Payload: {}", env.payload);
    }).await;

    server.listen("127.0.0.1:9001").await.expect("failed to listen");
    sleep(Duration::from_millis(100)).await; // let server bind

    // Client
    let client_identity = AgentIdentity {
        agent_id: "client-001".into(),
        framework: "hello-client".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let client = TPCPNode::new(client_identity);

    client.send_message(
        "ws://127.0.0.1:9001",
        "server-001",
        Intent::Handshake,
        serde_json::json!({"payload_type": "text", "content": "hello from Rust client"}),
    ).await.expect("send failed");

    sleep(Duration::from_millis(200)).await;
    println!("TPCP Rust SDK hello example completed.");
}

pub async fn send_message( &self, url: &str, receiver_id: &str, intent: Intent, payload: Value, ) -> Result<(), Box<dyn Error + Send + Sync>>

Sends a message to the given WebSocket URL. receiver_id is the target agent’s agent_id (not the URL).

Examples found in repository

examples/hello.rs (lines 36-41)

async fn main() {
    // Server
    let server_identity = AgentIdentity {
        agent_id: "server-001".into(),
        framework: "hello-server".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let server = Arc::new(TPCPNode::new(server_identity));

    server.register_handler(Intent::Handshake, |env| {
        println!("Server received HANDSHAKE from {}", env.header.sender_id);
        println!("Payload: {}", env.payload);
    }).await;

    server.listen("127.0.0.1:9001").await.expect("failed to listen");
    sleep(Duration::from_millis(100)).await; // let server bind

    // Client
    let client_identity = AgentIdentity {
        agent_id: "client-001".into(),
        framework: "hello-client".into(),
        capabilities: vec![],
        public_key: "".into(),
        modality: vec!["text".into()],
    };
    let client = TPCPNode::new(client_identity);

    client.send_message(
        "ws://127.0.0.1:9001",
        "server-001",
        Intent::Handshake,
        serde_json::json!({"payload_type": "text", "content": "hello from Rust client"}),
    ).await.expect("send failed");

    sleep(Duration::from_millis(200)).await;
    println!("TPCP Rust SDK hello example completed.");
}