@perspective-dev/viewer 5.1.0 → 5.2.0

package/src/rust/agent/client/protocol.rs

@@ -0,0 +1,320 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The OpenAI chat-completions wire shapes — only the fields this client
+//! produces or consumes. Unknown response fields are ignored by serde, so
+//! provider-specific extras (`usage`, `finish_reason`, ids) cost nothing.
+//! The format is pinned by the `test/js/agent/` specs, which assert these
+//! exact shapes against a scripted fake engine.
+
+use serde::{Deserialize, Serialize};
+use serde_json::Value;
+
+/// One conversation message, tagged by `role`. `Assistant` doubles as the
+/// response-message shape (`choices[n].message`).
+#[derive(Clone, Deserialize, Serialize)]
+#[serde(tag = "role", rename_all = "lowercase")]
+pub enum ChatMessage {
+    System {
+        content: String,
+    },
+    User {
+        content: String,
+    },
+    Assistant {
+        #[serde(default, skip_serializing_if = "Option::is_none")]
+        content: Option<String>,
+        #[serde(default, skip_serializing_if = "Vec::is_empty")]
+        tool_calls: Vec<ToolCall>,
+
+        /// Reasoning-model "thinking" text, captured for DISPLAY only:
+        /// `skip_serializing` is the contract that it is never replayed
+        /// into a request (providers reject or mis-tokenize replayed
+        /// reasoning). Two wire conventions, one field: DeepSeek-style
+        /// `reasoning_content` (also LM Studio/vLLM) and OpenRouter's
+        /// `reasoning`.
+        #[serde(default, skip_serializing, alias = "reasoning")]
+        reasoning_content: Option<String>,
+    },
+    Tool {
+        tool_call_id: String,
+        content: String,
+    },
+}
+
+/// A model-emitted tool invocation, echoed back verbatim in the transcript
+/// so the model can correlate `Tool` results by `id`.
+#[derive(Clone, Deserialize, Serialize)]
+pub struct ToolCall {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default = "function_type", rename = "type")]
+    pub kind: String,
+    pub function: FunctionCall,
+}
+
+/// `arguments` is a JSON-*encoded string* per the OpenAI wire format, not a
+/// JSON object.
+#[derive(Clone, Deserialize, Serialize)]
+pub struct FunctionCall {
+    pub name: String,
+    #[serde(default)]
+    pub arguments: String,
+}
+
+fn function_type() -> String {
+    "function".to_owned()
+}
+
+/// A tool advertised to the model.
+#[derive(Serialize)]
+pub struct ToolDef {
+    #[serde(rename = "type")]
+    pub kind: &'static str,
+    pub function: FunctionDef,
+}
+
+#[derive(Serialize)]
+pub struct FunctionDef {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub parameters: Value,
+}
+
+#[derive(Serialize)]
+pub struct ChatRequest<'a> {
+    pub model: &'a str,
+    pub messages: &'a [ChatMessage],
+    pub tools: &'a [ToolDef],
+
+    /// Always `true`; servers that ignore it get the buffered fallback in
+    /// `transport.rs`, so streaming needs no configuration surface.
+    pub stream: bool,
+}
+
+#[derive(Deserialize)]
+pub struct ChatResponse {
+    pub choices: Vec<ChatChoice>,
+}
+
+#[derive(Deserialize)]
+pub struct ChatChoice {
+    pub message: ChatMessage,
+}
+
+/// One `stream: true` SSE frame (`data: {...}`) — the delta shapes of the
+/// OpenAI streaming wire format.
+#[derive(Deserialize)]
+pub struct ChatChunk {
+    #[serde(default)]
+    pub choices: Vec<ChunkChoice>,
+}
+
+#[derive(Deserialize)]
+pub struct ChunkChoice {
+    #[serde(default)]
+    pub delta: ChunkDelta,
+}
+
+#[derive(Default, Deserialize)]
+pub struct ChunkDelta {
+    #[serde(default)]
+    pub content: Option<String>,
+    #[serde(default)]
+    pub reasoning_content: Option<String>,
+    #[serde(default)]
+    pub reasoning: Option<String>,
+    #[serde(default)]
+    pub tool_calls: Vec<ToolCallDelta>,
+}
+
+/// Tool-call fragments accumulate BY INDEX: `id`/`name` arrive on the
+/// first fragment, `arguments` arrives as string parts across many.
+#[derive(Deserialize)]
+pub struct ToolCallDelta {
+    #[serde(default)]
+    pub index: usize,
+    #[serde(default)]
+    pub id: Option<String>,
+    #[serde(default)]
+    pub function: Option<FunctionCallDelta>,
+}
+
+#[derive(Deserialize)]
+pub struct FunctionCallDelta {
+    #[serde(default)]
+    pub name: Option<String>,
+    #[serde(default)]
+    pub arguments: Option<String>,
+}
+
+/// Folds a stream of [`ChatChunk`]s into the same
+/// [`ChatMessage::Assistant`] the buffered path produces, so `turn.rs` is
+/// agnostic to how the response arrived. Reasoning takes the first
+/// non-empty of the two wire conventions per delta.
+#[derive(Default)]
+pub struct ChunkAccumulator {
+    content: String,
+    reasoning: String,
+    tool_calls: Vec<ToolCall>,
+}
+
+impl ChunkAccumulator {
+    pub fn push(&mut self, chunk: ChatChunk) {
+        for choice in chunk.choices {
+            let delta = choice.delta;
+            if let Some(content) = delta.content {
+                self.content.push_str(&content);
+            }
+
+            if let Some(reasoning) = delta
+                .reasoning_content
+                .into_iter()
+                .chain(delta.reasoning)
+                .find(|x| !x.is_empty())
+            {
+                self.reasoning.push_str(&reasoning);
+            }
+
+            for fragment in delta.tool_calls {
+                if self.tool_calls.len() <= fragment.index {
+                    self.tool_calls
+                        .resize_with(fragment.index + 1, || ToolCall {
+                            id: String::new(),
+                            kind: function_type(),
+                            function: FunctionCall {
+                                name: String::new(),
+                                arguments: String::new(),
+                            },
+                        });
+                }
+
+                let call = &mut self.tool_calls[fragment.index];
+                if let Some(id) = fragment.id {
+                    call.id = id;
+                }
+
+                if let Some(function) = fragment.function {
+                    if let Some(name) = function.name {
+                        call.function.name = name;
+                    }
+
+                    if let Some(arguments) = function.arguments {
+                        call.function.arguments.push_str(&arguments);
+                    }
+                }
+            }
+        }
+    }
+
+    /// Accumulated text/reasoning so far, for live-render callbacks.
+    pub fn progress(&self) -> (&str, &str) {
+        (&self.content, &self.reasoning)
+    }
+
+    pub fn finish(self) -> ChatMessage {
+        ChatMessage::Assistant {
+            content: (!self.content.is_empty()).then_some(self.content),
+            tool_calls: self.tool_calls,
+            reasoning_content: (!self.reasoning.is_empty()).then_some(self.reasoning),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn chunk(json: &str) -> ChatChunk {
+        serde_json::from_str(json).unwrap()
+    }
+
+    #[test]
+    fn content_and_both_reasoning_conventions_fold() {
+        let mut acc = ChunkAccumulator::default();
+        acc.push(chunk(r#"{"choices":[{"delta":{"role":"assistant"}}]}"#));
+        acc.push(chunk(
+            r#"{"choices":[{"delta":{"reasoning_content":"th"}}]}"#,
+        ));
+        acc.push(chunk(r#"{"choices":[{"delta":{"reasoning":"ink"}}]}"#));
+        acc.push(chunk(r#"{"choices":[{"delta":{"content":"Hel"}}]}"#));
+        acc.push(chunk(
+            r#"{"choices":[{"delta":{"content":"lo","reasoning":""}}]}"#,
+        ));
+        assert_eq!(acc.progress(), ("Hello", "think"));
+        let ChatMessage::Assistant {
+            content,
+            tool_calls,
+            reasoning_content,
+        } = acc.finish()
+        else {
+            panic!("not assistant");
+        };
+
+        assert_eq!(content.as_deref(), Some("Hello"));
+        assert!(tool_calls.is_empty());
+        assert_eq!(reasoning_content.as_deref(), Some("think"));
+    }
+
+    #[test]
+    fn fragmented_tool_arguments_accumulate_by_index() {
+        let mut acc = ChunkAccumulator::default();
+        acc.push(chunk(
+            r#"{"choices":[{"delta":{"tool_calls":[
+                {"index":0,"id":"c0","function":{"name":"get_schema","arguments":""}}]}}]}"#,
+        ));
+
+        // Index 1 opens before index 0 finishes; both argument streams
+        // interleave.
+        acc.push(chunk(
+            r#"{"choices":[{"delta":{"tool_calls":[
+                {"index":1,"id":"c1","function":{"name":"set_view_config","arguments":"{\"con"}}]}}]}"#,
+        ));
+
+        acc.push(chunk(
+            r#"{"choices":[{"delta":{"tool_calls":[
+                {"index":1,"function":{"arguments":"fig\":{}}"}}]}}]}"#,
+        ));
+
+        let ChatMessage::Assistant { tool_calls, .. } = acc.finish() else {
+            panic!("not assistant");
+        };
+
+        assert_eq!(tool_calls.len(), 2);
+        assert_eq!(tool_calls[0].id, "c0");
+        assert_eq!(tool_calls[0].function.name, "get_schema");
+        assert_eq!(tool_calls[1].function.arguments, "{\"config\":{}}");
+        assert_eq!(tool_calls[1].kind, "function");
+    }
+
+    /// The display-only contract: reasoning deserializes from EITHER wire
+    /// field but NEVER serializes back into a request.
+    #[test]
+    fn assistant_reasoning_reads_both_aliases_and_never_serializes() {
+        for field in ["reasoning_content", "reasoning"] {
+            let message: ChatMessage = serde_json::from_str(&format!(
+                r#"{{"role":"assistant","content":"hi","{field}":"secret"}}"#
+            ))
+            .unwrap();
+
+            let ChatMessage::Assistant {
+                reasoning_content, ..
+            } = &message
+            else {
+                panic!("not assistant");
+            };
+
+            assert_eq!(reasoning_content.as_deref(), Some("secret"));
+            assert!(!serde_json::to_string(&message).unwrap().contains("secret"));
+        }
+    }
+}

