Struct SyncClient 

pub struct SyncClient { /* private fields */ }

Synchronous client for communicating with Claude

Implementations

impl SyncClient

pub fn new(child: Child) -> Result<Self>

Create a new synchronous client from an existing child process

pub fn with_defaults() -> Result<Self>

Create a new synchronous client with default settings

pub fn resume_session(session_uuid: Uuid) -> Result<Self>

Resume a previous session by UUID This creates a new client that resumes an existing session

pub fn resume_session_with_model( session_uuid: Uuid, model: &str, ) -> Result<Self>

Resume a previous session with a specific model

pub fn query(&mut self, input: ClaudeInput) -> Result<Vec<ClaudeOutput>>

Send a query and collect all responses

pub fn query_stream( &mut self, input: ClaudeInput, ) -> Result<ResponseIterator<'_>>

Send a query and return an iterator over responses

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

Shutdown the client and wait for the process to exit

pub fn session_uuid(&self) -> Result<Uuid>

Get the session UUID if available Returns an error if no response has been received yet

pub fn ping(&mut self) -> bool

Test if the Claude connection is working by sending a ping message Returns true if Claude responds with “pong”, false otherwise

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

Enable the tool approval protocol by performing the initialization handshake.

After calling this method, the CLI will send ControlRequest messages when Claude wants to use a tool. You must handle these by calling send_control_response() with an appropriate response.

Important: The client must have been created with ClaudeCliBuilder::permission_prompt_tool("stdio") for this to work.

Example

use claude_codes::{SyncClient, ClaudeCliBuilder, ClaudeOutput, ControlRequestPayload};

let child = ClaudeCliBuilder::new()
    .model("sonnet")
    .permission_prompt_tool("stdio")
    .spawn_sync()?;

let mut client = SyncClient::new(child)?;
client.enable_tool_approval()?;

// Now when you receive messages, you may get ControlRequest messages
// that need responses

pub fn send_control_response(&mut self, response: ControlResponse) -> Result<()>

Send a control response back to the CLI.

Use this to respond to ControlRequest messages received during tool approval. The easiest way to create responses is using the helper methods on ToolPermissionRequest:

Example

use claude_codes::{SyncClient, ControlRequestPayload, ControlResponse, ToolPermissionRequest};

fn handle_permission(
    client: &mut SyncClient,
    perm_req: &ToolPermissionRequest,
    request_id: &str,
) -> claude_codes::Result<()> {
    let response = if perm_req.tool_name == "Bash" {
        perm_req.deny("Bash commands not allowed", request_id)
    } else {
        perm_req.allow(request_id)
    };
    client.send_control_response(response)
}

pub fn is_tool_approval_enabled(&self) -> bool

Check if tool approval protocol is enabled

Trait Implementations

impl Drop for SyncClient

fn drop(&mut self)

Executes the destructor for this type.