Struct InteractiveClient 

pub struct InteractiveClient { /* private fields */ }

Interactive client for stateful conversations with Claude

This is the recommended client for interactive use. It provides a clean API that matches the Python SDK’s functionality.

Implementations

impl InteractiveClient

pub fn new(options: ClaudeCodeOptions) -> Result<Self>

Create a new client

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

Connect to Claude

pub async fn send_and_receive(&mut self, prompt: String) -> Result<Vec<Message>>

Send a message and receive all messages until Result message

pub async fn send_message(&mut self, prompt: String) -> Result<()>

Send a message without waiting for response

pub async fn receive_response(&mut self) -> Result<Vec<Message>>

Receive messages until Result message (convenience method like Python SDK)

pub async fn receive_messages_stream( &mut self, ) -> impl Stream<Item = Result<Message>> + '_

Receive messages as a stream (streaming output support)

Returns a stream of messages that can be iterated over asynchronously. This is similar to Python SDK’s receive_messages() method.

Example

use cc_sdk::{InteractiveClient, ClaudeCodeOptions};
use futures::StreamExt;
 
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut client = InteractiveClient::new(ClaudeCodeOptions::default())?;
    client.connect().await?;
     
    // Send a message
    client.send_message("Hello!".to_string()).await?;
     
    // Receive messages as a stream
    let mut stream = client.receive_messages_stream().await;
    while let Some(msg) = stream.next().await {
        match msg {
            Ok(message) => println!("Received: {:?}", message),
            Err(e) => eprintln!("Error: {}", e),
        }
    }
     
    Ok(())
}

pub async fn receive_response_stream( &mut self, ) -> impl Stream<Item = Result<Message>> + '_

Receive messages as an async iterator until a Result message

This is a convenience method that collects messages until a Result message is received, similar to Python SDK’s receive_response().

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

Send interrupt signal to cancel current operation

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

Disconnect