package/src/rust/agent/client/transport.rs

@@ -0,0 +1,287 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! How completion requests move: browser `fetch()` for HTTP providers, or a
+//! host-supplied duck-typed engine object (WebLLM's `MLCEngine`, or the
+//! scripted fake the Playwright specs inject) — the same seam either way,
+//! so the offline specs exercise the identical request/response path the
+//! HTTP providers use.
+//!
+//! Every request asks for `stream: true` and every response path degrades
+//! automatically, so streaming needs no configuration surface: an HTTP
+//! response that is not `text/event-stream` and an engine result that is
+//! not async-iterable are both consumed as complete buffered responses.
+//! Either way the caller receives ONE folded [`ChatMessage`], with
+//! incremental progress reported through `on_delta`.
+
+use perspective_js::utils::{ApiError, ApiResult};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen_futures::JsFuture;
+
+use super::protocol::{ChatChunk, ChatMessage, ChatRequest, ChatResponse, ChunkAccumulator};
+
+/// Live progress callback: `(content_so_far, reasoning_so_far)`.
+pub type OnDelta<'a> = &'a dyn Fn(&str, &str);
+
+/// A configured connection to a completions endpoint. Static dispatch — two
+/// variants don't warrant a trait object.
+pub enum AgentTransport {
+    /// POST to an OpenAI-compatible `/chat/completions` URL with the given
+    /// extra request headers (auth etc.).
+    Fetch {
+        url: String,
+        headers: Vec<(String, String)>,
+    },
+
+    /// An in-page object exposing `chat.completions.create(request)`.
+    /// No bytes leave the page.
+    Engine(JsValue),
+}
+
+impl AgentTransport {
+    /// One completion request, folded to the response message. Cancellation
+    /// is by dropping the returned future (see [`AbortGuard`]).
+    pub async fn create(
+        &self,
+        request: &ChatRequest<'_>,
+        on_delta: OnDelta<'_>,
+    ) -> ApiResult<ChatMessage> {
+        let body = serde_json::to_string(request)?;
+        match self {
+            Self::Fetch { url, headers } => fetch_completion(url, headers, &body, on_delta).await,
+            Self::Engine(engine) => engine_completion(engine, &body, on_delta).await,
+        }
+    }
+}
+
+/// Parse a complete (non-streamed) chat-completions response body.
+fn from_response_text(text: &str) -> ApiResult<ChatMessage> {
+    let response: ChatResponse = serde_json::from_str(text)
+        .map_err(|x| ApiError::from(format!("Malformed completion response: {x}")))?;
+
+    response
+        .choices
+        .into_iter()
+        .next()
+        .map(|x| x.message)
+        .ok_or_else(|| ApiError::from("Completion response has no choices"))
+}
+
+/// Aborts the in-flight browser fetch when dropped, wiring the viewer's
+/// future-cancellation model (`AgentSlot`'s `Abortable`, the chat Stop
+/// button) through to the network layer. The fetch `signal` also covers the
+/// response body stream, so aborting mid-SSE kills the socket — no separate
+/// reader cancel is needed. Aborting an already-settled fetch is a no-op,
+/// so the guard needs no disarm path.
+struct AbortGuard(web_sys::AbortController);
+
+impl Drop for AbortGuard {
+    fn drop(&mut self) {
+        self.0.abort();
+    }
+}
+
+async fn fetch_completion(
+    url: &str,
+    headers: &[(String, String)],
+    body: &str,
+    on_delta: OnDelta<'_>,
+) -> ApiResult<ChatMessage> {
+    let controller = web_sys::AbortController::new()?;
+    let _guard = AbortGuard(controller.clone());
+    let request_headers = web_sys::Headers::new()?;
+    request_headers.append("content-type", "application/json")?;
+    for (name, value) in headers {
+        request_headers.append(name, value)?;
+    }
+
+    let init = web_sys::RequestInit::new();
+    init.set_method("POST");
+    init.set_body(&JsValue::from_str(body));
+    init.set_headers(&request_headers);
+    init.set_signal(Some(&controller.signal()));
+    let request = web_sys::Request::new_with_str_and_init(url, &init)?;
+    let window = web_sys::window().ok_or_else(|| ApiError::from("No `window`"))?;
+    let response: web_sys::Response = JsFuture::from(window.fetch_with_request(&request))
+        .await?
+        .unchecked_into();
+
+    if !response.ok() {
+        let text = JsFuture::from(response.text()?)
+            .await?
+            .as_string()
+            .unwrap_or_default();
+
+        return Err(ApiError::from(format!(
+            "HTTP {} {}: {}",
+            response.status(),
+            response.status_text(),
+            text
+        )));
+    }
+
+    let content_type = response
+        .headers()
+        .get("content-type")?
+        .unwrap_or_default()
+        .to_lowercase();
+
+    if content_type.starts_with("text/event-stream") {
+        stream_sse(&response, on_delta).await
+    } else {
+        // The server ignored `stream: true` — buffered fallback.
+        let text = JsFuture::from(response.text()?)
+            .await?
+            .as_string()
+            .unwrap_or_default();
+
+        from_response_text(&text)
+    }
+}
+
+/// Consume a `text/event-stream` response body, folding each `data:` chunk.
+async fn stream_sse(response: &web_sys::Response, on_delta: OnDelta<'_>) -> ApiResult<ChatMessage> {
+    let stream = response
+        .body()
+        .ok_or_else(|| ApiError::from("Streaming response has no body"))?;
+
+    let reader: web_sys::ReadableStreamDefaultReader = stream.get_reader().unchecked_into();
+    let decoder = web_sys::TextDecoder::new()?;
+    let options = web_sys::TextDecodeOptions::new();
+    options.set_stream(true);
+    let mut buf = String::new();
+    let mut acc = ChunkAccumulator::default();
+    'read: loop {
+        let result = JsFuture::from(reader.read()).await?;
+        let done = js_sys::Reflect::get(&result, &JsValue::from_str("done"))?
+            .as_bool()
+            .unwrap_or(true);
+
+        if done {
+            break;
+        }
+
+        let value: js_sys::Uint8Array =
+            js_sys::Reflect::get(&result, &JsValue::from_str("value"))?.unchecked_into();
+
+        buf.push_str(&decoder.decode_with_u8_array_and_options(&value.to_vec(), &options)?);
+        for payload in drain_sse_data(&mut buf) {
+            if payload == "[DONE]" {
+                break 'read;
+            }
+
+            let chunk: ChatChunk = serde_json::from_str(&payload)
+                .map_err(|x| ApiError::from(format!("Malformed completion chunk: {x}")))?;
+
+            acc.push(chunk);
+            let (content, reasoning) = acc.progress();
+            on_delta(content, reasoning);
+        }
+    }
+
+    Ok(acc.finish())
+}
+
+/// Drain complete SSE frames from `buf`, returning each frame's joined
+/// `data:` payload (multi-`data:` frames join with `\n` per the SSE spec);
+/// the incomplete tail stays in `buf`. Comment lines and other fields are
+/// ignored; CRLF is normalized — a `\r`/`\n` pair split across reads
+/// reunites in `buf` before the next drain sees it.
+fn drain_sse_data(buf: &mut String) -> Vec<String> {
+    if buf.contains("\r\n") {
+        *buf = buf.replace("\r\n", "\n");
+    }
+
+    let mut out = vec![];
+    while let Some(pos) = buf.find("\n\n") {
+        let frame: String = buf.drain(..pos + 2).collect();
+        let mut payload = String::new();
+        for line in frame.lines() {
+            if let Some(rest) = line.strip_prefix("data:") {
+                if !payload.is_empty() {
+                    payload.push('\n');
+                }
+
+                payload.push_str(rest.strip_prefix(' ').unwrap_or(rest));
+            }
+        }
+
+        if !payload.is_empty() {
+            out.push(payload);
+        }
+    }
+
+    out
+}
+
+/// JSON round-trip through `JSON.parse`/`JSON.stringify` so the engine sees
+/// plain JS objects (what WebLLM and the spec fakes expect) and replies
+/// deserialize through the same serde path as HTTP responses. A result
+/// bearing `Symbol.asyncIterator` (WebLLM's `stream: true` shape) is
+/// iterated as chunks; anything else is one complete response.
+async fn engine_completion(
+    engine: &JsValue,
+    body: &str,
+    on_delta: OnDelta<'_>,
+) -> ApiResult<ChatMessage> {
+    let request = js_sys::JSON::parse(body)?;
+    let chat = js_sys::Reflect::get(engine, &JsValue::from_str("chat"))?;
+    let completions = js_sys::Reflect::get(&chat, &JsValue::from_str("completions"))?;
+    let create: js_sys::Function =
+        js_sys::Reflect::get(&completions, &JsValue::from_str("create"))?
+            .dyn_into()
+            .map_err(|_| ApiError::from("`engine.chat.completions.create` is not a function"))?;
+
+    let result = create.call1(&completions, &request)?;
+    let result = JsFuture::from(js_sys::Promise::resolve(&result)).await?;
+    let iterator_fn = js_sys::Reflect::get(&result, js_sys::Symbol::async_iterator().as_ref())?;
+    if !iterator_fn.is_function() {
+        let text = js_sys::JSON::stringify(&result)?
+            .as_string()
+            .ok_or_else(|| ApiError::from("Engine returned an unserializable response"))?;
+
+        return from_response_text(&text);
+    }
+
+    let iterator = iterator_fn
+        .unchecked_into::<js_sys::Function>()
+        .call0(&result)?;
+    let next: js_sys::Function = js_sys::Reflect::get(&iterator, &JsValue::from_str("next"))?
+        .dyn_into()
+        .map_err(|_| ApiError::from("Engine stream iterator has no `next`"))?;
+
+    let mut acc = ChunkAccumulator::default();
+    loop {
+        let step = JsFuture::from(js_sys::Promise::resolve(&next.call0(&iterator)?)).await?;
+        let done = js_sys::Reflect::get(&step, &JsValue::from_str("done"))?
+            .as_bool()
+            .unwrap_or(true);
+
+        if done {
+            break;
+        }
+
+        let value = js_sys::Reflect::get(&step, &JsValue::from_str("value"))?;
+        let text = js_sys::JSON::stringify(&value)?
+            .as_string()
+            .ok_or_else(|| ApiError::from("Engine returned an unserializable chunk"))?;
+
+        let chunk: ChatChunk = serde_json::from_str(&text)
+            .map_err(|x| ApiError::from(format!("Malformed completion chunk: {x}")))?;
+
+        acc.push(chunk);
+        let (content, reasoning) = acc.progress();
+        on_delta(content, reasoning);
+    }
+
+    Ok(acc.finish())
+}