Struct ModelClientSession 

pub struct ModelClientSession { /* private fields */ }

A turn-scoped streaming session created from a ModelClient.

The session establishes a Responses WebSocket connection lazily and reuses it across multiple requests within the turn. It also caches per-turn state:

• The last full request, so subsequent calls can reuse incremental websocket request payloads only when the current request is an incremental extension of the previous one.
• The x-codex-turn-state sticky-routing token, which must be replayed for all requests within the same turn.

Create a fresh ModelClientSession for each Codex turn. Reusing it across turns would replay the previous turn’s sticky-routing token into the next turn, which violates the client/server contract and can cause routing bugs.

Implementations

impl ModelClientSession

pub async fn preconnect_websocket( &mut self, session_telemetry: &SessionTelemetry, responses_metadata: &CodexResponsesMetadata, ) -> Result<(), ApiError>

Opportunistically preconnects a websocket for this turn-scoped client session.

This performs only connection setup; it never sends prompt payloads.

pub async fn prewarm_websocket( &mut self, prompt: &Prompt, model_info: &ModelInfo, session_telemetry: &SessionTelemetry, effort: Option<ReasoningEffortConfig>, summary: ReasoningSummaryConfig, service_tier: Option<String>, responses_metadata: &CodexResponsesMetadata, ) -> Result<()>

pub async fn stream( &mut self, prompt: &Prompt, model_info: &ModelInfo, session_telemetry: &SessionTelemetry, effort: Option<ReasoningEffortConfig>, summary: ReasoningSummaryConfig, service_tier: Option<String>, responses_metadata: &CodexResponsesMetadata, inference_trace: &InferenceTraceContext, ) -> Result<ResponseStream>

Streams a single model request within the current turn.

The caller is responsible for passing per-turn settings explicitly (model selection, reasoning settings, telemetry context, and turn metadata). This method will prefer the Responses WebSocket transport when the provider supports it and it remains healthy, and will fall back to the HTTP Responses API transport otherwise. The trace context may be enabled or disabled, but is always explicit so transport paths do not need separate trace/no-trace branches.

Trait Implementations

impl Drop for ModelClientSession

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.