Module client 

Public Client - the entry point consumers hold.

Client is a cheap-clone handle (Arc-backed) over a background reader task that owns the claude subprocess. All methods take &self, so the same Client can be passed by reference into multiple tasks. The events stream is returned alongside the Client at spawn time as a ClientEvents receiver - single-consumer, independent of the writer-side handle.

Internally:

• The reader task pulls lines from the subprocess, decodes them, pushes regular Messages onto an mpsc that backs the returned ClientEvents, dispatches inbound control_requests on detached tasks, and routes outbound control_responses to per-request oneshots so Client::send_control callers can await their typed reply.
• The writer half is a clonable SharedWriter cloned from Subprocess; outbound writes go through it without contending on &mut self.

Re-exports

pub(crate) use control_dispatch::ControlDispatchHandle; 🔒

use std::collections::HashMap; 🔒

use std::collections::VecDeque; 🔒

use std::sync::Arc; 🔒

use std::sync::atomic::AtomicBool; 🔒

use std::sync::atomic::Ordering; 🔒

use tokio::sync::Mutex; 🔒

use tokio::sync::mpsc; 🔒

use tokio::sync::oneshot; 🔒

use tokio::task::JoinHandle; 🔒

use tracing::debug; 🔒

use crate::Error; 🔒

use crate::client::runtime::PendingControls; 🔒

use crate::client::runtime::SharedSessionId; 🔒

use crate::client::runtime::excerpt; 🔒

use crate::client::runtime::spawn_reader_task; 🔒

use crate::mcp::orchestration::McpHosts; 🔒

use crate::options::Options; 🔒

use crate::transport::codec::DecodedLine; 🔒

use crate::transport::codec::decode_dispatch; 🔒

use crate::transport::process::Subprocess; 🔒

use forge_primitives::Message; 🔒

Modules

control_dispatch 🔒

Inbound control_request dispatch: ControlDispatchHandle routes permission checks, MCP JSON-RPC, and hook callbacks to the appropriate handler and writes the matching control_response via a clonable SharedWriter.

control_send 🔒

Outbound control_request typed wrappers - the user-facing commands (interrupt, set_permission_mode, set_model, mcp_reconnect, mcp_toggle, stop_task, mcp_status, get_context_usage) plus the _raw escape hatches for mcp_status and get_context_usage.

runtime 🔒

Background runtime for Client - owns the subprocess reader, decodes incoming frames, dispatches inbound control_requests on detached tasks, and routes outbound control_responses to the PendingControls map so send_control callers can await their typed reply.

Structs

Client

An active claude binary subprocess.

ClientInner 🔒

PendingGuard 🔒

Removes a pending_controls entry when the awaiting future is dropped without a response having been routed - the drop guard send_control parks in its future.

Constants

INIT_HANDSHAKE_TIMEOUT

Budget for the initialize handshake inside Client::spawn. A wedged CLI (alive, stdout open, never answering) would otherwise park the caller forever with the child leaked.

Type Aliases

ClientEvents

Stream of regular Messages produced by the reader task. Returned alongside Client from Client::spawn. Single-consumer; the writer-side Client is Clone and can move freely between tasks while one task owns the receiver.