Method handle_response

crates/chat-cli/src/cli/chat/mod.rs:2812–3267

Sends a [crate::api_client::ApiClient::send_message] request to the backend and consumes the response stream. In order to handle sigints while also keeping track of metadata about how the response stream was handled, we need an extra parameter: `request_metadata_lock` - Updated with the [RequestMetadata] once it has been received (either though a successful request, or on an error).

(
        &mut self,
        os: &mut Os,
        state: crate::api_client::model::ConversationState,
        request_metadata_lock: Arc<Mutex<Option<RequestMetadata>>>,
    )

    /// * `request_metadata_lock` - Updated with the [RequestMetadata] once it has been received
    ///   (either though a successful request, or on an error).
    async fn handle_response(
        &mut self,
        os: &mut Os,
        state: crate::api_client::model::ConversationState,
        request_metadata_lock: Arc<Mutex<Option<RequestMetadata>>>,
    ) -> Result<ChatState, ChatError> {
        let mut rx = self.send_message(os, state, request_metadata_lock, None).await?;

        let request_id = rx.request_id().map(String::from);

        let mut buf = String::new();
        let mut offset = 0;
        let mut ended = false;
        let terminal_width = match self.wrap {
            Some(WrapMode::Never) => None,
            Some(WrapMode::Always) => Some(self.terminal_width()),
            Some(WrapMode::Auto) | None => {
                if std::io::stdout().is_terminal() {
                    Some(self.terminal_width())
                } else {
                    None
                }
            },
        };

        let mut state = ParseState::new(
            terminal_width,
            os.database.settings.get_bool(Setting::ChatDisableMarkdownRendering),
        );
        let mut response_prefix_printed = false;

        let mut tool_uses = Vec::new();
        let mut tool_name_being_recvd: Option<String> = None;

        if self.spinner.is_some() {
            drop(self.spinner.take());
            queue!(
                self.stderr,
                terminal::Clear(terminal::ClearType::CurrentLine),
                cursor::MoveToColumn(0),
            )?;
        }

        loop {
            match rx.recv().await {
                Some(Ok(msg_event)) => {
                    trace!("Consumed: {:?}", msg_event);

                    match msg_event {
                        parser::ResponseEvent::ToolUseStart { name } => {
                            // We need to flush the buffer here, otherwise text will not be
                            // printed while we are receiving tool use events.
                            buf.push('\n');
                            tool_name_being_recvd = Some(name);
                        },
                        parser::ResponseEvent::AssistantText(text) => {
                            if self.stdout.should_send_structured_event {
                                if !response_prefix_printed && !text.trim().is_empty() {