feat(stream): add method to detect incomplete tool calls and handle parsing errors

src/app/runtime/stream/turn.rs

@@ -157,6 +157,28 @@ impl StreamedTurn {
         msg
     }
 
+    /// Find the first named tool call whose accumulated `arguments` do not
+    /// parse as valid JSON.
+    ///
+    /// Why: a connection that closes mid-stream (no `[DONE]` event) still
+    /// leaves partial argument text in the accumulator — e.g. a `write`
+    /// tool call cut off mid-string. Parsing that fragment always fails,
+    /// so a parse failure at end-of-stream is a reliable signal that the
+    /// response was truncated, not that the model legitimately finished
+    /// without sending `[DONE]`.
+    ///
+    /// Return: `Some((name, parse_error))` for the first bad tool call, or
+    /// `None` if every tool call's arguments are complete, parsable JSON.
+    pub fn incomplete_tool_call(&self) -> Option<(&str, String)> {
+        self.tool_calls.iter()
+            .filter(|tc| !tc.name.is_empty())
+            .find_map(|tc| {
+                serde_json::from_str::<Value>(&tc.arguments)
+                    .err()
+                    .map(|e| (tc.name.as_str(), e.to_string()))
+            })
+    }
+
     /// Reserved accessor for callers that want to branch mid-stream before the turn
     /// completes; the current wiring only inspects the final `build_assistant_message()`.
     #[allow(dead_code)]
@@ -176,3 +198,41 @@ impl Default for StreamedTurn {
         Self::new()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn tool_call(name: &str, arguments: &str) -> ParsedToolCall {
+        ParsedToolCall {
+            id: "call_1".to_string(),
+            name: name.to_string(),
+            arguments: arguments.to_string(),
+            is_complete: false,
+        }
+    }
+
+    #[test]
+    fn incomplete_tool_call_flags_truncated_json() {
+        let mut turn = StreamedTurn::new();
+        turn.tool_calls.push(tool_call("write", "{\"path\": \"a.txt\", \"content\": \"unterm"));
+        let bad = turn.incomplete_tool_call();
+        assert_eq!(bad.map(|(name, _)| name), Some("write"));
+    }
+
+    #[test]
+    fn incomplete_tool_call_accepts_complete_json() {
+        let mut turn = StreamedTurn::new();
+        turn.tool_calls.push(tool_call("write", "{\"path\": \"a.txt\", \"content\": \"done\"}"));
+        assert!(turn.incomplete_tool_call().is_none());
+    }
+
+    #[test]
+    fn incomplete_tool_call_ignores_calls_without_a_name() {
+        // A slot reserved by `apply_event` (via index padding) but never
+        // filled with a name shouldn't be mistaken for a truncated call.
+        let mut turn = StreamedTurn::new();
+        turn.tool_calls.push(tool_call("", "not json at all"));
+        assert!(turn.incomplete_tool_call().is_none());
+    }
+}