Struct OpenResponsesProtocolChatDriver 

pub struct OpenResponsesProtocolChatDriver { /* private fields */ }

Implementations

impl OpenResponsesProtocolChatDriver

pub fn new(api_key: impl Into<String>) -> OpenResponsesProtocolChatDriver

Create a new driver with the given API key

pub fn with_base_url( api_key: impl Into<String>, api_url: impl Into<String>, ) -> OpenResponsesProtocolChatDriver

Create a new driver with a custom API URL

pub fn with_provider_type( self, provider_type: DriverId, ) -> OpenResponsesProtocolChatDriver

Set the model provider used for provider-specific request features.

pub fn with_request_extension( self, extension: Arc<dyn OpenResponsesRequestExtension>, ) -> OpenResponsesProtocolChatDriver

Attach a provider-specific request-body decorator. The decorator runs on every chat request just before it is sent (see OpenResponsesRequestExtension).

pub fn with_auth_provider( self, provider: Arc<dyn AuthHeaderProvider>, ) -> OpenResponsesProtocolChatDriver

Set a pluggable AuthHeaderProvider that overrides the default host-keyed api-key / bearer auth. The provider is awaited once per HTTP attempt (including retries), so refreshable OAuth providers (ChatGPT/Codex, Entra ID, workload identity, …) can mint or refresh tokens per request without the driver knowing the scheme. The resolved auth header takes precedence over any header set by an OpenResponsesRequestExtension::decorate_headers.

pub fn with_retry_config( self, config: LlmRetryConfig, ) -> OpenResponsesProtocolChatDriver

Configure retry behavior for rate limit errors

pub fn api_url(&self) -> &str

Get the API URL

pub fn api_key(&self) -> &str

Get the API key (for subclass access)

pub fn client(&self) -> &Client

Get the HTTP client (for subclass access)

pub fn provider_type(&self) -> &DriverId

Get the provider type used for model profile lookup.

pub async fn compact( &self, request: CompactRequest, ) -> Result<CompactResponse, AgentLoopError>

Compact a conversation to reduce context size

This method calls the /v1/responses/compact endpoint to compress the conversation history. User messages are kept verbatim, while assistant messages, tool calls, and tool results are replaced by an encrypted compaction item.

Arguments

• request - The compact request containing the model and input items

Returns

Returns a CompactResponse containing the compacted output items. The output can be used directly as input for the next /v1/responses call.

Example

use everruns_core::{OpenResponsesProtocolChatDriver, CompactRequest, CompactInputItem, CompactContent};

let driver = OpenResponsesProtocolChatDriver::new("your-api-key");

let request = CompactRequest {
    model: "gpt-4o".to_string(),
    input: vec![
        CompactInputItem::Message {
            role: "user".to_string(),
            content: CompactContent::Text("Hello!".to_string()),
        },
    ],
    previous_response_id: None,
    instructions: None,
};

let response = driver.compact(request).await?;
// Use response.output as input for the next /v1/responses call

pub fn supports_compact(&self) -> bool

Check if this driver supports the compact endpoint

Returns true for OpenAI’s Responses API. Custom endpoints may or may not support compaction.

Trait Implementations

impl ChatDriver for OpenResponsesProtocolChatDriver

fn supports_parallel_tool_calls(&self, _model: &str) -> bool

The Responses API accepts the top-level parallel_tool_calls boolean.

fn supports_stateful_responses(&self) -> bool

Whether this driver persists Responses API state and can resolve tool calls that are reachable only through previous_response_id.

fn chat_completion_stream<'life0, 'life1, 'async_trait>( &'life0 self, messages: Vec<LlmMessage>, config: &'life1 LlmCallConfig, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<LlmStreamEvent, AgentLoopError>> + Send>>, AgentLoopError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, OpenResponsesProtocolChatDriver: 'async_trait,

Call the LLM with streaming response

fn supports_compact(&self) -> bool

Check if this driver supports the compact endpoint

fn compact<'life0, 'async_trait>( &'life0 self, request: CompactRequest, ) -> Pin<Box<dyn Future<Output = Result<Option<CompactResponse>, AgentLoopError>> + Send + 'async_trait>>

where 'life0: 'async_trait, OpenResponsesProtocolChatDriver: 'async_trait,

Compact a conversation to reduce context size

fn chat_completion<'life0, 'life1, 'async_trait>( &'life0 self, messages: Vec<LlmMessage>, config: &'life1 LlmCallConfig, ) -> Pin<Box<dyn Future<Output = Result<LlmResponse, AgentLoopError>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Call the LLM without streaming (convenience method)

fn list_models<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<DiscoveredModel>>, AgentLoopError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

List available models from the provider

impl Clone for OpenResponsesProtocolChatDriver

fn clone(&self) -> OpenResponsesProtocolChatDriver

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OpenResponsesProtocolChatDriver

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.