Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 8 additions & 1 deletion TypeWhisper/ViewModels/StreamingHandler.swift
Original file line number Diff line number Diff line change
Expand Up @@ -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)
Expand Down Expand Up @@ -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)")
}
}
Expand Down
203 changes: 203 additions & 0 deletions TypeWhisperTests/StreamingHandlerTests.swift
Original file line number Diff line number Diff line change
Expand Up @@ -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<Void, Never>?

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
)
}
Comment thread
coderabbitai[bot] marked this conversation as resolved.
Resolved

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" }
Expand Down Expand Up @@ -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<TranscriptionResult, Error>?
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) }
Expand Down