Keep voice-only setup in startVoiceConversation and share one start path.

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

Author: renal128

Sources/ElevenLabs/Internal/Conversation/Conversation.swift

@@ -6,9 +6,8 @@ import LiveKit
 
 /// A single-use conversation session, created by and owned by `ConversationClient`.
 ///
-/// Manages the lifecycle of one conversation: network layer
-/// (`WebRTCConnectionManager`|`WebSocketConnectionManager`), protocol parser
-/// (`EventParser`), and audio device setup.
+/// Owns one conversation's transport (`WebRTCConnectionManager` or
+/// `WebSocketConnectionManager`) and audio device setup.
 @MainActor
 final class Conversation: ObservableObject {
     // MARK: - State
@@ -17,8 +16,6 @@ final class Conversation: ObservableObject {
     @Published var chatHistory: [any ChatHistoryItem] = []
     @Published var agentState: AgentState = .listening
 
-    private var chatHistoryReconciler = ChatHistoryReconciler()
-
     /// Stream of client tool calls that need to be executed by the app
     @Published var pendingToolCalls: [ClientToolCallEvent] = []
 
@@ -31,38 +28,29 @@ final class Conversation: ObservableObject {
     /// Current MCP connection status for all integrations
     @Published var mcpConnectionStatus: MCPConnectionStatusEvent?
 
-    /// Pending mute state to apply after connection completes.
-    /// Allows setting mute state during connection phase.
-    private var pendingMuteState: Bool?
+    private var chatHistoryReconciler = ChatHistoryReconciler()
+
+    /// Agent state manager for event-based state tracking
+    private var agentStateManager: AgentStateManager?
 
     /// Audio device management
     private var audioManager: ConversationAudioManager?
 
+    /// Pending mute state to apply after connection completes.
+    /// Allows setting mute state during connection phase.
+    private var pendingMuteState: Bool?
+
     /// Externally registered audio observers. Kept attached across track swaps.
     let agentObserverRegistry = AudioObserverRegistry()
     let micObserverRegistry = AudioObserverRegistry()
 
-    /// Agent state manager for event-based state tracking
-    var agentStateManager: AgentStateManager?
-
-    /// Forward a signal to the event-based state manager, or fall back to directly setting `agentState`.
-    func applyStateSignal(_ signal: AgentStateSignal, fallback: AgentState) {
-        if let manager = agentStateManager {
-            manager.processSignal(signal)
-        } else {
-            agentState = fallback
-        }
+    /// Internal LiveKit tracks used to attach ``ConversationAudioObserver``s.
+    private var inputTrack: (any AudioTrackProtocol)? {
+        activeWebRTCConnectionManager?.inputTrack
     }
 
-    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 var agentAudioTrack: (any AudioTrackProtocol)? {
+        activeWebRTCConnectionManager?.agentAudioTrack
     }
 
     /// Internal logger, accessible from nonisolated contexts.
@@ -71,14 +59,10 @@ final class Conversation: ObservableObject {
     /// Context for logging (e.g. agentId)
     private var activeContext: [String: String]?
 
-    /// Internal LiveKit tracks used to attach ``ConversationAudioObserver``s.
-    var inputTrack: (any AudioTrackProtocol)? {
-        activeWebRTCConnectionManager?.inputTrack
-    }
-
-    var agentAudioTrack: (any AudioTrackProtocol)? {
-        activeWebRTCConnectionManager?.agentAudioTrack
-    }
+    let config: ConversationConfig
+    let callbacks: ConversationCallbacks
+    private var speakingTimer: Task<Void, Never>?
+    private var isTearingDown = false
 
     // MARK: - Init
 
@@ -95,115 +79,63 @@ final class Conversation: ObservableObject {
         logger = dependencyProvider.logger
     }
 
-    private func setupAudioManager() {
-        audioManager = ConversationAudioManager(logger: logger)
-    }
-
-    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
-    }
-
     // MARK: - API
 
     func startVoiceConversation(_ auth: ConversationAuth.Voice) async throws -> ConversationStartResult {
-        try await runStart(isTextOnly: false) { config in
-            try await performVoiceStart(auth, config: config)
-        }
-    }
-
-    func startTextConversation(_ auth: ConversationAuth.TextOnly) async throws -> ConversationStartResult {
-        try await runStart(isTextOnly: true) { config in
-            try await performTextStart(auth, config: config)
-        }
-    }
+        let manager = dependencyProvider.webRTCConnectionManager
+        let audioManager = ConversationAudioManager(logger: logger)
+        self.audioManager = audioManager
 
-    private func runStart(
-        isTextOnly: Bool,
-        _ work: (ConversationConfig) async throws -> ConversationStartResult
-    ) async throws -> ConversationStartResult {
-        guard state == .idle else {
-            throw ConversationError.alreadyStarted
-        }
-
-        var startConfig = config
-        startConfig.conversationOverrides.textOnly = isTextOnly
-        let result = try await work(startConfig)
-
-        guard !Task.isCancelled, state.isConnecting else {
-            await activeConnectionManager?.disconnect()
-            throw CancellationError()
-        }
-        state = .connected(result.callInfo)
-        callbacks.onAgentReady?()
-        return result
-    }
-
-    private func performVoiceStart(
-        _ auth: ConversationAuth.Voice,
-        config: ConversationConfig
-    ) async throws -> ConversationStartResult {
-        let webRTCConnectionManager = dependencyProvider.webRTCConnectionManager
-        setupAudioManager()
-        prepareConversationStart(
-            agentId: auth.agentId,
-            isTextOnly: false,
-            connectionManager: webRTCConnectionManager
-        )
-
-        webRTCConnectionManager.onRemoteSpeakingChanged = { [weak self] isSpeaking in
+        manager.onRemoteSpeakingChanged = { [weak self] isSpeaking in
             Task { @MainActor in
                 self?.handleRemoteSpeakingUpdate(isSpeaking: isSpeaking)
             }
         }
-        webRTCConnectionManager.onTracksChanged = { [weak self] in
+        manager.onTracksChanged = { [weak self] in
             Task { @MainActor in
                 self?.refreshAudioObservers()
             }
         }
-
-        await audioManager?.configure(with: config, callbacks: callbacks)
+        await audioManager.configure(with: config, callbacks: callbacks)
         if let pendingMuteState {
-            audioManager?.softwareMuteProcessor?.setMuted(pendingMuteState)
+            audioManager.softwareMuteProcessor?.setMuted(pendingMuteState)
         }
 
-        let result: ConversationStartResult
-        do {
-            result = try await webRTCConnectionManager.connect(
+        let result = try await start(agentId: auth.agentId, isTextOnly: false, using: manager) { config in
+            try await manager.connect(
                 auth: auth,
                 config: config,
-                onStartupStateChange: { [weak self] stage in
-                    self?.updateStartupStage(stage)
-                }
+                onStartupStateChange: { [weak self] in self?.updateStartupStage($0) }
             )
-        } catch let error as ConversationError {
-            await handleStartupFailure(error, disconnecting: webRTCConnectionManager)
-            throw error
-        } catch is CancellationError {
-            await handleStartupCancellation(disconnecting: webRTCConnectionManager)
-            throw CancellationError()
         }
 
         if let pendingMute = pendingMuteState {
             pendingMuteState = nil
             do {
-                if let softwareMuteProcessor = audioManager?.softwareMuteProcessor {
+                if let softwareMuteProcessor = audioManager.softwareMuteProcessor {
                     softwareMuteProcessor.setMuted(pendingMute)
                 } else {
-                    try await webRTCConnectionManager.setMicrophoneMuted(pendingMute)
+                    try await manager.setMicrophoneMuted(pendingMute)
                 }
             } catch {
                 logger.warning("Failed to apply pending mute state", context: ["error": "\(error)"])
             }
         }
 
         refreshAudioObservers()
-        return result
+        return try await setConnected(result)
+    }
+
+    func startTextConversation(_ auth: ConversationAuth.TextOnly) async throws -> ConversationStartResult {
+        let manager = dependencyProvider.webSocketConnectionManager
+        let result = try await start(agentId: auth.agentId, isTextOnly: true, using: manager) { config in
+            try await manager.connect(
+                auth: auth,
+                config: config,
+                onStartupStateChange: { [weak self] in self?.updateStartupStage($0) }
+            )
+        }
+        return try await setConnected(result)
     }
 
     // MARK: - Audio observers
@@ -237,38 +169,6 @@ final class Conversation: ObservableObject {
         micObserverRegistry.attach(to: inputTrack)
     }
 
-    private func performTextStart(
-        _ auth: ConversationAuth.TextOnly,
-        config: ConversationConfig
-    ) async throws -> ConversationStartResult {
-        let connectionManager = dependencyProvider.webSocketConnectionManager
-        let agentId = switch auth {
-        case let .publicAgent(id): id
-        case .signedWebSocketURL: "unknown"
-        }
-        prepareConversationStart(
-            agentId: agentId,
-            isTextOnly: true,
-            connectionManager: connectionManager
-        )
-
-        do {
-            return try await connectionManager.connect(
-                auth: auth,
-                config: config,
-                onStartupStateChange: { [weak self] stage in
-                    self?.updateStartupStage(stage)
-                }
-            )
-        } catch let error as ConversationError {
-            await handleStartupFailure(error, disconnecting: connectionManager)
-            throw error
-        } catch is CancellationError {
-            await handleStartupCancellation(disconnecting: connectionManager)
-            throw CancellationError()
-        }
-    }
-
     /// End and clean up.
     /// Can be called during connection phase to cancel, or during connected conversation to end.
     func endConversation(reason: EndReason = .userEnded) async {
@@ -336,7 +236,7 @@ final class Conversation: ObservableObject {
         try await publish(event)
     }
 
-    /// Contextual update to agent (system prompt-ish).
+    /// Inject context for the agent without interrupting or adding a user-visible message.
     func updateContext(_ context: String) async throws {
         guard state.isConnected else { throw ConversationError.notConnected }
         let event = OutgoingEvent.contextualUpdate(ContextualUpdateEvent(text: context))
@@ -383,42 +283,93 @@ final class Conversation: ObservableObject {
         activeConnectionManager as? any WebRTCConnectionManaging
     }
 
-    let config: ConversationConfig
-    let callbacks: ConversationCallbacks
-
-    var speakingTimer: Task<Void, Never>?
-    private var isTearingDown = false
-
     private func updateStartupStage(_ stage: ConversationStartupState) {
         guard state.isConnecting, state != .connecting(stage) else { return }
         state = .connecting(stage)
     }
 
-    /// Common preparation shared by voice and text-only startup paths.
-    private func prepareConversationStart(
+    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,
-        connectionManager: any ConnectionManaging
-    ) {
+        using manager: any ConnectionManaging,
+        connect: (ConversationConfig) async throws -> ConversationStartResult
+    ) async throws -> ConversationStartResult {
+        guard state == .idle else {
+            throw ConversationError.alreadyStarted
+        }
+
+        var startConfig = config
+        startConfig.conversationOverrides.textOnly = isTextOnly
+
         state = .connecting(.preparing)
-        activeConnectionManager = connectionManager
+        activeConnectionManager = manager
 
         activeContext = ["agentId": agentId]
         let mode = isTextOnly ? "text-only" : "voice"
         logger.info("Starting \(mode) conversation", context: activeContext)
 
         setupAgentStateManager()
 
-        let connectionManagerID = ObjectIdentifier(connectionManager)
-        connectionManager.onEventReceived = { [weak self] event in
+        let connectionManagerID = ObjectIdentifier(manager)
+        manager.onEventReceived = { [weak self] event in
             Task { @MainActor [weak self] in
                 await self?.handleIncomingEvent(event, from: connectionManagerID)
             }
         }
-        connectionManager.onDisconnected = { [weak self] in
+        manager.onDisconnected = { [weak self] in
             guard let self else { return }
             await endConversation(reason: .remoteDisconnected)
         }
+
+        do {
+            return try await connect(startConfig)
+        } catch let error as ConversationError {
+            await handleStartupFailure(error, disconnecting: manager)
+            throw error
+        } catch is CancellationError {
+            await handleStartupCancellation(disconnecting: manager)
+            throw CancellationError()
+        }
+    }
+
+    private func setConnected(_ result: ConversationStartResult) async throws -> ConversationStartResult {
+        guard !Task.isCancelled, state.isConnecting else {
+            await activeConnectionManager?.disconnect()
+            throw CancellationError()
+        }
+        state = .connected(result.callInfo)
+        callbacks.onAgentReady?()
+        return result
     }
 
     private func handleIncomingEvent(_ event: IncomingEvent, from connectionManagerID: ObjectIdentifier) async {
@@ -488,7 +439,7 @@ final class Conversation: ObservableObject {
         }
     }
 
-    func publish(_ event: OutgoingEvent) async throws {
+    private func publish(_ event: OutgoingEvent) async throws {
         guard let connectionManager = activeConnectionManager else {
             throw ConversationError.notConnected
         }