Struct AgentClient 

pub struct AgentClient { /* private fields */ }

Main FEAGI Agent Client

This client handles:

• Registration with FEAGI
• Automatic heartbeat
• Sending sensory data
• Receiving motor data (for motor agents)
• Automatic deregistration on drop

Example

use feagi_agent::{AgentClient, AgentConfig, AgentType};

let config = AgentConfig::new("my_camera", AgentType::Sensory)
    .with_feagi_host("localhost")
    .with_vision_capability("camera", (640, 480), 3, "i_vision");

let mut client = AgentClient::new(config)?;
client.connect()?;

// Send sensory data
client.send_sensory_data(vec![(0, 50.0), (1, 75.0)])?;

// Client auto-deregisters on drop

Implementations

impl AgentClient

pub fn new(config: AgentConfig) -> Result<Self>

Create a new FEAGI agent client

Arguments

• config - Agent configuration

pub fn registration_body_json(&self) -> Option<&Value>

Get the last successful registration response body (JSON), if available.

This is only set after a successful connect() / registration step.

pub fn connect(&mut self) -> Result<()>

Connect to FEAGI and register the agent

This will:

1. Create ZMQ control sockets (registration/control)
2. Register with FEAGI
3. Create ZMQ data sockets (sensory/motor/viz)
4. Start heartbeat service (ONLY after successful registration)

IMPORTANT: Background threads are ONLY started AFTER successful registration. This prevents thread interference with GUI event loops (e.g., MuJoCo, Godot). If registration fails, NO threads are spawned.

TIMING: FEAGI starts its ZMQ data stream services asynchronously after processing the registration message. Data socket connection uses retry/backoff to handle stream readiness delays.

pub fn reconnect_data_streams(&mut self) -> Result<()>

Reconnect data sockets (sensory/motor/viz) using configured retry/backoff.

pub fn send_sensory_data(&self, neuron_pairs: Vec<(i32, f64)>) -> Result<()>

Send sensory data to FEAGI

Arguments

• neuron_pairs - Vector of (neuron_id, potential) pairs

Example

client.send_sensory_data(vec![
    (0, 50.0),
    (1, 75.0),
    (2, 30.0),
])?;

pub fn send_sensory_bytes(&self, bytes: Vec<u8>) -> Result<()>

Send pre-serialized sensory bytes to FEAGI (real-time semantics).

This is intended for high-performance clients (e.g., Python SDK brain_input) that already produce FeagiByteContainer bytes via Rust-side encoding caches.

Real-time policy:

• Uses ZMQ DONTWAIT to avoid blocking the caller.
• On backpressure (EAGAIN), the message is dropped (latest-only semantics).

pub fn try_send_sensory_bytes(&self, bytes: &[u8]) -> Result<bool>

Try sending pre-serialized sensory bytes to FEAGI (non-blocking), returning whether it was sent.

Returns:

• Ok(true) if the message was sent.
• Ok(false) if dropped due to backpressure (EAGAIN).
• Err(...) for other failures (not registered, socket errors).

pub fn receive_motor_data( &self, ) -> Result<Option<CorticalMappedXYZPNeuronVoxels>>

Receive motor data from FEAGI (non-blocking)

Returns None if no data is available. Motor data is in binary XYZP format (CorticalMappedXYZPNeuronVoxels).

Example

use feagi_structures::neuron_voxels::xyzp::CorticalMappedXYZPNeuronVoxels;

if let Some(motor_data) = client.receive_motor_data()? {
    // Process binary motor data
    for (cortical_id, neurons) in motor_data.iter() {
        println!("Motor area {:?}: {} neurons", cortical_id, neurons.len());
    }
}

pub fn receive_visualization_data(&self) -> Result<Option<Vec<u8>>>

Receive visualization data from FEAGI (non-blocking)

Returns None if no data is available.

Example

if let Some(viz_data) = client.receive_visualization_data()? {
    // Process neural activity data
    println!("Visualization data size: {} bytes", viz_data.len());
}

pub fn control_request( &self, method: &str, route: &str, data: Option<Value>, ) -> Result<Value>

Make a REST API request to FEAGI over ZMQ

Arguments

• method - HTTP method (GET, POST, PUT, DELETE)
• route - API route (e.g., “/v1/system/health_check”)
• data - Optional request body for POST/PUT requests

Example

// GET request
let health = client.control_request("GET", "/v1/system/health_check", None)?;

// POST request
let data = serde_json::json!({"key": "value"});
let response = client.control_request("POST", "/v1/some/endpoint", Some(data))?;

pub fn is_registered(&self) -> bool

Check if agent is registered

pub fn agent_id(&self) -> &str

Get agent ID

Trait Implementations

impl Drop for AgentClient

fn drop(&mut self)

Executes the destructor for this type.