Method process

crates/opencode-session/src/llm.rs:303–383

Run the full stream processing loop with retry support. Returns `ProcessResult` matching the TS "compact" | "stop" | "continue".

(
        &mut self,
        stream_input: StreamInput,
        provider: Arc<dyn Provider>,
    )

    /// Run the full stream processing loop with retry support.
    /// Returns `ProcessResult` matching the TS "compact" | "stop" | "continue".
    pub async fn process(
        &mut self,
        stream_input: StreamInput,
        provider: Arc<dyn Provider>,
    ) -> ProcessResult {
        self.needs_compaction = false;
        self.model_limits = Some(resolve_model_limits(&stream_input, provider.as_ref()));

        loop {
            match self.process_stream(&stream_input, provider.clone()).await {
                Ok(()) => {}
                Err(e) => {
                    tracing::error!(
                        session_id = %self.session_id,
                        error = %e,
                        "Stream processing error"
                    );

                    let error =
                        crate::message_v2::error_from_anyhow(e, &stream_input.model.provider_id);

                    let retry_msg = retry::retryable(&error);
                    if let Some(retry_message) = retry_msg {
                        self.attempt += 1;

                        let api_info = match &error {
                            MessageError::ApiError {
                                message,
                                is_retryable,
                                response_headers,
                                response_body,
                                ..
                            } => Some(ApiErrorInfo {
                                message: message.clone(),
                                is_retryable: *is_retryable,
                                response_headers: response_headers.clone(),
                                response_body: response_body.clone(),
                            }),
                            _ => None,
                        };

                        let delay_ms = retry::delay(self.attempt, api_info.as_ref());

                        tracing::info!(
                            session_id = %self.session_id,
                            attempt = self.attempt,
                            delay_ms = delay_ms,
                            message = %retry_message,
                            "Retrying after error"
                        );

                        // Sleep with cancellation support
                        let _ =
                            retry::sleep_with_cancel(delay_ms, stream_input.abort.clone()).await;

                        continue;
                    }