How do I know when the stream task is completed? about cleverbird HOT 3 CLOSED

    private func startStreamingResponse() {
        self.isCurrentlyStreamingResponse = true

        streamingTask = Task {
            defer {
                Task { @MainActor in
                    self.isCurrentlyStreamingResponse = false
                }
            }

            do {
                let stream = try await self.chatThread.complete()

                // Iterate through the stream, processing chunks as they arrive
                for try await chunk in stream {
                    Task { @MainActor in
                        let streamingMessage: ChatMessage
                        if self.messages.last?.role != .assistant {
                            streamingMessage = ChatMessage(role: .assistant, content: "")
                        } else {
                            streamingMessage = self.messages.popLast() ?? ChatMessage(role: .assistant, content: "")
                        }
                        let newContent = streamingMessage.content + chunk
                        self.messages.append(ChatMessage(role: .assistant, content: newContent, id: streamingMessage.id))
                    }
                }

            } catch {
                if Task.isCancelled {
                    self.chatThread.cancelStreaming()
                } else {
                    print("Error while processing stream: \(error)")
                }
            }
        }
    }

    private func testStreamingAPI() async {
        let openAIAPIConnection = OpenAIAPIConnection(apiKey: Secrets.OPENAI_API_KEY)
        streamableChatThread = ChatThread(connection: openAIAPIConnection).withStreaming()
            .addSystemMessage("You are an expert ornithologist.")
            .addUserMessage("What is the most common bird in North America?")

        do {
            print("request token count: \(try streamableChatThread!.tokenCount())")

            let stream = try await streamableChatThread!.complete()
            Task { @MainActor in
                apiResult = ""
                jsonResult = "{}"
            }

            // Iterate through the stream, processing chunks as they arrive
            for try await chunk in stream {
                Task { @MainActor in
                    apiResult += chunk
                }
            }
            print("Finished with stream!")
        } catch {
            print("Error while processing stream: \(error)")
        }

        Task { @MainActor in
            let lastMessage = streamableChatThread!.getNonSystemMessages().last!
            jsonResult = "id: \(lastMessage.id)\n\(lastMessage.prettyPrintedJSONString)"
        }
    }