How tauri http handles stream responses？

[wkl007]

Like fetch https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream/getReader

const response = await fetch(url);
const reader = response.body.getReader();

while (true) {
  const { value, done } = await reader.read();
  if (done) break;
  console.log('Received', value);
}

console.log('Response fully received');

[FabianLars]

This is something we'd like to support with v2 but with the current IPC this is basically impossible (the IPC works by sending json strings which really isn't optimal for streaming data).

That said, if the Web API you linked works for you, then you can use it too, Tauri's http client is currently more of a fallback if the built-in stuff doesn't work (cors issues for example)

[wkl007]

It is currently handled in the following way.

use futures_util::StreamExt;
use reqwest::{header, Client};
use std::collections::HashMap;
use std::str::from_utf8;
use tauri::{AppHandle, Manager, Runtime};

#[derive(Clone, serde::Serialize)]
pub struct StreamPayload {
    pub message: String,
    pub prompt: String,
}

#[tauri::command]
pub async fn receive_stream<R: Runtime>(
    app_handle: AppHandle<R>,
    url: &str,
    cookie: &str,
    prompt: &str,
) -> Result<String, String> {
    let mut data = HashMap::new();
    data.insert("prompt", prompt);

    let mut headers = header::HeaderMap::new();
    headers.insert(header::COOKIE, cookie.parse().unwrap());

    let client = Client::builder()
        .default_headers(headers)
        .build()
        .map_err(|err| format!("failed to generate client: {}", err))?;

    let mut stream = client
        .post(url)
        .json(&data)
        .send()
        .await
        .map_err(|err| format!("failed to call API: {}", err))?
        .bytes_stream();

    while let Some(item) = stream.next().await {
        match item {
            Ok(bytes) => {
                let chunk = from_utf8(&bytes).unwrap();
                // println!("{}", chunk);
                app_handle
                    .emit_all(
                        "fetch-stream-data",
                        StreamPayload {
                            message: chunk.to_string(),
                            prompt: prompt.to_string(),
                        },
                    )
                    .unwrap();
            }
            Err(e) => {
                eprintln!("Error: {}", e);
                break;
            }
        }
    }

    Ok("success".to_string())
}

[lukaesch]

I stumbled upon the same problem because I want to integrate a 3rd party lib (Anthropic AI) to stream content while solving the CORS problem .

From @FabianLars I understand the issue stems from Tauri's current HTTP client implementation.

A potential workaround could involve implementing custom streaming logic on the Rust side, as you've demonstrated. This approach would use Tauri's event system to emit chunks of data as they're received, simulating a stream-like behavior in the frontend.

Or (if your use case allows it) you might consider using the Web Fetch API directly when possible, falling back to Tauri's HTTP client only when necessary (e.g., for CORS issues).