Method send_message

crates/chat-cli/src/cli/chat/parser.rs:207–268

Sends a SendMessage request to the backend, returning the response stream to consume. You should repeatedly call [Self::recv] to receive [ResponseEvent]'s until a [ResponseEvent::EndStream] value is returned. # Arguments `client` - api client to make the request with `conversation_state` - the [crate::api_client::model::ConversationState] to send `request_metadata_lock` - a mutex that will be u

(
        client: &ApiClient,
        conversation_state: ConversationState,
        request_metadata_lock: Arc<Mutex<Option<RequestMetadata>>>,
        message_meta_tags: Option<Vec<MessageMetaTag>>,

    /// future is aborted in the sigint case). The task will gracefully end with updating the mutex
    /// with [RequestMetadata].
    pub async fn send_message(
        client: &ApiClient,
        conversation_state: ConversationState,
        request_metadata_lock: Arc<Mutex<Option<RequestMetadata>>>,
        message_meta_tags: Option<Vec<MessageMetaTag>>,
    ) -> Result<Self, SendMessageError> {
        let message_id = uuid::Uuid::new_v4().to_string();
        info!(?message_id, "Generated new message id");
        let user_prompt_length = conversation_state.user_input_message.content.len();
        let model_id = conversation_state.user_input_message.model_id.clone();
        let message_meta_tags = message_meta_tags.unwrap_or_default();

        let cancel_token = CancellationToken::new();
        let cancel_token_clone = cancel_token.clone();

        let start_time = Instant::now();
        let start_time_sys = SystemTime::now();
        debug!(?start_time, "sending send_message request");
        let response = client
            .send_message(conversation_state)
            .await
            .map_err(|err| SendMessageError {
                source: err,
                request_metadata: RequestMetadata {
                    message_id: message_id.clone(),
                    request_start_timestamp_ms: system_time_to_unix_ms(start_time_sys),
                    stream_end_timestamp_ms: system_time_to_unix_ms(SystemTime::now()),
                    model_id: model_id.clone(),
                    user_prompt_length,
                    message_meta_tags: message_meta_tags.clone(),
                    // Other fields are irrelevant if we can't get a successful response
                    ..Default::default()
                },
            })?;
        let elapsed = start_time.elapsed();
        debug!(?elapsed, "send_message succeeded");

        let request_id = response.request_id().map(str::to_string);
        let (ev_tx, ev_rx) = mpsc::channel(16);
        tokio::spawn(async move {
            ResponseParser::new(
                response,
                message_id,
                model_id,
                user_prompt_length,
                message_meta_tags,
                ev_tx,
                start_time,
                start_time_sys,
                cancel_token_clone,
                request_metadata_lock,
            )
            .try_recv()
            .await;
        });

        Ok(Self {
            request_id,