Merge pull request #57 from pragmatrix/google-v2-integration

Google Transcribe V2 Integration

Author: pragmatrix

.github/copilot-instructions.md

@@ -4,6 +4,8 @@
 - Prefer imports over deeply-qualified module paths. As a rule of thumb, avoid using more than one module prefix inline (for example, prefer importing a type and using `TypeName` instead of writing `foo::bar::TypeName` repeatedly).
 - Prefer high-level flow first: when practical, place local supporting definitions (for example helper structs, impls, functions, and type aliases) below their first use.
 - Keep imports grouped and sorted to match existing file style.
+- Avoid `maybe_` prefixes for optional variables; use neutral names and rely on type/context for optionality.
+- Avoid `_ref` suffixes for local variable names; use descriptive neutral names instead.
 
 ## Change Communication
 - Include a short rationale for each non-trivial code change.
@@ -12,3 +14,11 @@
 - Avoid defensive code unless there is concrete evidence it is necessary.
 - Avoid redundant logic and repeated calls; keep only the minimal behavior required for correctness.
 - Do not add tests unless explicitly requested by the user.
+
+## Control Flow Style
+- Prefer exhaustive `match` statements for enum-based control flow instead of `if matches!(...)` shortcuts.
+
+## Memory Promotion
+- When a durable repository-specific preference is learned during a session, write it into this file as a concise bullet if it can help future sessions.
+- Keep additions short, actionable, and scoped to coding behavior in this repository.
+- Do not add temporary experiment details or one-off debugging notes.

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "cSpell.words": [
+        "alsa",
+        "aristech",
+        "denoiser",
+        "subtag"
+    ]
+}

Cargo.toml

@@ -33,6 +33,7 @@ azure = { workspace = true }
 azure-speech = { workspace = true }
 aristech = { workspace = true }
 elevenlabs = { workspace = true }
+google-transcribe = { workspace = true }
 
 # basic
 
@@ -63,14 +64,15 @@ tracing-subscriber = { workspace = true }
 context-switch-core = { workspace = true }
 
 dotenvy = { workspace = true }
+clap = { version = "4.6.1", features = ["derive"] }
 
 # audio input
 cpal = "0.17.3"
 rodio = { workspace = true, features = ["playback"] }
 
 azure = { workspace = true }
 aristech = { workspace = true }
-google-transcribe = { path = "services/google-transcribe" }
+google-transcribe = { workspace = true }
 
 tokio = { workspace = true, features = ["rt-multi-thread"] }
 
@@ -91,6 +93,7 @@ azure = { path = "services/azure" }
 playback = { path = "services/playback" }
 aristech = { path = "services/aristech" }
 elevenlabs = { path = "services/elevenlabs" }
+google-transcribe = { path = "services/google-transcribe" }
 
 anyhow = "1.0.102"
 derive_more = { version = "2.1.1", features = ["full"] }

core/src/conversation.rs

@@ -119,13 +119,13 @@ impl Conversation {
         }
     }
 
-    pub fn require_text_output(&self, interim: bool) -> Result<()> {
+    pub fn require_text_output(&self, supports_interim_text: bool) -> Result<()> {
         for modality in &self.output_modalities {
             match modality {
                 OutputModality::Audio { .. } => bail!("No audio output expected"),
                 OutputModality::Text => {}
                 OutputModality::InterimText => {
-                    if !interim {
+                    if !supports_interim_text {
                         bail!("Interim text is unsupported")
                     }
                 }

core/src/language.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 
+use derive_more::Deref;
 use isolang::Language;
 use oxilangtag::LanguageTag;
 
@@ -24,6 +25,86 @@ impl fmt::Display for LanguageCodeError {
 
 impl std::error::Error for LanguageCodeError {}
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum LanguageListError {
+    Empty,
+    MultipleValues { count: usize },
+}
+
+impl fmt::Display for LanguageListError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LanguageListError::Empty => write!(f, "language list must contain at least one value"),
+            LanguageListError::MultipleValues { count } => {
+                write!(f, "expected exactly one language value, got {count}")
+            }
+        }
+    }
+}
+
+impl std::error::Error for LanguageListError {}
+
+/// A non-empty list of normalized language codes.
+///
+/// Values are trimmed and empty entries are removed during construction.
+/// Construction fails if no non-empty values remain.
+#[derive(Debug, Clone, PartialEq, Eq, Deref)]
+pub struct Languages(Vec<String>);
+
+impl Languages {
+    /// Creates a non-empty language list from raw values.
+    pub fn new(values: Vec<String>) -> Result<Self, LanguageListError> {
+        let values = values
+            .into_iter()
+            .map(|x| x.trim().to_owned())
+            .filter(|x| !x.is_empty())
+            .collect::<Vec<_>>();
+
+        if values.is_empty() {
+            return Err(LanguageListError::Empty);
+        }
+
+        Ok(Self(values))
+    }
+
+    /// Creates a non-empty language list from a comma-separated string.
+    pub fn from_csv(language: &str) -> Result<Self, LanguageListError> {
+        Self::new(
+            language
+                .split(',')
+                .map(str::trim)
+                .filter(|x| !x.is_empty())
+                .map(str::to_owned)
+                .collect(),
+        )
+    }
+
+    /// Returns the first language code.
+    ///
+    /// The list is guaranteed to be non-empty after construction.
+    pub fn first(&self) -> &String {
+        &self.0[0]
+    }
+
+    /// Returns the single language code.
+    ///
+    /// Fails if multiple language codes are present.
+    pub fn single(&self) -> Result<&String, LanguageListError> {
+        if self.0.len() == 1 {
+            Ok(self.first())
+        } else {
+            Err(LanguageListError::MultipleValues {
+                count: self.0.len(),
+            })
+        }
+    }
+
+    /// Returns the language codes joined by commas.
+    pub fn join_csv(&self) -> String {
+        self.0.join(",")
+    }
+}
+
 /// Converts a BCP 47 language tag into its ISO 639-3 language code.
 ///
 /// The conversion uses the primary language subtag only and ignores script, region, variant,

examples/azure-transcribe.rs

@@ -121,15 +121,15 @@ async fn recognize(format: AudioFormat, mut input_consumer: AudioConsumer) -> Re
 
     let (output_producer, mut output_consumer) = unbounded_channel();
     // For now this is more or less unbounded, because we push complete audio files for recognition.
-    let (conv_input_producer, conv_input_consumer) = channel(16384);
+    let (conversation_input_producer, conversation_input_consumer) = channel(16384);
 
     let azure = AzureTranscribe;
     let mut conversation = azure.conversation(
         params,
         Conversation::new(
             InputModality::Audio { format },
             [OutputModality::Text, OutputModality::InterimText],
-            conv_input_consumer,
+            conversation_input_consumer,
             output_producer,
         ),
     );
@@ -144,7 +144,7 @@ async fn recognize(format: AudioFormat, mut input_consumer: AudioConsumer) -> Re
             // Forward audio input
             input = input_consumer.consume() => {
                 if let Some(frame) = input {
-                    conv_input_producer.try_send(Input::Audio {frame})?;
+                    conversation_input_producer.try_send(Input::Audio {frame})?;
                 }
                 else {
                     println!("End of input");