diff --git a/TypeWhisper/ViewModels/StreamingHandler.swift b/TypeWhisper/ViewModels/StreamingHandler.swift index 11faac115..949e652bd 100644 --- a/TypeWhisper/ViewModels/StreamingHandler.swift +++ b/TypeWhisper/ViewModels/StreamingHandler.swift @@ -181,8 +181,13 @@ final class StreamingHandler: @unchecked Sendable { let finishStart = CFAbsoluteTimeGetCurrent() func elapsedMs() -> String { String(format: "%.0f", (CFAbsoluteTimeGetCurrent() - finishStart) * 1000) } - streamingTask?.cancel() + let previewTask = streamingTask streamingTask = nil + previewTask?.cancel() + if let previewTask { + await previewTask.value + logger.info("Finish timing: preview task stopped elapsedMs=\(elapsedMs(), privacy: .public)") + } guard let handle = claimLiveSessionHandleForFinish() else { clearStreamingState(notifyStreamingStopped: true) @@ -319,8 +324,10 @@ final class StreamingHandler: @unchecked Sendable { return true } ) + guard !Task.isCancelled else { return } _ = processPreviewUpdate(result.text, audioGate: nil, persist: true) } catch { + guard !Task.isCancelled else { return } logger.warning("Streaming preview error: \(error.localizedDescription)") } } diff --git a/TypeWhisperTests/StreamingHandlerTests.swift b/TypeWhisperTests/StreamingHandlerTests.swift index 281583656..eb030beb8 100644 --- a/TypeWhisperTests/StreamingHandlerTests.swift +++ b/TypeWhisperTests/StreamingHandlerTests.swift @@ -94,6 +94,105 @@ final class StreamingHandlerTests: XCTestCase { } } + private actor BlockingPreviewFallbackRecorder { + private var activeTranscriptions = 0 + private var maxConcurrentTranscriptions = 0 + private var prompts: [String?] = [] + private var firstCallReleased = false + private var firstCallReleaseContinuation: CheckedContinuation? + + func begin(prompt: String?) -> Int { + activeTranscriptions += 1 + maxConcurrentTranscriptions = max(maxConcurrentTranscriptions, activeTranscriptions) + prompts.append(prompt) + return prompts.count + } + + func waitForFirstCallRelease() async { + guard !firstCallReleased else { return } + await withCheckedContinuation { continuation in + firstCallReleaseContinuation = continuation + } + } + + func releaseFirstCall() { + guard !firstCallReleased else { return } + firstCallReleased = true + firstCallReleaseContinuation?.resume() + firstCallReleaseContinuation = nil + } + + func end() { + activeTranscriptions -= 1 + } + + func snapshot() -> (callCount: Int, maxConcurrentTranscriptions: Int, prompts: [String?]) { + (prompts.count, maxConcurrentTranscriptions, prompts) + } + } + + private final class MockBlockingPreviewFallbackPlugin: NSObject, TranscriptionEnginePlugin, @unchecked Sendable { + static var pluginId: String { "com.typewhisper.mock.blocking-preview-fallback" } + static var pluginName: String { "Mock Blocking Preview Fallback" } + + var providerId: String { "mock-blocking-preview-fallback" } + var providerDisplayName: String { "Mock Blocking Preview Fallback" } + var isConfigured: Bool { true } + var transcriptionModels: [PluginModelInfo] { [] } + var selectedModelId: String? { nil } + var supportsTranslation: Bool { false } + var supportsStreaming: Bool { true } + var supportedLanguages: [String] { ["en"] } + + private let recorder = BlockingPreviewFallbackRecorder() + + func activate(host: HostServices) {} + func deactivate() {} + func selectModel(_ modelId: String) {} + + func transcribe( + audio: AudioData, + language: String?, + translate: Bool, + prompt: String? + ) async throws -> PluginTranscriptionResult { + let callIndex = await recorder.begin(prompt: prompt) + if callIndex == 1 { + await recorder.waitForFirstCallRelease() + } + await recorder.end() + return PluginTranscriptionResult( + text: "result-\(prompt ?? "none")", + detectedLanguage: language + ) + } + + func transcribe( + audio: AudioData, + language: String?, + translate: Bool, + prompt: String?, + onProgress: @Sendable @escaping (String) -> Bool + ) async throws -> PluginTranscriptionResult { + let result = try await transcribe( + audio: audio, + language: language, + translate: translate, + prompt: prompt + ) + _ = onProgress(result.text) + return result + } + + func releaseFirstCall() async { + await recorder.releaseFirstCall() + } + + func snapshot() async -> (callCount: Int, maxConcurrentTranscriptions: Int, prompts: [String?]) { + await recorder.snapshot() + } + } + private final class MockPreviewFallbackOptOutPlugin: NSObject, TranscriptionEnginePlugin, TranscriptPreviewFallbackPolicyProviding, @unchecked Sendable { static var pluginId: String { "com.typewhisper.mock.preview-opt-out" } static var pluginName: String { "Mock Preview Opt Out" } @@ -1002,6 +1101,110 @@ final class StreamingHandlerTests: XCTestCase { XCTAssertEqual(snapshot.prompts, ["Final Terms"]) } + func testFinishWaitsForInFlightFallbackPreviewBeforeFinalTranscription() async throws { + let appSupportDirectory = try TestSupport.makeTemporaryDirectory() + defer { TestSupport.remove(appSupportDirectory) } + + let plugin = MockBlockingPreviewFallbackPlugin() + PluginManager.shared = PluginManager(appSupportDirectory: appSupportDirectory) + PluginManager.shared.loadedPlugins = [ + LoadedPlugin( + manifest: PluginManifest( + id: "com.typewhisper.mock.blocking-preview-fallback", + name: "Mock Blocking Preview Fallback", + version: "1.0.0", + principalClass: "MockBlockingPreviewFallbackPlugin" + ), + instance: plugin, + bundle: Bundle.main, + sourceURL: appSupportDirectory, + isEnabled: true + ) + ] + + let modelManager = ModelManagerService() + modelManager.selectProvider(plugin.providerId) + + let handler = StreamingHandler( + modelManager: modelManager, + bufferProvider: { + XCTFail("full buffer provider should not be used for fallback previews") + return [] + }, + recentBufferProvider: { _ in Array(repeating: 0.5, count: 16_000) }, + bufferDeltaProvider: { _ in ([], 0) }, + bufferedDurationProvider: { 1.0 } + ) + defer { handler.stop() } + + handler.start( + streamPrompt: "Preview Terms", + engineOverrideId: plugin.providerId, + selectedProviderId: plugin.providerId, + languageSelection: .exact("en"), + task: .transcribe, + cloudModelOverride: nil, + allowLiveTranscription: true, + stateCheck: { true } + ) + + var previewStarted = false + for _ in 0..<50 { + if await plugin.snapshot().callCount == 1 { + previewStarted = true + break + } + try await Task.sleep(for: .milliseconds(100)) + } + XCTAssertTrue(previewStarted) + guard previewStarted else { + handler.stop() + return + } + + let finalTask = Task { @MainActor in + _ = await handler.finish() + return try await modelManager.transcribe( + audioSamples: Array(repeating: 0.5, count: 16_000), + languageSelection: .exact("en"), + task: .transcribe, + engineOverrideId: plugin.providerId, + cloudModelOverride: nil, + prompt: "Final Terms" + ) + } + let finalCompleted = expectation(description: "final transcription completed") + var finalOutcome: Result? + let finalWaitTask = Task { @MainActor in + do { + finalOutcome = .success(try await finalTask.value) + } catch { + finalOutcome = .failure(error) + } + finalCompleted.fulfill() + } + defer { + finalTask.cancel() + finalWaitTask.cancel() + } + + try await Task.sleep(for: .milliseconds(100)) + let blockedSnapshot = await plugin.snapshot() + XCTAssertEqual(blockedSnapshot.callCount, 1) + XCTAssertEqual(blockedSnapshot.maxConcurrentTranscriptions, 1) + + await plugin.releaseFirstCall() + await fulfillment(of: [finalCompleted], timeout: 10) + guard let finalOutcome else { return } + let finalResult = try finalOutcome.get() + let finalSnapshot = await plugin.snapshot() + + XCTAssertEqual(finalResult.text, "result-Final Terms") + XCTAssertEqual(finalSnapshot.callCount, 2) + XCTAssertEqual(finalSnapshot.maxConcurrentTranscriptions, 1) + XCTAssertEqual(finalSnapshot.prompts, ["Preview Terms", "Final Terms"]) + } + func testLiveSessionConsumesOnlyIncrementalAudioDeltas() async throws { let appSupportDirectory = try TestSupport.makeTemporaryDirectory() defer { TestSupport.remove(appSupportDirectory) }