refactor: remove feedback availability callback

Feedback is available whenever the conversation is connected, so consumers can derive availability directly from state.

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

Author: renal128

Documentation/Usage.md

@@ -498,10 +498,6 @@ let callbacks = ConversationCallbacks(
     onAudioAlignment: { alignment in
         // Real-time word highlighting timing.
     },
-    onCanSendFeedbackChange: { canSend in
-        // Enable/disable your 'Thumbs Up/Down' buttons in the UI
-        self.showFeedbackUI = canSend
-    },
     onError: { error in
         print("A non-fatal or startup error occurred: \(error)")
     }
@@ -553,35 +549,29 @@ let config = ConversationConfig(startupConfiguration: startupConfig)
 
 ## Feedback & Context {#feedback-context}
 
-Handle feedback (like/dislike) and contextual updates to the agent.
+Feedback can be sent whenever the conversation is connected.
 
 ```swift
-// 1) Setup: react to feedback availability
-var canSendFeedback = false
-
 let callbacks = ConversationCallbacks(
     onAgentResponse: { text, eventId in
         print("Agent:", text, "(event:", eventId, ")")
-    },
-    onCanSendFeedbackChange: { can in
-        canSendFeedback = can
-        // e.g., refresh your UI
     }
 )
 
-let conversation = try await ElevenLabs.startConversation(agentId: "agent_123", callbacks: callbacks)
+let client = ConversationClient(callbacks: callbacks)
+_ = try await client.startConversation(agentId: "agent_123")
 
-// 2) Sending feedback from your UI
-func thumbsUp(latestEventId: Int) {
-    Task { try? await conversation.sendFeedback(.like, eventId: latestEventId) }
+func thumbsUp(eventId: Int) async throws {
+    guard client.state.isConnected else { return }
+    try await client.sendFeedback(.like, eventId: eventId)
 }
 
-func thumbsDown(latestEventId: Int) {
-    Task { try? await conversation.sendFeedback(.dislike, eventId: latestEventId) }
+func thumbsDown(eventId: Int) async throws {
+    guard client.state.isConnected else { return }
+    try await client.sendFeedback(.dislike, eventId: eventId)
 }
 
-// 3) Contextual updates (e.g., user preferences)
-Task { try? await conversation.updateContext("user_prefers_detailed_answers=true") }
+try await client.updateContext("user_prefers_detailed_answers=true")
 ```
 
 ---

Sources/ElevenLabs/Internal/Conversation/Conversation+Events.swift

@@ -14,12 +14,8 @@ extension Conversation {
 
         case let .agentResponse(e):
             upsertAgentMessage(content: e.response, eventId: e.eventId)
-            lastAgentEventId = e.eventId
             agentStateManager?.processSignal(.agentResponse)
             callbacks.onAgentResponse?(e.response, e.eventId)
-            if lastFeedbackSubmittedEventId.map({ e.eventId > $0 }) ?? true {
-                callbacks.onCanSendFeedbackChange?(true)
-            }
 
         case let .agentResponseCorrection(correction):
             upsertAgentMessage(content: correction.correctedAgentResponse, eventId: correction.eventId)
@@ -48,7 +44,6 @@ extension Conversation {
             speakingTimer?.cancel()
             applyStateSignal(.interruption, fallback: .listening)
             callbacks.onInterruption?(interruptionEvent.eventId)
-            callbacks.onCanSendFeedbackChange?(false)
 
         case let .conversationMetadata(metadata):
             // Store the conversation metadata for public access

Sources/ElevenLabs/Public/Conversation/Conversation.swift

@@ -30,9 +30,6 @@ final class Conversation: ObservableObject {
     /// Current MCP connection status for all integrations
     @Published var mcpConnectionStatus: MCPConnectionStatusEvent?
 
-    var lastAgentEventId: Int?
-    var lastFeedbackSubmittedEventId: Int?
-
     /// Pending mute state to apply after connection completes.
     /// Allows setting mute state during connection phase.
     private var pendingMuteState: Bool?
@@ -258,7 +255,6 @@ final class Conversation: ObservableObject {
 
         // Call user's onDisconnect callback if provided
         callbacks.onDisconnect?(disconnectReason)
-        callbacks.onCanSendFeedbackChange?(false)
     }
 
     /// Send a text message to the agent.
@@ -331,8 +327,6 @@ final class Conversation: ObservableObject {
 
         let event = OutgoingEvent.feedback(FeedbackEvent(score: score, eventId: eventId))
         try await publish(event)
-        lastFeedbackSubmittedEventId = eventId
-        callbacks.onCanSendFeedbackChange?(false)
     }
 
     /// Approve or reject an MCP tool call request from the agent.
@@ -387,7 +381,6 @@ final class Conversation: ObservableObject {
         let mode = config.conversationOverrides.textOnly ? "text-only" : "voice"
         logger.info("Starting \(mode) conversation", context: activeContext)
 
-        callbacks.onCanSendFeedbackChange?(false)
         setupAgentStateManager()
 
         connectionManager.onEventReceived = { [weak self, weak connectionManager] event in
@@ -434,10 +427,6 @@ final class Conversation: ObservableObject {
         cleanupTransientResources()
 
         pendingToolCalls.removeAll()
-
-        lastAgentEventId = nil
-        lastFeedbackSubmittedEventId = nil
-        callbacks.onCanSendFeedbackChange?(false)
     }
 
     private func cleanupTransientResources() {

Sources/ElevenLabs/Public/Conversation/ConversationCallbacks.swift

@@ -45,9 +45,6 @@ public struct ConversationCallbacks: Sendable {
     /// Called when audio alignment metadata is emitted.
     public var onAudioAlignment: (@Sendable (AudioAlignment) -> Void)?
 
-    /// Called when feedback availability changes.
-    public var onCanSendFeedbackChange: (@Sendable (Bool) -> Void)?
-
     /// Called when a client tool call is received without a registered handler.
     public var onClientToolCall: (@Sendable (ClientToolCallEvent) -> Void)?
 
@@ -69,7 +66,6 @@ public struct ConversationCallbacks: Sendable {
         onInterruption: (@Sendable (_ eventId: Int) -> Void)? = nil,
         onVadScore: (@Sendable (_ score: Double) -> Void)? = nil,
         onAudioAlignment: (@Sendable (AudioAlignment) -> Void)? = nil,
-        onCanSendFeedbackChange: (@Sendable (Bool) -> Void)? = nil,
         onClientToolCall: (@Sendable (ClientToolCallEvent) -> Void)? = nil,
         onAgentStateChange: (@Sendable (ElevenLabs.AgentState) -> Void)? = nil
     ) {
@@ -87,7 +83,6 @@ public struct ConversationCallbacks: Sendable {
         self.onInterruption = onInterruption
         self.onVadScore = onVadScore
         self.onAudioAlignment = onAudioAlignment
-        self.onCanSendFeedbackChange = onCanSendFeedbackChange
         self.onClientToolCall = onClientToolCall
         self.onAgentStateChange = onAgentStateChange
     }

Tests/ElevenLabsTests/Unit/ConversationEventHandlerTests.swift

@@ -79,7 +79,6 @@ final class ConversationEventHandlerTests: XCTestCase {
         XCTAssertEqual(conversation.messages.last?.content, "I am an AI")
         XCTAssertEqual(conversation.messages.last?.role, .agent)
         XCTAssertEqual(conversation.messages.last?.eventId, 456)
-        XCTAssertEqual(conversation.lastAgentEventId, 456)
     }
 
     func testAgentResponseFinalizesStreamedMessageInsteadOfDuplicating() async {

Tests/ElevenLabsTests/Unit/ConversationTests.swift

@@ -552,40 +552,21 @@ final class ConversationTests: XCTestCase {
         XCTAssertEqual(errorsAfterInitFailure, [.connectionFailed("Publish failed")])
     }
 
-    func testAgentResponseCallbackTogglesFeedbackAvailability() async throws {
-        let gotResponse = expectation(description: "agent response")
-        // Feedback flips more than once (start→false, response→true, feedback→false).
-        let feedbackStates = ValueRecorder<Bool>()
-
-        let callbacks = makeCallbacks(configure: { callbacks in
-            callbacks.onAgentResponse = { text, eventId in
-                XCTAssertEqual(text, "Hello")
-                XCTAssertEqual(eventId, 42)
-                gotResponse.fulfill()
-            }
-            callbacks.onCanSendFeedbackChange = { canSend in
-                Task { await feedbackStates.append(canSend) }
-            }
-        })
-
+    func testSendFeedbackWhileConnected() async throws {
         let conversation = Conversation(
             dependencyProvider: dependencyProvider,
-            config: makeConfig(),
-            callbacks: callbacks
+            config: makeConfig()
         )
 
         _ = try await conversation.start(auth: .publicAgent(id: "test"))
 
-        mockWebRTCConnectionManager.deliver(.agentResponse(AgentResponseEvent(response: "Hello", eventId: 42)))
-
-        await fulfillment(of: [gotResponse], timeout: 1.0)
-        let initialFeedbackState = await waitForLastValue(feedbackStates) { $0 == true }
-        XCTAssertEqual(initialFeedbackState, true)
-
         try await conversation.sendFeedback(FeedbackEvent.Score.like, eventId: 42)
 
-        let updatedFeedbackState = await waitForLastValue(feedbackStates) { $0 == false }
-        XCTAssertEqual(updatedFeedbackState, false)
+        let payload = try XCTUnwrap(mockWebRTCConnectionManager.publishedPayloads.last)
+        let json = try XCTUnwrap(JSONSerialization.jsonObject(with: payload) as? [String: Any])
+        XCTAssertEqual(json["type"] as? String, "feedback")
+        XCTAssertEqual(json["score"] as? String, "like")
+        XCTAssertEqual(json["event_id"] as? Int, 42)
     }
 
     func testVadScoreCallbackReceivesScores() async throws {
@@ -632,34 +613,6 @@ final class ConversationTests: XCTestCase {
         await fulfillment(of: [gotTool], timeout: 1.0)
     }
 
-    func testInterruptionCallbackDisablesFeedback() async throws {
-        let gotInterruption = expectation(description: "interruption")
-        let feedbackStates = ValueRecorder<Bool>()
-
-        let callbacks = makeCallbacks(configure: { callbacks in
-            callbacks.onInterruption = { id in
-                XCTAssertEqual(id, 7)
-                gotInterruption.fulfill()
-            }
-            callbacks.onCanSendFeedbackChange = { canSend in
-                Task { await feedbackStates.append(canSend) }
-            }
-        })
-
-        let conversation = Conversation(
-            dependencyProvider: dependencyProvider,
-            config: makeConfig(),
-            callbacks: callbacks
-        )
-        _ = try await conversation.start(auth: .publicAgent(id: "test"))
-
-        mockWebRTCConnectionManager.deliver(.interruption(InterruptionEvent(eventId: 7)))
-
-        await fulfillment(of: [gotInterruption], timeout: 1.0)
-        let interruptionFeedbackState = await waitForLastValue(feedbackStates) { $0 == false }
-        XCTAssertEqual(interruptionFeedbackState, false)
-    }
-
     @MainActor
     func testSendToolResultWhenNotConnected() async {
         do {