Public Access
1583 lines
65 KiB
C#
1583 lines
65 KiB
C#
using MeetingAssistant.Recording;
|
|
using MeetingAssistant.Speakers;
|
|
using MeetingAssistant.Transcription;
|
|
using MeetingAssistant.MeetingNotes;
|
|
using MeetingAssistant.Summary;
|
|
using Microsoft.Extensions.Logging.Abstractions;
|
|
using Microsoft.Extensions.Options;
|
|
using System.Threading.Channels;
|
|
|
|
namespace MeetingAssistant.Tests;
|
|
|
|
public sealed class RecordingCoordinatorTests
|
|
{
|
|
private static async Task WaitUntilAsync(Func<bool> condition)
|
|
{
|
|
var deadline = DateTimeOffset.UtcNow.AddSeconds(5);
|
|
while (DateTimeOffset.UtcNow < deadline)
|
|
{
|
|
if (condition())
|
|
{
|
|
return;
|
|
}
|
|
|
|
await Task.Delay(25);
|
|
}
|
|
|
|
throw new TimeoutException("Condition was not met.");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task ToggleStartsStreamingTranscriptionAndSecondToggleStopsIt()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var provider = new EchoStreamingTranscriptionProvider();
|
|
var store = new InMemoryTranscriptStore();
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var noteOpener = new CapturingMeetingNoteOpener();
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var audioArchive = new InMemoryRecordedAudioStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(provider),
|
|
store,
|
|
noteStore,
|
|
noteOpener,
|
|
artifactStore,
|
|
audioArchive,
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
var started = await coordinator.ToggleAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk(new byte[] { 1, 0 }, 16000, 1), CancellationToken.None);
|
|
|
|
await store.WaitForTextAsync("chunk:2");
|
|
var stopped = await coordinator.ToggleAsync(CancellationToken.None);
|
|
|
|
Assert.True(started.IsRecording);
|
|
Assert.Equal(noteStore.SavedNote?.Path, noteOpener.OpenedPath);
|
|
Assert.Equal(started.MeetingNotePath, noteOpener.OpenedPath);
|
|
Assert.Equal(started.MeetingNotePath, artifactStore.CreatedArtifacts?.MeetingNotePath);
|
|
Assert.True(provider.FirstChunkWasObservedBeforeSourceCompleted);
|
|
Assert.False(stopped.IsRecording);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartCreatesMeetingNoteLinkedToTranscriptAndOpensIt()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var transcriptStore = new InMemoryTranscriptStore("C:\\Vault\\Meetings\\Transcripts\\20260519-transcript.md");
|
|
var noteStore = new InMemoryMeetingNoteStore("C:\\Vault\\Meetings\\Notes\\20260519-meeting.md");
|
|
var noteOpener = new CapturingMeetingNoteOpener();
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var audioArchive = new InMemoryRecordedAudioStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new EchoStreamingTranscriptionProvider()),
|
|
transcriptStore,
|
|
noteStore,
|
|
noteOpener,
|
|
artifactStore,
|
|
audioArchive,
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
Vault = new VaultOptions
|
|
{
|
|
AssistantContextFolder = "C:\\Vault\\Meetings\\Assistant Context",
|
|
SummariesFolder = "C:\\Vault\\Meetings\\Summaries"
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
var status = await coordinator.StartAsync(CancellationToken.None);
|
|
|
|
Assert.True(status.IsRecording);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Notes\\20260519-meeting.md", status.MeetingNotePath);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Transcripts\\20260519-transcript.md", noteStore.SavedNote?.Frontmatter.Transcript);
|
|
Assert.StartsWith("C:\\Vault\\Meetings\\Assistant Context\\", noteStore.SavedNote?.Frontmatter.AssistantContext, StringComparison.Ordinal);
|
|
Assert.EndsWith("-assistant-context.md", noteStore.SavedNote?.Frontmatter.AssistantContext, StringComparison.Ordinal);
|
|
Assert.StartsWith("C:\\Vault\\Meetings\\Summaries\\", noteStore.SavedNote?.Frontmatter.Summary, StringComparison.Ordinal);
|
|
Assert.EndsWith("-summary.md", noteStore.SavedNote?.Frontmatter.Summary, StringComparison.Ordinal);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Notes\\20260519-meeting.md", noteOpener.OpenedPath);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Notes\\20260519-meeting.md", artifactStore.CreatedArtifacts?.MeetingNotePath);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Transcripts\\20260519-transcript.md", artifactStore.CreatedArtifacts?.TranscriptPath);
|
|
Assert.StartsWith("C:\\Vault\\Meetings\\Assistant Context\\", artifactStore.CreatedArtifacts?.AssistantContextPath, StringComparison.Ordinal);
|
|
Assert.StartsWith("C:\\Vault\\Meetings\\Summaries\\", artifactStore.CreatedArtifacts?.SummaryPath, StringComparison.Ordinal);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartUsesCurrentOutlookMeetingMetadataWhenAvailable()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore("C:\\Vault\\Meetings\\Notes\\metadata-meeting.md");
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new EchoStreamingTranscriptionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
new FixedMeetingMetadataProvider(new MeetingMetadata(
|
|
"Architecture Sync",
|
|
["Ada <ada@example.com>", "Grace"],
|
|
"Review API shape",
|
|
DateTimeOffset.Parse("2026-05-19T11:00:00+02:00"))));
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await WaitUntilAsync(() => artifactStore.Agenda == "Review API shape");
|
|
|
|
Assert.Equal("Architecture Sync", noteStore.SavedNote?.Frontmatter.Title);
|
|
Assert.Equal(["Ada <ada@example.com>", "Grace"], noteStore.SavedNote?.Frontmatter.Attendees);
|
|
Assert.Equal("Review API shape", artifactStore.Agenda);
|
|
Assert.Equal(DateTimeOffset.Parse("2026-05-19T11:00:00+02:00"), artifactStore.ScheduledEnd);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartDoesNotWaitForSlowMeetingMetadataButAppliesItLater()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore("C:\\Vault\\Meetings\\Notes\\metadata-meeting.md");
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var provider = new BlockingMeetingMetadataProvider(new MeetingMetadata(
|
|
"Late Calendar Match",
|
|
["Ada"],
|
|
"Late agenda",
|
|
DateTimeOffset.Parse("2026-05-19T12:00:00+02:00")));
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new EchoStreamingTranscriptionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
provider);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
|
|
Assert.StartsWith("Meeting ", noteStore.SavedNote?.Frontmatter.Title, StringComparison.Ordinal);
|
|
provider.Release();
|
|
await WaitUntilAsync(() =>
|
|
noteStore.SavedNote?.Frontmatter.Title == "Late Calendar Match" &&
|
|
artifactStore.Agenda == "Late agenda");
|
|
|
|
Assert.Equal(["Ada"], noteStore.SavedNote?.Frontmatter.Attendees);
|
|
Assert.Equal("Late agenda", artifactStore.Agenda);
|
|
Assert.Equal(DateTimeOffset.Parse("2026-05-19T12:00:00+02:00"), artifactStore.ScheduledEnd);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartCreatesMeetingNoteWhenMetadataProviderFails()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore("C:\\Vault\\Meetings\\Notes\\fallback-meeting.md");
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new EchoStreamingTranscriptionProvider()),
|
|
new InMemoryTranscriptStore("C:\\Vault\\Meetings\\Transcripts\\fallback-transcript.md"),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
new ThrowingMeetingMetadataProvider());
|
|
|
|
var status = await coordinator.StartAsync(CancellationToken.None);
|
|
|
|
Assert.True(status.IsRecording);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Notes\\fallback-meeting.md", status.MeetingNotePath);
|
|
Assert.NotNull(artifactStore.CreatedArtifacts);
|
|
Assert.StartsWith("Meeting ", noteStore.SavedNote?.Frontmatter.Title, StringComparison.Ordinal);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartContinuesWhenObsidianOpenFails()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore("C:\\Vault\\Meetings\\Notes\\open-fails.md");
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new EchoStreamingTranscriptionProvider()),
|
|
new InMemoryTranscriptStore("C:\\Vault\\Meetings\\Transcripts\\open-fails-transcript.md"),
|
|
noteStore,
|
|
new ThrowingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
var status = await coordinator.StartAsync(CancellationToken.None);
|
|
|
|
Assert.True(status.IsRecording);
|
|
Assert.Equal("C:\\Vault\\Meetings\\Notes\\open-fails.md", status.MeetingNotePath);
|
|
Assert.NotNull(artifactStore.CreatedArtifacts);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopCompletesAudioCaptureAndDrainsFinalTranscriptionWindow()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk(new byte[] { 1, 0 }, 16000, 1));
|
|
var provider = new FinalSegmentOnAudioCompletionProvider();
|
|
var store = new InMemoryTranscriptStore();
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var noteOpener = new CapturingMeetingNoteOpener();
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var audioArchive = new InMemoryRecordedAudioStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(provider),
|
|
store,
|
|
noteStore,
|
|
noteOpener,
|
|
artifactStore,
|
|
audioArchive,
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
var stopped = await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.False(stopped.IsRecording);
|
|
await store.WaitForTextAsync("final:2");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task CaptureStartsEvenWhenTranscriptionProviderIsStillWarmingUp()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var provider = new BlockingBeforeTranscriptionProvider();
|
|
var store = new InMemoryTranscriptStore();
|
|
var audioArchive = new InMemoryRecordedAudioStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(provider),
|
|
store,
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
audioArchive,
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await provider.WaitUntilWaitingForBackendAsync();
|
|
await audioSource.WriteAsync(new AudioChunk(new byte[] { 1, 0, 2, 0 }, 16000, 1), CancellationToken.None);
|
|
|
|
await audioArchive.WaitForAppendAsync();
|
|
Assert.Equal([4], audioArchive.AppendedChunkSizes);
|
|
|
|
provider.MarkBackendReady();
|
|
await store.WaitForTextAsync("chunk:4");
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StartPassesDictationWordsToSpeechPipeline()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var provider = new CapturingPipelineOptionsProvider();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(provider),
|
|
new InMemoryTranscriptStore(),
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
dictationWordStore: new FixedDictationWordStore(["PBI", "Product Backlog Item"]));
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk([1, 0], 16000, 1), CancellationToken.None);
|
|
await provider.OptionsObserved.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
|
|
Assert.Equal(["PBI", "Product Backlog Item"], provider.Options?.DictationWords);
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopRewritesTranscriptWithFinalDiarizedSegmentsWhenAvailable()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk(new byte[] { 1, 0, 2, 0 }, 16000, 1));
|
|
var transcriptStore = new InMemoryTranscriptStore();
|
|
var finalizer = new CapturingTranscriptFinalizer(
|
|
[
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Speaker 0", "hello"),
|
|
new TranscriptionSegment(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(2), "Speaker 1", "there")
|
|
]);
|
|
var audioArchive = new InMemoryRecordedAudioStore("memory-recording.wav");
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider(), finalizer.FinalizeAsync),
|
|
transcriptStore,
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
audioArchive,
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal("memory-recording.wav", finalizer.AudioPath);
|
|
Assert.Collection(
|
|
finalizer.LiveSegments,
|
|
segment => Assert.Equal("final:4", segment.Text));
|
|
Assert.Equal([4], audioArchive.AppendedChunkSizes);
|
|
Assert.True(audioArchive.Completed);
|
|
Assert.True(audioArchive.Deleted);
|
|
Assert.Collection(
|
|
transcriptStore.ReplacedSegments,
|
|
first =>
|
|
{
|
|
Assert.Equal("Speaker 0", first.Speaker);
|
|
Assert.Equal("hello", first.Text);
|
|
},
|
|
second =>
|
|
{
|
|
Assert.Equal("Speaker 1", second.Speaker);
|
|
Assert.Equal("there", second.Text);
|
|
});
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopRelabelsFinishedTranscriptWithLearnedSpeakerIdentity()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk(new byte[] { 1, 0, 2, 0 }, 16000, 1));
|
|
var transcriptStore = new InMemoryTranscriptStore();
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
noteStore.UpdateSavedNote(MeetingNoteTemplate.Create(
|
|
"Identity Test",
|
|
DateTimeOffset.Parse("2026-05-20T12:00:00+02:00"),
|
|
attendees: ["Chris"],
|
|
transcriptPath: "memory-transcript.md",
|
|
assistantContextPath: "memory-context.md",
|
|
summaryPath: "memory-summary.md"));
|
|
var finalizer = new CapturingTranscriptFinalizer(
|
|
[
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Guest03", "hello")
|
|
]);
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider(), finalizer.FinalizeAsync),
|
|
transcriptStore,
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: new FixedSpeakerIdentificationService("Guest03", "Chris"));
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal("Chris", transcriptStore.ReplacedSegments.Single().Speaker);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopAddsIdentifiedSpeakerToMeetingAttendees()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk(new byte[] { 1, 0, 2, 0 }, 16000, 1));
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var finalizer = new CapturingTranscriptFinalizer(
|
|
[
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Guest03", "hello")
|
|
]);
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider(), finalizer.FinalizeAsync),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: new FixedSpeakerIdentificationService(
|
|
"Guest03",
|
|
"Chris",
|
|
["Chris", "Christopher"]));
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
var attendees = Assert.IsType<List<string>>(noteStore.SavedNote?.Frontmatter.Attendees);
|
|
Assert.Contains("Chris", attendees);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopDoesNotDuplicateIdentifiedSpeakerWhenAliasIsAlreadyAttendee()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk(new byte[] { 1, 0, 2, 0 }, 16000, 1));
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var finalizer = new CapturingTranscriptFinalizer(
|
|
[
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Guest03", "hello")
|
|
]);
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider(), finalizer.FinalizeAsync),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: new FixedSpeakerIdentificationService(
|
|
"Guest03",
|
|
"Christopher",
|
|
["Christopher", "Chris"]));
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
noteStore.UpdateAttendees(["Chris <chris@example.com>"]);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
var attendees = Assert.IsType<List<string>>(noteStore.SavedNote?.Frontmatter.Attendees);
|
|
Assert.Equal(["Chris <chris@example.com>"], attendees);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LiveSpeakerIdentityMatchRelabelsCurrentAndFutureTranscriptSegments()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var transcriptStore = new InMemoryTranscriptStore();
|
|
var speakerIdentification = new BlockingSpeakerIdentificationService("Guest03", "Chris");
|
|
var provider = new OrderedChunkProvider();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(provider),
|
|
transcriptStore,
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
SpeakerIdentification = new SpeakerIdentificationOptions
|
|
{
|
|
InitialDelay = TimeSpan.Zero,
|
|
Interval = TimeSpan.FromMilliseconds(10)
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: speakerIdentification);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(0, 1, 2, 3, 4, 5, 6, 7), 4, 1), CancellationToken.None);
|
|
await WaitUntilAsync(() => transcriptStore.Segments.Any(segment => segment.Text.Contains("first", StringComparison.Ordinal)));
|
|
await speakerIdentification.IdentificationObserved.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
await WaitUntilAsync(() => transcriptStore.ReplacedSegments.Any(segment => segment.Text.Contains("first", StringComparison.Ordinal)));
|
|
Assert.Equal("Chris", transcriptStore.ReplacedSegments.Single().Speaker);
|
|
await Task.Delay(50);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(8, 9, 10, 11, 12, 13, 14, 15), 4, 1), CancellationToken.None);
|
|
|
|
await transcriptStore.WaitForTextAsync("second");
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Collection(
|
|
transcriptStore.Segments,
|
|
first => Assert.Equal("Guest03", first.Speaker),
|
|
second => Assert.Equal("Chris", second.Speaker));
|
|
Assert.Contains(
|
|
transcriptStore.ReplacedSegments,
|
|
segment => segment.Text.Contains("first", StringComparison.Ordinal) && segment.Speaker == "Chris");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LiveSpeakerIdentityMatchAddsIdentifiedSpeakerToMeetingAttendees()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var speakerIdentification = new BlockingSpeakerIdentificationService("Guest03", "Chris");
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new OrderedChunkProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
SpeakerIdentification = new SpeakerIdentificationOptions
|
|
{
|
|
InitialDelay = TimeSpan.Zero,
|
|
Interval = TimeSpan.FromMilliseconds(10)
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: speakerIdentification);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(0, 1, 2, 3, 4, 5, 6, 7), 4, 1), CancellationToken.None);
|
|
|
|
await WaitUntilAsync(() => noteStore.SavedNote?.Frontmatter.Attendees.Contains("Chris") == true);
|
|
var attendees = Assert.IsType<List<string>>(noteStore.SavedNote?.Frontmatter.Attendees);
|
|
Assert.Contains("Chris", attendees);
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LiveSpeakerIdentificationRetriesWhenAttendeesChange()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var speakerIdentification = new CountingSpeakerIdentificationService();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new OrderedChunkProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
SpeakerIdentification = new SpeakerIdentificationOptions
|
|
{
|
|
InitialDelay = TimeSpan.Zero,
|
|
Interval = TimeSpan.FromMilliseconds(20)
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: speakerIdentification);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(0, 1, 2, 3, 4, 5, 6, 7), 4, 1), CancellationToken.None);
|
|
await WaitUntilAsync(() => speakerIdentification.Requests.Count == 1);
|
|
|
|
noteStore.UpdateAttendees(["Chris"]);
|
|
|
|
await WaitUntilAsync(() => speakerIdentification.Requests.Count == 2);
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal(["Chris"], speakerIdentification.Requests.Last().MeetingNote.Frontmatter.Attendees);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task LiveSpeakerIdentificationRetriesWhenNewUnmappedSpeakerAppears()
|
|
{
|
|
var audioSource = new ControlledAudioSource();
|
|
var speakerIdentification = new CountingSpeakerIdentificationService();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new ChangingSpeakerOrderedChunkProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
SpeakerIdentification = new SpeakerIdentificationOptions
|
|
{
|
|
InitialDelay = TimeSpan.Zero,
|
|
Interval = TimeSpan.FromMilliseconds(20)
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance,
|
|
speakerIdentificationService: speakerIdentification);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(0, 1, 2, 3, 4, 5, 6, 7), 4, 1), CancellationToken.None);
|
|
await WaitUntilAsync(() => speakerIdentification.Requests.Count == 1);
|
|
await audioSource.WriteAsync(new AudioChunk(Samples(8, 9, 10, 11, 12, 13, 14, 15), 4, 1), CancellationToken.None);
|
|
|
|
await WaitUntilAsync(() => speakerIdentification.Requests.Count == 2);
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
var samples = Assert.IsAssignableFrom<IReadOnlyList<SpeakerAudioSample>>(
|
|
speakerIdentification.Requests.Last().Samples);
|
|
Assert.Contains(samples, sample => sample.Speaker == "Guest04");
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0, null)]
|
|
[InlineData(1, null)]
|
|
[InlineData(2, 2)]
|
|
[InlineData(5, 5)]
|
|
public async Task StopUsesMeetingNoteAttendeeCountAsSpeakerHintWhenThereAreMultipleAttendees(
|
|
int attendeeCount,
|
|
int? expectedNumSpeakers)
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var finalizer = new CapturingTranscriptFinalizer(
|
|
[
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Speaker 0", "hello")
|
|
]);
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider(), finalizer.FinalizeAsync),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
noteStore.UpdateAttendees(Enumerable.Range(1, attendeeCount).Select(index => $"Person {index}"));
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal(expectedNumSpeakers, finalizer.Options?.NumSpeakers);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopAddsMeetingEndTimeAndRunsSummaryAfterFinishedTranscript()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var noteStore = new InMemoryMeetingNoteStore();
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var summaryPipeline = new CapturingMeetingSummaryPipeline();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
noteStore,
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
summaryPipeline,
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
var startTime = noteStore.SavedNote?.Frontmatter.StartTime;
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.NotNull(startTime);
|
|
Assert.NotNull(noteStore.SavedNote?.Frontmatter.EndTime);
|
|
Assert.True(noteStore.SavedNote?.Frontmatter.EndTime >= startTime);
|
|
Assert.Equal(artifactStore.CreatedArtifacts, summaryPipeline.Artifacts);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopUpdatesTranscriptMetadataWithMeetingEndTime()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var transcriptStore = new InMemoryTranscriptStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
|
|
transcriptStore,
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
new InMemoryMeetingArtifactStore(),
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.NotNull(transcriptStore.MetadataMeetingNote?.Frontmatter.EndTime);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopUpdatesAssistantContextStateThroughSummaryLifecycle()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(CreateOptionsWithoutFinalizer()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal(
|
|
[AssistantContextState.Summarizing, AssistantContextState.Finished],
|
|
artifactStore.States);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopMarksAssistantContextErrorWhenSummaryFails()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(succeeded: false),
|
|
Options.Create(CreateOptionsWithoutFinalizer()),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal(
|
|
[AssistantContextState.Summarizing, AssistantContextState.Error],
|
|
artifactStore.States);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task StopMarksSpeakerRecognitionBeforeSummaryWhenFinalizerIsConfigured()
|
|
{
|
|
var audioSource = new CapturedChunkThenCancelAudioSource(new AudioChunk([1, 0, 2, 0], 16000, 1));
|
|
var artifactStore = new InMemoryMeetingArtifactStore();
|
|
var coordinator = new MeetingRecordingCoordinator(
|
|
audioSource,
|
|
new TestSpeechRecognitionPipelineFactory(new FinalSegmentOnAudioCompletionProvider()),
|
|
new InMemoryTranscriptStore(),
|
|
new InMemoryMeetingNoteStore(),
|
|
new CapturingMeetingNoteOpener(),
|
|
artifactStore,
|
|
new InMemoryRecordedAudioStore(),
|
|
new CapturingMeetingSummaryPipeline(),
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
Recording = new RecordingOptions { TranscriptionProvider = "whisper-local" },
|
|
WhisperLocal = new WhisperLocalOptions
|
|
{
|
|
Diarization = new PyannoteDiarizationOptions { Enabled = true }
|
|
}
|
|
}),
|
|
NullLogger<MeetingRecordingCoordinator>.Instance);
|
|
|
|
await coordinator.StartAsync(CancellationToken.None);
|
|
await audioSource.WaitUntilCapturedAsync();
|
|
|
|
await coordinator.StopAsync(CancellationToken.None);
|
|
|
|
Assert.Equal(
|
|
[AssistantContextState.SpeakerRecognition, AssistantContextState.Summarizing, AssistantContextState.Finished],
|
|
artifactStore.States);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task VaultTranscriptStoreCreatesConfiguredFolderAndAppendsSegments()
|
|
{
|
|
var vaultFolder = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
|
|
var store = new VaultTranscriptStore(
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
Vault = new VaultOptions { TranscriptsFolder = vaultFolder }
|
|
}),
|
|
NullLogger<VaultTranscriptStore>.Instance);
|
|
|
|
var session = await store.CreateSessionAsync(CancellationToken.None);
|
|
await store.AppendAsync(
|
|
session,
|
|
new TranscriptionSegment(TimeSpan.Zero, TimeSpan.FromSeconds(1), "Unknown", "hello vault"),
|
|
CancellationToken.None);
|
|
|
|
Assert.True(Directory.Exists(vaultFolder));
|
|
Assert.EndsWith(".md", session.TranscriptPath, StringComparison.Ordinal);
|
|
Assert.Contains("hello vault", await File.ReadAllTextAsync(session.TranscriptPath));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TemporaryRecordedAudioStoreCreatesConfiguredFolderAndWritesPcmWav()
|
|
{
|
|
var recordingFolder = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
|
|
var store = new TemporaryRecordedAudioStore(
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
Recording = new RecordingOptions
|
|
{
|
|
SampleRate = 16000,
|
|
Channels = 1,
|
|
TemporaryRecordingsFolder = recordingFolder
|
|
}
|
|
}),
|
|
NullLogger<TemporaryRecordedAudioStore>.Instance);
|
|
|
|
await using var session = await store.CreateSessionAsync(CancellationToken.None);
|
|
await session.AppendAsync(new AudioChunk([1, 0, 2, 0], 16000, 1), CancellationToken.None);
|
|
await session.CompleteAsync(CancellationToken.None);
|
|
|
|
Assert.True(Directory.Exists(recordingFolder));
|
|
Assert.EndsWith(".wav", session.AudioPath, StringComparison.Ordinal);
|
|
Assert.True(new FileInfo(session.AudioPath).Length > 44);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task TemporaryRecordedAudioStoreDeletesStaleRecordingsOnStartup()
|
|
{
|
|
var recordingFolder = Path.Combine(Path.GetTempPath(), "meeting-assistant-tests", Guid.NewGuid().ToString("N"));
|
|
Directory.CreateDirectory(recordingFolder);
|
|
var staleRecording = Path.Combine(recordingFolder, "stale.wav");
|
|
var unrelatedFile = Path.Combine(recordingFolder, "keep.txt");
|
|
await File.WriteAllTextAsync(staleRecording, "stale");
|
|
await File.WriteAllTextAsync(unrelatedFile, "keep");
|
|
var store = new TemporaryRecordedAudioStore(
|
|
Options.Create(new MeetingAssistantOptions
|
|
{
|
|
Recording = new RecordingOptions { TemporaryRecordingsFolder = recordingFolder }
|
|
}),
|
|
NullLogger<TemporaryRecordedAudioStore>.Instance);
|
|
|
|
await store.DeleteStaleRecordingsAsync(CancellationToken.None);
|
|
|
|
Assert.False(File.Exists(staleRecording));
|
|
Assert.True(File.Exists(unrelatedFile));
|
|
}
|
|
|
|
private static MeetingAssistantOptions CreateOptionsWithoutFinalizer()
|
|
{
|
|
return new MeetingAssistantOptions
|
|
{
|
|
Recording = new RecordingOptions { TranscriptionProvider = "whisper-local" },
|
|
WhisperLocal = new WhisperLocalOptions
|
|
{
|
|
Diarization = new PyannoteDiarizationOptions { Enabled = false }
|
|
}
|
|
};
|
|
}
|
|
|
|
private sealed class InMemoryTranscriptStore : ITranscriptStore
|
|
{
|
|
private readonly List<TranscriptionSegment> segments = [];
|
|
private readonly TaskCompletionSource segmentWritten = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
private readonly string transcriptPath;
|
|
|
|
public InMemoryTranscriptStore(string transcriptPath = "memory-transcript.md")
|
|
{
|
|
this.transcriptPath = transcriptPath;
|
|
}
|
|
|
|
public Task<TranscriptSession> CreateSessionAsync(CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(new TranscriptSession(transcriptPath));
|
|
}
|
|
|
|
public Task AppendAsync(TranscriptSession session, TranscriptionSegment segment, CancellationToken cancellationToken)
|
|
{
|
|
segments.Add(segment);
|
|
segmentWritten.TrySetResult();
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public async Task WaitForTextAsync(string text)
|
|
{
|
|
var deadline = DateTimeOffset.UtcNow.AddSeconds(5);
|
|
while (DateTimeOffset.UtcNow < deadline)
|
|
{
|
|
if (segments.Any(segment => segment.Text.Contains(text, StringComparison.Ordinal)))
|
|
{
|
|
return;
|
|
}
|
|
|
|
await segmentWritten.Task.WaitAsync(TimeSpan.FromMilliseconds(100));
|
|
}
|
|
|
|
throw new TimeoutException($"Segment containing '{text}' was not written.");
|
|
}
|
|
|
|
public IReadOnlyList<TranscriptionSegment> ReplacedSegments { get; private set; } = [];
|
|
|
|
public IReadOnlyList<TranscriptionSegment> Segments => segments;
|
|
|
|
public MeetingNote? MetadataMeetingNote { get; private set; }
|
|
|
|
public Task ReplaceAsync(
|
|
TranscriptSession session,
|
|
IReadOnlyList<TranscriptionSegment> replacementSegments,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
ReplacedSegments = replacementSegments;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task UpdateMetadataAsync(
|
|
TranscriptSession session,
|
|
MeetingSessionArtifacts artifacts,
|
|
MeetingNote meetingNote,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
MetadataMeetingNote = meetingNote;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
private sealed class InMemoryMeetingNoteStore : IMeetingNoteStore
|
|
{
|
|
private readonly string notePath;
|
|
|
|
public InMemoryMeetingNoteStore(string notePath = "memory-meeting.md")
|
|
{
|
|
this.notePath = notePath;
|
|
}
|
|
|
|
public MeetingNote? SavedNote { get; private set; }
|
|
|
|
public Task<MeetingNote> SaveAsync(MeetingNote note, CancellationToken cancellationToken)
|
|
{
|
|
SavedNote = note with { Path = notePath };
|
|
return Task.FromResult(SavedNote);
|
|
}
|
|
|
|
public Task<MeetingNote> ReadAsync(string path, CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(SavedNote ?? throw new FileNotFoundException(path));
|
|
}
|
|
|
|
public void UpdateAttendees(IEnumerable<string> attendees)
|
|
{
|
|
if (SavedNote is null)
|
|
{
|
|
throw new InvalidOperationException("No meeting note has been saved.");
|
|
}
|
|
|
|
SavedNote.Frontmatter.Attendees = attendees.ToList();
|
|
}
|
|
|
|
public void UpdateSavedNote(MeetingNote note)
|
|
{
|
|
SavedNote = note with { Path = notePath };
|
|
}
|
|
}
|
|
|
|
private sealed class CapturingMeetingNoteOpener : IMeetingNoteOpener
|
|
{
|
|
public string? OpenedPath { get; private set; }
|
|
|
|
public Task OpenAsync(string notePath, CancellationToken cancellationToken)
|
|
{
|
|
OpenedPath = notePath;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
private sealed class InMemoryMeetingArtifactStore : IMeetingArtifactStore
|
|
{
|
|
public MeetingSessionArtifacts? CreatedArtifacts { get; private set; }
|
|
|
|
public List<AssistantContextState> States { get; } = [];
|
|
|
|
public string? Agenda { get; private set; }
|
|
|
|
public DateTimeOffset? ScheduledEnd { get; private set; }
|
|
|
|
public Task CreateAssistantContextAsync(
|
|
MeetingSessionArtifacts artifacts,
|
|
string agenda,
|
|
DateTimeOffset? scheduledEnd,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
CreatedArtifacts = artifacts;
|
|
Agenda = agenda;
|
|
ScheduledEnd = scheduledEnd;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task UpdateAssistantContextStateAsync(
|
|
MeetingSessionArtifacts artifacts,
|
|
AssistantContextState state,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
States.Add(state);
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task UpdateAssistantContextMetadataAsync(
|
|
MeetingSessionArtifacts artifacts,
|
|
string agenda,
|
|
DateTimeOffset? scheduledEnd,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Agenda = agenda;
|
|
ScheduledEnd = scheduledEnd;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
|
|
private sealed class FixedMeetingMetadataProvider : IMeetingMetadataProvider
|
|
{
|
|
private readonly MeetingMetadata? metadata;
|
|
|
|
public FixedMeetingMetadataProvider(MeetingMetadata? metadata)
|
|
{
|
|
this.metadata = metadata;
|
|
}
|
|
|
|
public Task<MeetingMetadata?> GetCurrentMeetingAsync(
|
|
DateTimeOffset startedAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(metadata);
|
|
}
|
|
}
|
|
|
|
private sealed class ThrowingMeetingMetadataProvider : IMeetingMetadataProvider
|
|
{
|
|
public Task<MeetingMetadata?> GetCurrentMeetingAsync(
|
|
DateTimeOffset startedAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
throw new InvalidOperationException("metadata unavailable");
|
|
}
|
|
}
|
|
|
|
private sealed class BlockingMeetingMetadataProvider : IMeetingMetadataProvider
|
|
{
|
|
private readonly MeetingMetadata metadata;
|
|
private readonly TaskCompletionSource release = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public BlockingMeetingMetadataProvider(MeetingMetadata metadata)
|
|
{
|
|
this.metadata = metadata;
|
|
}
|
|
|
|
public void Release()
|
|
{
|
|
release.TrySetResult();
|
|
}
|
|
|
|
public async Task<MeetingMetadata?> GetCurrentMeetingAsync(
|
|
DateTimeOffset startedAt,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
await release.Task.WaitAsync(cancellationToken);
|
|
return metadata;
|
|
}
|
|
}
|
|
|
|
private sealed class ThrowingMeetingNoteOpener : IMeetingNoteOpener
|
|
{
|
|
public Task OpenAsync(string notePath, CancellationToken cancellationToken)
|
|
{
|
|
throw new InvalidOperationException("obsidian unavailable");
|
|
}
|
|
}
|
|
|
|
private sealed class CapturingMeetingSummaryPipeline : IMeetingSummaryPipeline
|
|
{
|
|
private readonly bool succeeded;
|
|
|
|
public CapturingMeetingSummaryPipeline(bool succeeded = true)
|
|
{
|
|
this.succeeded = succeeded;
|
|
}
|
|
|
|
public MeetingSessionArtifacts? Artifacts { get; private set; }
|
|
|
|
public Task<MeetingSummaryRunResult> RunAsync(
|
|
MeetingSessionArtifacts artifacts,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Artifacts = artifacts;
|
|
return Task.FromResult(new MeetingSummaryRunResult(
|
|
artifacts.SummaryPath,
|
|
succeeded ? "summary ok" : "summary failed",
|
|
succeeded,
|
|
succeeded ? null : "error"));
|
|
}
|
|
}
|
|
|
|
private sealed class InMemoryRecordedAudioStore : IRecordedAudioStore
|
|
{
|
|
private readonly string audioPath;
|
|
|
|
public InMemoryRecordedAudioStore(string audioPath = "memory-recording.wav")
|
|
{
|
|
this.audioPath = audioPath;
|
|
}
|
|
|
|
public List<int> AppendedChunkSizes { get; } = [];
|
|
|
|
public bool Completed { get; private set; }
|
|
|
|
public bool Deleted { get; private set; }
|
|
|
|
private TaskCompletionSource AppendObserved { get; set; } =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public Task WaitForAppendAsync()
|
|
{
|
|
return AppendObserved.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
}
|
|
|
|
public Task<IRecordedAudioSink> CreateSessionAsync(CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult<IRecordedAudioSink>(new Sink(this, audioPath));
|
|
}
|
|
|
|
public Task DeleteStaleRecordingsAsync(CancellationToken cancellationToken)
|
|
{
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
private sealed class Sink : IRecordedAudioSink
|
|
{
|
|
private readonly InMemoryRecordedAudioStore store;
|
|
|
|
public Sink(InMemoryRecordedAudioStore store, string audioPath)
|
|
{
|
|
this.store = store;
|
|
AudioPath = audioPath;
|
|
}
|
|
|
|
public string AudioPath { get; }
|
|
|
|
public Task AppendAsync(AudioChunk chunk, CancellationToken cancellationToken)
|
|
{
|
|
store.AppendedChunkSizes.Add(chunk.Pcm.Length);
|
|
store.AppendObserved.TrySetResult();
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public Task CompleteAsync(CancellationToken cancellationToken)
|
|
{
|
|
store.Completed = true;
|
|
return Task.CompletedTask;
|
|
}
|
|
|
|
public ValueTask DisposeAsync()
|
|
{
|
|
return ValueTask.CompletedTask;
|
|
}
|
|
|
|
public Task DeleteAsync(CancellationToken cancellationToken)
|
|
{
|
|
store.Deleted = true;
|
|
return Task.CompletedTask;
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class TestSpeechRecognitionPipelineFactory : ISpeechRecognitionPipelineFactory
|
|
{
|
|
private readonly IStreamingTranscriptionProvider provider;
|
|
private readonly Func<string, IReadOnlyList<TranscriptionSegment>, SpeechRecognitionPipelineOptions, CancellationToken, Task<IReadOnlyList<TranscriptionSegment>>> finalize;
|
|
|
|
public TestSpeechRecognitionPipelineFactory(
|
|
IStreamingTranscriptionProvider provider,
|
|
Func<string, IReadOnlyList<TranscriptionSegment>, SpeechRecognitionPipelineOptions, CancellationToken, Task<IReadOnlyList<TranscriptionSegment>>>? finalize = null)
|
|
{
|
|
this.provider = provider;
|
|
this.finalize = finalize ?? ((_, _, _, _) => Task.FromResult<IReadOnlyList<TranscriptionSegment>>([]));
|
|
}
|
|
|
|
public ISpeechRecognitionPipeline Create()
|
|
{
|
|
return new TestSpeechRecognitionPipeline(provider, finalize);
|
|
}
|
|
}
|
|
|
|
private sealed class TestSpeechRecognitionPipeline : StreamingSpeechRecognitionPipeline
|
|
{
|
|
private readonly Func<string, IReadOnlyList<TranscriptionSegment>, SpeechRecognitionPipelineOptions, CancellationToken, Task<IReadOnlyList<TranscriptionSegment>>> finalize;
|
|
|
|
public TestSpeechRecognitionPipeline(
|
|
IStreamingTranscriptionProvider provider,
|
|
Func<string, IReadOnlyList<TranscriptionSegment>, SpeechRecognitionPipelineOptions, CancellationToken, Task<IReadOnlyList<TranscriptionSegment>>> finalize)
|
|
: base(provider)
|
|
{
|
|
this.finalize = finalize;
|
|
}
|
|
|
|
protected override Task<IReadOnlyList<TranscriptionSegment>> BuildFinishedTranscriptAsync(
|
|
string audioPath,
|
|
IReadOnlyList<TranscriptionSegment> liveSegments,
|
|
SpeechRecognitionPipelineOptions options,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return finalize(audioPath, liveSegments, options, cancellationToken);
|
|
}
|
|
}
|
|
|
|
private sealed class CapturingTranscriptFinalizer
|
|
{
|
|
private readonly IReadOnlyList<TranscriptionSegment> segments;
|
|
|
|
public CapturingTranscriptFinalizer(IReadOnlyList<TranscriptionSegment> segments)
|
|
{
|
|
this.segments = segments;
|
|
}
|
|
|
|
public string? AudioPath { get; private set; }
|
|
|
|
public IReadOnlyList<TranscriptionSegment> LiveSegments { get; private set; } = [];
|
|
|
|
public SpeechRecognitionPipelineOptions? Options { get; private set; }
|
|
|
|
public Task<IReadOnlyList<TranscriptionSegment>> FinalizeAsync(
|
|
string audioPath,
|
|
IReadOnlyList<TranscriptionSegment> liveSegments,
|
|
SpeechRecognitionPipelineOptions options,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
AudioPath = audioPath;
|
|
LiveSegments = liveSegments;
|
|
Options = options;
|
|
return Task.FromResult(segments);
|
|
}
|
|
}
|
|
|
|
private sealed class FixedSpeakerIdentificationService : ISpeakerIdentificationService
|
|
{
|
|
private readonly string sourceSpeaker;
|
|
private readonly string targetSpeaker;
|
|
private readonly IReadOnlyList<string> acceptedNames;
|
|
|
|
public FixedSpeakerIdentificationService(
|
|
string sourceSpeaker,
|
|
string targetSpeaker,
|
|
IReadOnlyList<string>? acceptedNames = null)
|
|
{
|
|
this.sourceSpeaker = sourceSpeaker;
|
|
this.targetSpeaker = targetSpeaker;
|
|
this.acceptedNames = acceptedNames ?? [targetSpeaker];
|
|
}
|
|
|
|
public Task<SpeakerIdentificationResult> ProcessFinishedTranscriptAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(new SpeakerIdentificationResult(
|
|
request.Segments.Select(segment => segment.Speaker == sourceSpeaker
|
|
? segment with { Speaker = targetSpeaker }
|
|
: segment).ToList(),
|
|
new Dictionary<string, string> { [sourceSpeaker] = targetSpeaker },
|
|
[new SpeakerIdentityAttendeeMatch(targetSpeaker, acceptedNames)]));
|
|
}
|
|
|
|
public Task<SpeakerIdentificationResult> IdentifyKnownSpeakersAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return ProcessFinishedTranscriptAsync(request, cancellationToken);
|
|
}
|
|
}
|
|
|
|
private sealed class BlockingSpeakerIdentificationService : ISpeakerIdentificationService
|
|
{
|
|
private readonly string sourceSpeaker;
|
|
private readonly string targetSpeaker;
|
|
private readonly IReadOnlyList<string> acceptedNames;
|
|
|
|
public BlockingSpeakerIdentificationService(
|
|
string sourceSpeaker,
|
|
string targetSpeaker,
|
|
IReadOnlyList<string>? acceptedNames = null)
|
|
{
|
|
this.sourceSpeaker = sourceSpeaker;
|
|
this.targetSpeaker = targetSpeaker;
|
|
this.acceptedNames = acceptedNames ?? [targetSpeaker];
|
|
}
|
|
|
|
public TaskCompletionSource IdentificationObserved { get; } =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public Task<SpeakerIdentificationResult> IdentifyKnownSpeakersAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
IdentificationObserved.TrySetResult();
|
|
return Task.FromResult(new SpeakerIdentificationResult(
|
|
request.Segments,
|
|
new Dictionary<string, string> { [sourceSpeaker] = targetSpeaker },
|
|
[new SpeakerIdentityAttendeeMatch(targetSpeaker, acceptedNames)]));
|
|
}
|
|
|
|
public Task<SpeakerIdentificationResult> ProcessFinishedTranscriptAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(new SpeakerIdentificationResult(request.Segments, new Dictionary<string, string>()));
|
|
}
|
|
}
|
|
|
|
private sealed class CountingSpeakerIdentificationService : ISpeakerIdentificationService
|
|
{
|
|
public List<SpeakerIdentificationRequest> Requests { get; } = [];
|
|
|
|
public Task<SpeakerIdentificationResult> IdentifyKnownSpeakersAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
Requests.Add(request);
|
|
return Task.FromResult(new SpeakerIdentificationResult(request.Segments, new Dictionary<string, string>()));
|
|
}
|
|
|
|
public Task<SpeakerIdentificationResult> ProcessFinishedTranscriptAsync(
|
|
SpeakerIdentificationRequest request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(new SpeakerIdentificationResult(request.Segments, new Dictionary<string, string>()));
|
|
}
|
|
}
|
|
|
|
private sealed class FixedDictationWordStore : IDictationWordStore
|
|
{
|
|
private readonly IReadOnlyList<string> words;
|
|
|
|
public FixedDictationWordStore(IReadOnlyList<string> words)
|
|
{
|
|
this.words = words;
|
|
}
|
|
|
|
public Task<IReadOnlyList<string>> ReadWordsAsync(CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(words);
|
|
}
|
|
|
|
public Task<IReadOnlyList<string>> AddWordAsync(string word, CancellationToken cancellationToken)
|
|
{
|
|
return Task.FromResult(words);
|
|
}
|
|
}
|
|
|
|
private sealed class CapturingPipelineOptionsProvider : IStreamingTranscriptionProvider
|
|
{
|
|
public TaskCompletionSource OptionsObserved { get; } =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public SpeechRecognitionPipelineOptions? Options { get; private set; }
|
|
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
Options = options;
|
|
OptionsObserved.TrySetResult();
|
|
await foreach (var _ in audio.WithCancellation(cancellationToken))
|
|
{
|
|
yield return new TranscriptionSegment(TimeSpan.Zero, TimeSpan.Zero, "Unknown", "ok");
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class OrderedChunkProvider : IStreamingTranscriptionProvider
|
|
{
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
var index = 0;
|
|
await foreach (var _ in audio.WithCancellation(cancellationToken))
|
|
{
|
|
var text = index++ == 0 ? "first" : "second";
|
|
yield return new TranscriptionSegment(
|
|
TimeSpan.FromSeconds(index - 1),
|
|
TimeSpan.FromSeconds(index + 1),
|
|
"Guest03",
|
|
$"{text} has enough words for identification.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class ChangingSpeakerOrderedChunkProvider : IStreamingTranscriptionProvider
|
|
{
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
var index = 0;
|
|
await foreach (var _ in audio.WithCancellation(cancellationToken))
|
|
{
|
|
var speaker = index++ == 0 ? "Guest03" : "Guest04";
|
|
yield return new TranscriptionSegment(
|
|
TimeSpan.FromSeconds(index - 1),
|
|
TimeSpan.FromSeconds(index + 1),
|
|
speaker,
|
|
"This segment has enough words for identification.");
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class ControlledAudioSource : IMeetingAudioSource
|
|
{
|
|
private readonly Channel<AudioChunk> chunks = Channel.CreateUnbounded<AudioChunk>();
|
|
|
|
public IAsyncEnumerable<AudioChunk> CaptureAsync(CancellationToken cancellationToken)
|
|
{
|
|
return chunks.Reader.ReadAllAsync(cancellationToken);
|
|
}
|
|
|
|
public ValueTask WriteAsync(AudioChunk chunk, CancellationToken cancellationToken)
|
|
{
|
|
return chunks.Writer.WriteAsync(chunk, cancellationToken);
|
|
}
|
|
}
|
|
|
|
private sealed class CapturedChunkThenCancelAudioSource : IMeetingAudioSource
|
|
{
|
|
private readonly AudioChunk chunk;
|
|
private readonly TaskCompletionSource captured = new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public CapturedChunkThenCancelAudioSource(AudioChunk chunk)
|
|
{
|
|
this.chunk = chunk;
|
|
}
|
|
|
|
public async IAsyncEnumerable<AudioChunk> CaptureAsync(
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
yield return chunk;
|
|
captured.TrySetResult();
|
|
|
|
try
|
|
{
|
|
await Task.Delay(Timeout.InfiniteTimeSpan, cancellationToken);
|
|
}
|
|
finally
|
|
{
|
|
captured.TrySetResult();
|
|
}
|
|
}
|
|
|
|
public Task WaitUntilCapturedAsync()
|
|
{
|
|
return captured.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
}
|
|
}
|
|
|
|
private sealed class EchoStreamingTranscriptionProvider : IStreamingTranscriptionProvider
|
|
{
|
|
public bool FirstChunkWasObservedBeforeSourceCompleted { get; private set; }
|
|
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
await foreach (var chunk in audio.WithCancellation(cancellationToken))
|
|
{
|
|
FirstChunkWasObservedBeforeSourceCompleted = true;
|
|
yield return new TranscriptionSegment(TimeSpan.Zero, TimeSpan.Zero, "Unknown", $"chunk:{chunk.Pcm.Length}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class FinalSegmentOnAudioCompletionProvider : IStreamingTranscriptionProvider
|
|
{
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
var byteCount = 0;
|
|
await foreach (var chunk in audio.WithCancellation(cancellationToken))
|
|
{
|
|
byteCount += chunk.Pcm.Length;
|
|
}
|
|
|
|
yield return new TranscriptionSegment(TimeSpan.Zero, TimeSpan.Zero, "Unknown", $"final:{byteCount}");
|
|
}
|
|
}
|
|
|
|
private sealed class BlockingBeforeTranscriptionProvider : IStreamingTranscriptionProvider
|
|
{
|
|
private readonly TaskCompletionSource waitingForBackend =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
private readonly TaskCompletionSource backendReady =
|
|
new(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
public Task WaitUntilWaitingForBackendAsync()
|
|
{
|
|
return waitingForBackend.Task.WaitAsync(TimeSpan.FromSeconds(5));
|
|
}
|
|
|
|
public void MarkBackendReady()
|
|
{
|
|
backendReady.TrySetResult();
|
|
}
|
|
|
|
public async IAsyncEnumerable<TranscriptionSegment> TranscribeAsync(
|
|
IAsyncEnumerable<AudioChunk> audio,
|
|
SpeechRecognitionPipelineOptions options,
|
|
[System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken)
|
|
{
|
|
waitingForBackend.TrySetResult();
|
|
await backendReady.Task.WaitAsync(cancellationToken);
|
|
await foreach (var chunk in audio.WithCancellation(cancellationToken))
|
|
{
|
|
yield return new TranscriptionSegment(TimeSpan.Zero, TimeSpan.Zero, "Unknown", $"chunk:{chunk.Pcm.Length}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private static byte[] Samples(params short[] samples)
|
|
{
|
|
var bytes = new byte[samples.Length * sizeof(short)];
|
|
Buffer.BlockCopy(samples, 0, bytes, 0, bytes.Length);
|
|
return bytes;
|
|
}
|
|
}
|
|
|
|
|
|
|