feat: Add Azure OpenAI Realtime API support for transcription (STT)

apps/cli/src/output.rs

@@ -44,10 +44,14 @@ async fn ensure_parent_dirs(path: &Path) -> CliResult<()> {
     Ok(())
 }
 
-async fn write_bytes_to(output: Option<&Path>, bytes: Vec<u8>) -> CliResult<()> {
+async fn write_bytes_to(output: Option<&Path>, bytes: Vec<u8>, add_newline: bool) -> CliResult<()> {
     if let Some(path) = output {
         ensure_parent_dirs(path).await?;
-        tokio::fs::write(path, bytes)
+        let mut data = bytes;
+        if add_newline {
+            data.push(b'\n');
+        }
+        tokio::fs::write(path, data)
             .await
             .map_err(|e| CliError::operation_failed("write output", e.to_string()))?;
         return Ok(());
@@ -56,14 +60,17 @@ async fn write_bytes_to(output: Option<&Path>, bytes: Vec<u8>) -> CliResult<()>
     std::io::stdout()
         .write_all(&bytes)
         .map_err(|e| CliError::operation_failed("write output", e.to_string()))?;
-    std::io::stdout()
-        .write_all(b"\n")
-        .map_err(|e| CliError::operation_failed("write output", e.to_string()))?;
+    if add_newline {
+        std::io::stdout()
+            .write_all(b"\n")
+            .map_err(|e| CliError::operation_failed("write output", e.to_string()))?;
+    }
     Ok(())
 }
 
 pub async fn write_text(output: Option<&Path>, text: String) -> CliResult<()> {
-    write_bytes_to(output, (text + "\n").into_bytes()).await
+    // Text content; add single trailing newline for POSIX compliance
+    write_bytes_to(output, text.into_bytes(), true).await
 }
 
 pub async fn write_json(output: Option<&Path>, value: &impl serde::Serialize) -> CliResult<()> {
@@ -74,7 +81,8 @@ pub async fn write_json(output: Option<&Path>, value: &impl serde::Serialize) ->
     }
     .map_err(|e| CliError::operation_failed("serialize response", e.to_string()))?;
 
-    write_bytes_to(output, bytes).await
+    // JSON output needs trailing newline for POSIX compliance
+    write_bytes_to(output, bytes, true).await
 }
 
 #[cfg(test)]

apps/desktop/src/auth/context.tsx

@@ -65,6 +65,28 @@ export type AuthContextType = AuthState &
 
 const AuthContext = createContext<AuthContextType | null>(null);
 
+const MOCK_SESSION: Session = {
+  access_token: "mock-access-token",
+  refresh_token: "mock-refresh-token",
+  token_type: "bearer",
+  expires_in: 3600,
+  expires_at: Math.floor(Date.now() / 1000) + 3600 * 24 * 365,
+  user: {
+    id: "00000000-0000-0000-0000-000000000000",
+    aud: "authenticated",
+    role: "authenticated",
+    email: "local@localhost",
+    email_confirmed_at: new Date().toISOString(),
+    phone: "",
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    app_metadata: {},
+    user_metadata: {},
+    identities: [],
+    factors: [],
+  },
+};
+
 export function useAuth() {
   const context = useContext(AuthContext);
 
@@ -197,6 +219,8 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
 
   useEffect(() => {
     if (!supabase) {
+      console.log("[auth] Supabase not configured, using mock session");
+      setSession(MOCK_SESSION);
       return;
     }
 

apps/desktop/src/onboarding/index.tsx

@@ -4,7 +4,7 @@ import { Volume2Icon, VolumeXIcon } from "lucide-react";
 import { useCallback, useEffect, useRef, useState } from "react";
 
 import { commands as analyticsCommands } from "@hypr/plugin-analytics";
-import { commands as sfxCommands } from "@hypr/plugin-sfx";
+// import { commands as sfxCommands } from "@hypr/plugin-sfx";
 
 import { LoginSection } from "./account";
 import { CalendarSection } from "./calendar";
@@ -90,19 +90,21 @@ export function TabContentOnboarding({
     });
   }, [currentStep]);
 
-  useEffect(() => {
-    sfxCommands
-      .play("BGM")
-      .then(() => sfxCommands.setVolume("BGM", 0.2))
-      .catch(console.error);
-    return () => {
-      sfxCommands.stop("BGM").catch(console.error);
-    };
-  }, []);
-
-  useEffect(() => {
-    sfxCommands.setVolume("BGM", isMuted ? 0 : 0.2).catch(console.error);
-  }, [isMuted]);
+  // Disabled: Background music during onboarding
+  // useEffect(() => {
+  //   sfxCommands
+  //     .play("BGM")
+  //     .then(() => sfxCommands.setVolume("BGM", 0.2))
+  //     .catch(console.error);
+  //   return () => {
+  //     sfxCommands.stop("BGM").catch(console.error);
+  //   };
+  // }, []);
+
+  // Disabled: Volume control for background music
+  // useEffect(() => {
+  //   sfxCommands.setVolume("BGM", isMuted ? 0 : 0.2).catch(console.error);
+  // }, [isMuted]);
 
   useEffect(() => {
     if (onboardingVideoRef.current) {

apps/desktop/src/routes/app/main/_layout.tsx

@@ -30,7 +30,7 @@ import {
   restoreRecentlyOpenedToStore,
   useTabs,
 } from "~/store/zustand/tabs";
-import { commands } from "~/types/tauri.gen";
+// import { commands } from "~/types/tauri.gen";
 
 export const Route = createFileRoute("/app/main/_layout")({
   component: Component,
@@ -76,12 +76,8 @@ function Component() {
         });
         const currentTabs = useTabs.getState().tabs;
         if (currentTabs.length === 0) {
-          const result = await commands.getOnboardingNeeded();
-          if (result.status === "ok" && result.data) {
-            openNew({ type: "onboarding" });
-          } else {
-            openDefaultEmptyTab();
-          }
+          // Skip onboarding - always open default empty tab
+          openDefaultEmptyTab();
         }
       }
     };

crates/audio-device/src/macos.rs

@@ -59,7 +59,7 @@ impl MacOSBackend {
             .unwrap_or(TransportType::Unknown);
 
         let is_default = default_device_id
-            .map(|id| device.0.0 == id)
+            .map(|id| device.0 .0 == id)
             .unwrap_or(false);
 
         let mut audio_device = AudioDevice {
@@ -102,7 +102,11 @@ impl MacOSBackend {
             })
         });
 
-        if detected { Some(true) } else { None }
+        if detected {
+            Some(true)
+        } else {
+            None
+        }
     }
 
     fn is_external_from_device(device: Option<ca::Device>) -> bool {
@@ -120,8 +124,8 @@ impl AudioDeviceBackend for MacOSBackend {
         let ca_devices =
             ca::System::devices().map_err(|e| Error::EnumerationFailed(format!("{:?}", e)))?;
 
-        let default_input_id = ca::System::default_input_device().ok().map(|d| d.0.0);
-        let default_output_id = ca::System::default_output_device().ok().map(|d| d.0.0);
+        let default_input_id = ca::System::default_input_device().ok().map(|d| d.0 .0);
+        let default_output_id = ca::System::default_output_device().ok().map(|d| d.0 .0);
 
         let mut devices = Vec::new();
 
@@ -161,7 +165,7 @@ impl AudioDeviceBackend for MacOSBackend {
         Ok(Self::create_audio_device(
             &ca_device,
             AudioDirection::Input,
-            Some(ca_device.0.0),
+            Some(ca_device.0 .0),
         ))
     }
 
@@ -178,7 +182,7 @@ impl AudioDeviceBackend for MacOSBackend {
         Ok(Self::create_audio_device(
             &ca_device,
             AudioDirection::Output,
-            Some(ca_device.0.0),
+            Some(ca_device.0 .0),
         ))
     }
 

crates/audio-device/src/windows.rs

@@ -1,17 +1,17 @@
 use crate::{AudioDevice, AudioDeviceBackend, AudioDirection, DeviceId, Error, TransportType};
 use std::ffi::OsString;
 use std::os::windows::ffi::OsStringExt;
+use windows::core::{Interface, GUID, PCWSTR, PWSTR};
 use windows::Win32::Devices::FunctionDiscovery::PKEY_Device_FriendlyName;
 use windows::Win32::Media::Audio::Endpoints::IAudioEndpointVolume;
 use windows::Win32::Media::Audio::{
-    DEVICE_STATE_ACTIVE, IMMDevice, IMMDeviceEnumerator, MMDeviceEnumerator, eAll, eCapture,
-    eConsole, eRender,
+    eAll, eCapture, eConsole, eRender, IMMDevice, IMMDeviceEnumerator, MMDeviceEnumerator,
+    DEVICE_STATE_ACTIVE,
 };
 use windows::Win32::System::Com::{
-    CLSCTX_ALL, COINIT_MULTITHREADED, CoCreateInstance, CoInitializeEx, CoUninitialize, STGM_READ,
+    CoCreateInstance, CoInitializeEx, CoUninitialize, CLSCTX_ALL, COINIT_MULTITHREADED, STGM_READ,
 };
 use windows::Win32::UI::Shell::PropertiesSystem::IPropertyStore;
-use windows::core::{GUID, Interface, PCWSTR, PWSTR};
 
 pub struct WindowsBackend;
 

crates/owhisper-client/src/adapter/openai/live.rs

@@ -29,8 +29,18 @@ impl RealtimeSttAdapter for OpenAIAdapter {
         false
     }
 
-    fn build_ws_url(&self, api_base: &str, _params: &ListenParams, _channels: u8) -> url::Url {
-        let (mut url, existing_params) = Self::build_ws_url_from_base(api_base);
+    fn build_ws_url(&self, api_base: &str, params: &ListenParams, _channels: u8) -> url::Url {
+        // Detect Azure from the base URL and store flag for initial_message
+        if let Ok(parsed) = api_base.parse::<url::Url>() {
+            if let Some(host) = parsed.host_str() {
+                if Self::is_azure_host(host) {
+                    self.set_azure(true);
+                }
+            }
+        }
+
+        let model = params.model.as_deref();
+        let (mut url, existing_params) = Self::build_ws_url_from_base_with_model(api_base, model);
 
         if !existing_params.is_empty() {
             let mut query_pairs = url.query_pairs_mut();
@@ -78,6 +88,11 @@ impl RealtimeSttAdapter for OpenAIAdapter {
             None => default,
         };
 
+        // Use the Azure flag set during build_ws_url (detected from api_base URL)
+        if self.is_azure() {
+            return self.build_azure_initial_message(model, language);
+        }
+
         let session_config = SessionUpdateEvent {
             event_type: "session.update".to_string(),
             session: SessionConfig {
@@ -227,6 +242,76 @@ impl RealtimeSttAdapter for OpenAIAdapter {
     }
 }
 
+impl OpenAIAdapter {
+    /// Build Azure OpenAI-specific initial message
+    /// Azure uses a different session update format: transcription_session.update
+    fn build_azure_initial_message(
+        &self,
+        model: &str,
+        language: Option<String>,
+    ) -> Option<Message> {
+        let session_update = AzureTranscriptionSessionUpdate {
+            event_type: "transcription_session.update".to_string(),
+            session: AzureSessionConfig {
+                input_audio_format: "pcm16".to_string(),
+                input_audio_transcription: AzureTranscriptionConfig {
+                    model: model.to_string(),
+                    prompt: None,
+                    language,
+                },
+                turn_detection: Some(AzureTurnDetection {
+                    detection_type: VAD_DETECTION_TYPE.to_string(),
+                    threshold: Some(VAD_THRESHOLD),
+                    prefix_padding_ms: Some(VAD_PREFIX_PADDING_MS),
+                    silence_duration_ms: Some(VAD_SILENCE_DURATION_MS),
+                }),
+            },
+        };
+
+        let json = serde_json::to_string(&session_update).ok()?;
+        tracing::debug!(payload = %json, "azure_openai_session_update_payload");
+        Some(Message::Text(json.into()))
+    }
+}
+
+// Azure OpenAI specific session message types
+
+#[derive(Debug, Serialize)]
+struct AzureTranscriptionSessionUpdate {
+    #[serde(rename = "type")]
+    event_type: String,
+    session: AzureSessionConfig,
+}
+
+#[derive(Debug, Serialize)]
+struct AzureSessionConfig {
+    input_audio_format: String,
+    input_audio_transcription: AzureTranscriptionConfig,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    turn_detection: Option<AzureTurnDetection>,
+}
+
+#[derive(Debug, Serialize)]
+struct AzureTranscriptionConfig {
+    model: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    prompt: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    language: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+struct AzureTurnDetection {
+    #[serde(rename = "type")]
+    detection_type: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    threshold: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    prefix_padding_ms: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    silence_duration_ms: Option<u32>,
+}
+
 #[derive(Debug, Serialize)]
 struct SessionUpdateEvent {
     #[serde(rename = "type")]