create_a_message returns Content::MultipleBlocks with StreamOption::ReturnOnce

It might be an API issue, but I thought I should raise the issue.

I'm able to parse the response any how.

  pub async fn text_generation_request(&self, req_config: &RequestConfig) -> Result<String> {
        let prompt = req_config.default_formatted_prompt.as_ref().unwrap();

        let request = MessagesRequestBuilder::new(model_id_to_enum(&self.model.model_id))
            .stream(StreamOption::ReturnOnce)
            .messages(vec![Message::user(prompt["user"]["content"].clone())])
            .system(SystemPrompt::new(prompt["system"]["content"].clone()))
            .max_tokens(
                MaxTokens::new(
                    req_config.actual_request_tokens.unwrap(),
                    model_id_to_enum(&self.model.model_id),

                )
                .map_err(|e| anyhow!(e))?,
            )
            .temperature(Temperature::new(req_config.temperature).map_err(|e| anyhow!(e))?)
            .top_p(TopP::new(req_config.top_p).map_err(|e| anyhow!(e))?)
            .build();

        match self.client().create_a_message(request).await {
            Ok(response) => match &response.content {
                Content::SingleText(content) => {
                    if self.logging_enabled {
                        tracing::info!(?response);
                    }
                    Ok(content.to_owned())
                }
                Content::MultipleBlocks(blocks) => {
                    if self.logging_enabled {
                        tracing::info!(?response);
                    }
                    if blocks.len() == 1 {
                        match &blocks[0] {
                            ContentBlock::Text(content) => Ok(content.text.to_owned()),
                            _ => panic!("Images not supported"),
                        }
                    } else {
                        panic!("MultipleBlocks not supported")
                    }
                }
            },
            Err(e) => {
                let error =
                    anyhow::format_err!("AnthropicBackend text_generation_request error: {}", e);

                if self.logging_enabled {
                    tracing::info!(?error);
                }
                Err(error)
            }
        }
    }

mochi-neko / clust

create_a_message returns Content::MultipleBlocks with StreamOption::ReturnOnce #3