Claim connecting before voice audio setup so cancel during start is not alreadyStarted.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: renal128

Sources/ElevenLabs/Internal/Conversation/Conversation.swift

@@ -44,6 +44,12 @@ final class Conversation: ObservableObject {
     let agentObserverRegistry = AudioObserverRegistry()
     let micObserverRegistry = AudioObserverRegistry()
 
+    private let dependencyProvider: any ConversationDependencyProvider
+    private var activeConnectionManager: (any ConnectionManaging)?
+    private var activeWebRTCConnectionManager: (any WebRTCConnectionManaging)? {
+        activeConnectionManager as? any WebRTCConnectionManaging
+    }
+
     /// Internal LiveKit tracks used to attach ``ConversationAudioObserver``s.
     private var inputTrack: (any AudioTrackProtocol)? {
         activeWebRTCConnectionManager?.inputTrack
@@ -83,26 +89,30 @@ final class Conversation: ObservableObject {
 
     func startVoiceConversation(_ auth: ConversationAuth.Voice) async throws -> ConversationStartResult {
         let manager = dependencyProvider.webRTCConnectionManager
-        let audioManager = ConversationAudioManager(logger: logger)
-        self.audioManager = audioManager
+        let result = try await start(agentId: auth.agentId, isTextOnly: false, using: manager) { config in
+            let audioManager = ConversationAudioManager(logger: logger)
+            self.audioManager = audioManager
 
-        manager.onRemoteSpeakingChanged = { [weak self] isSpeaking in
-            Task { @MainActor in
-                self?.handleRemoteSpeakingUpdate(isSpeaking: isSpeaking)
+            manager.onRemoteSpeakingChanged = { [weak self] isSpeaking in
+                Task { @MainActor in
+                    self?.handleRemoteSpeakingUpdate(isSpeaking: isSpeaking)
+                }
             }
-        }
-        manager.onTracksChanged = { [weak self] in
-            Task { @MainActor in
-                self?.refreshAudioObservers()
+            manager.onTracksChanged = { [weak self] in
+                Task { @MainActor in
+                    self?.refreshAudioObservers()
+                }
+            }
+            await audioManager.configure(with: config, callbacks: callbacks)
+            guard state.isConnecting else {
+                audioManager.cleanup()
+                throw CancellationError()
+            }
+            if let pendingMuteState {
+                audioManager.softwareMuteProcessor?.setMuted(pendingMuteState)
             }
-        }
-        await audioManager.configure(with: config, callbacks: callbacks)
-        if let pendingMuteState {
-            audioManager.softwareMuteProcessor?.setMuted(pendingMuteState)
-        }
 
-        let result = try await start(agentId: auth.agentId, isTextOnly: false, using: manager) { config in
-            try await manager.connect(
+            return try await manager.connect(
                 auth: auth,
                 config: config,
                 onStartupStateChange: { [weak self] in self?.updateStartupStage($0) }
@@ -112,7 +122,7 @@ final class Conversation: ObservableObject {
         if let pendingMute = pendingMuteState {
             pendingMuteState = nil
             do {
-                if let softwareMuteProcessor = audioManager.softwareMuteProcessor {
+                if let softwareMuteProcessor = audioManager?.softwareMuteProcessor {
                     softwareMuteProcessor.setMuted(pendingMute)
                 } else {
                     try await manager.setMicrophoneMuted(pendingMute)
@@ -277,54 +287,16 @@ final class Conversation: ObservableObject {
 
     // MARK: - Private
 
-    private let dependencyProvider: any ConversationDependencyProvider
-    private var activeConnectionManager: (any ConnectionManaging)?
-    private var activeWebRTCConnectionManager: (any WebRTCConnectionManaging)? {
-        activeConnectionManager as? any WebRTCConnectionManaging
-    }
-
-    private func updateStartupStage(_ stage: ConversationStartupState) {
-        guard state.isConnecting, state != .connecting(stage) else { return }
-        state = .connecting(stage)
-    }
-
-    private func setupAgentStateManager() {
-        guard let configuration = config.agentStateConfiguration else { return }
-        let manager = AgentStateManager(configuration: configuration)
-        manager.onStateChange = { [weak self] state in
-            self?.agentState = state
-            self?.callbacks.onAgentStateChange?(state)
-        }
-        agentStateManager = manager
-    }
-
-    /// Forward a signal to the event-based state manager, or fall back to directly setting `agentState`.
-    private func applyStateSignal(_ signal: AgentStateSignal, fallback: AgentState) {
-        if let manager = agentStateManager {
-            manager.processSignal(signal)
-        } else {
-            agentState = fallback
-        }
-    }
-
-    private func handleRemoteSpeakingUpdate(isSpeaking: Bool) {
-        if let manager = agentStateManager {
-            manager.processSignal(isSpeaking ? .agentStartedSpeaking : .agentStoppedSpeaking)
-        } else if isSpeaking {
-            speakingTimer?.cancel()
-            agentState = .speaking
-        } else {
-            scheduleBackToListening(delay: 1.0)
-        }
-    }
-
     private func start(
         agentId: String,
         isTextOnly: Bool,
         using manager: any ConnectionManaging,
         connect: (ConversationConfig) async throws -> ConversationStartResult
     ) async throws -> ConversationStartResult {
-        guard state == .idle else {
+        if state != .idle {
+            if state.isEnded, activeConnectionManager == nil {
+                throw CancellationError()
+            }
             throw ConversationError.alreadyStarted
         }
 
@@ -372,6 +344,41 @@ final class Conversation: ObservableObject {
         return result
     }
 
+    private func updateStartupStage(_ stage: ConversationStartupState) {
+        guard state.isConnecting, state != .connecting(stage) else { return }
+        state = .connecting(stage)
+    }
+
+    private func setupAgentStateManager() {
+        guard let configuration = config.agentStateConfiguration else { return }
+        let manager = AgentStateManager(configuration: configuration)
+        manager.onStateChange = { [weak self] state in
+            self?.agentState = state
+            self?.callbacks.onAgentStateChange?(state)
+        }
+        agentStateManager = manager
+    }
+
+    /// Forward a signal to the event-based state manager, or fall back to directly setting `agentState`.
+    private func applyStateSignal(_ signal: AgentStateSignal, fallback: AgentState) {
+        if let manager = agentStateManager {
+            manager.processSignal(signal)
+        } else {
+            agentState = fallback
+        }
+    }
+
+    private func handleRemoteSpeakingUpdate(isSpeaking: Bool) {
+        if let manager = agentStateManager {
+            manager.processSignal(isSpeaking ? .agentStartedSpeaking : .agentStoppedSpeaking)
+        } else if isSpeaking {
+            speakingTimer?.cancel()
+            agentState = .speaking
+        } else {
+            scheduleBackToListening(delay: 1.0)
+        }
+    }
+
     private func handleIncomingEvent(_ event: IncomingEvent, from connectionManagerID: ObjectIdentifier) async {
         guard let activeConnectionManager,
               ObjectIdentifier(activeConnectionManager) == connectionManagerID,