Struct ConnectorClient 

pub struct ConnectorClient { /* private fields */ }

gRPC client for connector communication

Supports two transport modes:

• TransportType::Grpc (default): Native gRPC over HTTP/2
• TransportType::WebSocket: WebSocket over HTTP/1.1 (for corporate proxy compatibility)

Example

use strike48_connector::{ConnectorClient, client::{ClientOptions, TransportType}};

// Using native gRPC (default)
let client = ConnectorClient::new("connectors-poc-us.strike48.com:443".to_string(), true);

// Using WebSocket for corporate proxy compatibility
let client = ConnectorClient::with_options(ClientOptions {
    host: "connectors-poc-us.strike48.com:443".to_string(),
    use_tls: true,
    transport: TransportType::WebSocket,
    default_timeout_ms: 30000,
});

Implementations

impl ConnectorClient

pub fn new(host: String, use_tls: bool) -> Self

Create a new ConnectorClient with default transport (gRPC).

For URL-based transport auto-detection, use with_options with url.

pub fn with_options(opts: ClientOptions) -> Self

Create a new ConnectorClient with full configuration.

Transport is auto-detected from URL scheme when using url option:

• grpc:// or grpcs:// → gRPC transport
• ws://, wss://, http://, https:// → WebSocket transport

Examples

// Auto-detect transport from URL (recommended)
let client = ConnectorClient::with_options(ClientOptions {
    url: Some("grpcs://connectors.example.com:443".to_string()),
    ..Default::default()
});

// WebSocket transport (auto-detected from wss://)
let client = ConnectorClient::with_options(ClientOptions {
    url: Some("wss://connectors.example.com:443".to_string()),
    ..Default::default()
});

pub async fn connect_channel(&mut self) -> Result<()>

Connect to Strike48 server using the configured transport.

Uses the configured transport:

• TransportType::Grpc: Native gRPC over HTTP/2 (default)
• TransportType::WebSocket: WebSocket over HTTP/1.1 (for corporate proxy compatibility)

pub async fn send_register_request( &self, tenant_id: &str, connector_type: &str, instance_id: &str, capabilities: &ConnectorCapabilities, auth_token: &str, ) -> Result<()>

Send registration request on the stream Note: Registration happens through the bidirectional stream, not a separate RPC

pub async fn start_stream_with_registration( &mut self, initial_message: ProtoStreamMessage, ) -> Result<(UnboundedSender<ProtoStreamMessage>, UnboundedReceiver<ProtoStreamMessage>)>

Start bidirectional streaming using the transport abstraction.

This method works identically for both gRPC and WebSocket transports. The transport handles protocol-specific details internally.

A background keepalive task is automatically spawned that sends HeartbeatRequest messages every 30 seconds. This prevents the server’s session reaper (90s timeout) from killing the session, regardless of whether the caller sends their own metrics/heartbeats.

pub async fn send_message(&self, message: ProtoStreamMessage) -> Result<()>

Send a message on the stream

pub async fn set_session_token(&self, token: String)

Set session token

pub async fn send_response(&self, response: ExecuteResponse) -> Result<()>

Send execute response

pub async fn disconnect(&mut self)

Disconnect from Strike48 server

pub fn is_connected(&self) -> bool

Check if connected (lock-free atomic check)

pub fn is_registered(&self) -> bool

Check if registered (lock-free atomic check)

pub fn mark_registered(&self)

Mark this client as successfully registered with the server.

pub async fn invoke_capability( &self, target_address: &str, payload: Vec<u8>, options: InvokeOptions, ) -> Result<Option<InvokeCapabilityResponse>>

Invoke a capability on another connector through Strike48 routing

pub fn get_default_timeout(&self) -> Option<u64>

Get default timeout in milliseconds