fix proxy handling in adaptors

yujonglee · yujonglee · commit 879c88c611cb · 2025-12-04T10:42:02.000+09:00
diff --git a/apps/api/src/stt/connection.ts b/apps/api/src/stt/connection.ts
@@ -17,6 +17,7 @@ type QueuedPayload = { payload: WsPayload; size: number };
 export type WsProxyOptions = {
   headers?: Record<string, string>;
   controlMessageTypes?: ReadonlySet<string>;
+  transformFirstMessage?: (payload: WsPayload) => WsPayload;
 };
 
 const DEFAULT_CONTROL_MESSAGE_TYPES = new Set<string>();
@@ -37,6 +38,8 @@ export class WsProxyConnection {
 
   private readonly headers?: Record<string, string>;
   private readonly controlMessageTypes: ReadonlySet<string>;
+  private readonly transformFirstMessage?: (payload: WsPayload) => WsPayload;
+  private hasTransformedFirst = false;
 
   constructor(
     private upstreamUrl: string,
@@ -45,6 +48,7 @@ export class WsProxyConnection {
     this.headers = options.headers;
     this.controlMessageTypes =
       options.controlMessageTypes ?? DEFAULT_CONTROL_MESSAGE_TYPES;
+    this.transformFirstMessage = options.transformFirstMessage;
   }
 
   private clearErrorTimeout() {
@@ -343,18 +347,26 @@ export class WsProxyConnection {
       return;
     }
 
+    let finalPayload = payload;
+    if (!this.hasTransformedFirst && this.transformFirstMessage) {
+      finalPayload = this.transformFirstMessage(payload);
+      this.hasTransformedFirst = true;
+    } else if (!this.hasTransformedFirst) {
+      this.hasTransformedFirst = true;
+    }
+
     const isControlPayload = payloadIsControlMessage(
-      payload,
+      finalPayload,
       this.controlMessageTypes,
     );
 
     if (!this.upstreamReady) {
-      this.enqueuePendingPayload(payload, isControlPayload);
+      this.enqueuePendingPayload(finalPayload, isControlPayload);
       return;
     }
 
     try {
-      this.upstream.send(payload);
+      this.upstream.send(finalPayload);
     } catch (error) {
       console.error(error);
       this.closeConnections(DEFAULT_CLOSE_CODE, "upstream_send_failed");
diff --git a/apps/api/src/stt/soniox.ts b/apps/api/src/stt/soniox.ts
@@ -12,8 +12,22 @@ export const createSonioxProxy = (): WsProxyConnection => {
     throw new Error("SONIOX_API_KEY not configured");
   }
 
+  const apiKey = env.SONIOX_API_KEY;
   const target = buildSonioxUrl();
+
   return new WsProxyConnection(target.toString(), {
     controlMessageTypes: CONTROL_MESSAGE_TYPES,
+    transformFirstMessage: (payload) => {
+      if (typeof payload !== "string") {
+        return payload;
+      }
+      try {
+        const config = JSON.parse(payload);
+        config.api_key = apiKey;
+        return JSON.stringify(config);
+      } catch {
+        return payload;
+      }
+    },
   });
 };
diff --git a/owhisper/owhisper-client/src/adapter/assemblyai/mod.rs b/owhisper/owhisper-client/src/adapter/assemblyai/mod.rs
@@ -27,6 +27,10 @@ impl AssemblyAIAdapter {
             );
         }
 
+        if let Some(proxy_result) = super::build_proxy_ws_url(api_base) {
+            return proxy_result;
+        }
+
         if api_base.contains(".eu.") || api_base.ends_with("-eu") {
             return (
                 "wss://streaming.eu.assemblyai.com/v3/ws"
@@ -70,26 +74,25 @@ mod tests {
     }
 
     #[test]
-    fn test_streaming_ws_url_preserves_query_params() {
-        let (url, params) =
-            AssemblyAIAdapter::streaming_ws_url("https://api.hyprnote.com/v1?provider=assemblyai");
-        assert_eq!(url.as_str(), "wss://api.hyprnote.com/v1/v3/ws");
-        assert_eq!(params, vec![("provider".into(), "assemblyai".into())]);
+    fn test_streaming_ws_url_empty_uses_default() {
+        let (url, params) = AssemblyAIAdapter::streaming_ws_url("");
+        assert_eq!(url.as_str(), "wss://streaming.assemblyai.com/v3/ws");
+        assert!(params.is_empty());
     }
 
     #[test]
-    fn test_streaming_ws_url_no_double_v3_ws() {
-        let (url, params) = AssemblyAIAdapter::streaming_ws_url(
-            "https://api.hyprnote.com/v3/ws?provider=assemblyai",
-        );
-        assert_eq!(url.as_str(), "wss://api.hyprnote.com/v3/ws");
+    fn test_streaming_ws_url_proxy() {
+        let (url, params) =
+            AssemblyAIAdapter::streaming_ws_url("https://api.hyprnote.com?provider=assemblyai");
+        assert_eq!(url.as_str(), "wss://api.hyprnote.com/listen");
         assert_eq!(params, vec![("provider".into(), "assemblyai".into())]);
     }
 
     #[test]
-    fn test_streaming_ws_url_empty_uses_default() {
-        let (url, params) = AssemblyAIAdapter::streaming_ws_url("");
-        assert_eq!(url.as_str(), "wss://streaming.assemblyai.com/v3/ws");
-        assert!(params.is_empty());
+    fn test_streaming_ws_url_localhost() {
+        let (url, params) =
+            AssemblyAIAdapter::streaming_ws_url("http://localhost:8787?provider=assemblyai");
+        assert_eq!(url.as_str(), "ws://localhost:8787/listen");
+        assert_eq!(params, vec![("provider".into(), "assemblyai".into())]);
     }
 }
diff --git a/owhisper/owhisper-client/src/adapter/fireworks/mod.rs b/owhisper/owhisper-client/src/adapter/fireworks/mod.rs
@@ -56,26 +56,21 @@ impl FireworksAdapter {
             return default_url();
         }
 
+        if let Some(proxy_result) = super::build_proxy_ws_url(api_base) {
+            return proxy_result;
+        }
+
         let parsed: url::Url = match api_base.parse() {
             Ok(u) => u,
             Err(_) => return default_url(),
         };
 
-        let host = parsed.host_str().unwrap_or(DEFAULT_API_HOST);
         let existing_params = super::extract_query_params(&parsed);
 
-        if Self::is_fireworks_host(host) {
-            let url: url::Url = format!("wss://{}{}", Self::ws_host(api_base), WS_PATH)
-                .parse()
-                .expect("invalid_ws_url");
-            (url, existing_params)
-        } else {
-            let mut url = parsed;
-            url.set_query(None);
-            super::append_path_if_missing(&mut url, WS_PATH);
-            super::set_scheme_from_host(&mut url);
-            (url, existing_params)
-        }
+        let url: url::Url = format!("wss://{}{}", Self::ws_host(api_base), WS_PATH)
+            .parse()
+            .expect("invalid_ws_url");
+        (url, existing_params)
     }
 }
 
@@ -108,22 +103,16 @@ mod tests {
         let (url, params) = FireworksAdapter::build_ws_url_from_base(
             "https://api.hyprnote.com/listen?provider=fireworks",
         );
-        assert_eq!(
-            url.as_str(),
-            "wss://api.hyprnote.com/listen/v1/audio/transcriptions/streaming"
-        );
+        assert_eq!(url.as_str(), "wss://api.hyprnote.com/listen");
         assert_eq!(params, vec![("provider".into(), "fireworks".into())]);
     }
 
     #[test]
-    fn test_build_ws_url_from_base_proxy_no_double_path() {
+    fn test_build_ws_url_from_base_localhost() {
         let (url, params) = FireworksAdapter::build_ws_url_from_base(
-            "https://api.hyprnote.com/v1/audio/transcriptions/streaming?provider=fireworks",
-        );
-        assert_eq!(
-            url.as_str(),
-            "wss://api.hyprnote.com/v1/audio/transcriptions/streaming"
+            "http://localhost:8787/listen?provider=fireworks",
         );
+        assert_eq!(url.as_str(), "ws://localhost:8787/listen");
         assert_eq!(params, vec![("provider".into(), "fireworks".into())]);
     }
 }
diff --git a/owhisper/owhisper-client/src/adapter/mod.rs b/owhisper/owhisper-client/src/adapter/mod.rs
@@ -108,11 +108,30 @@ pub fn is_hyprnote_cloud_host(base_url: &str) -> bool {
     host_matches(base_url, |h| h.contains("hyprnote.com"))
 }
 
-pub fn append_provider_param(base_url: &str, provider: &str) -> String {
-    if !is_hyprnote_cloud_host(base_url) {
-        return base_url.to_string();
+pub fn build_proxy_ws_url(api_base: &str) -> Option<(url::Url, Vec<(String, String)>)> {
+    const PROXY_PATH: &str = "/listen";
+
+    if api_base.is_empty() {
+        return None;
     }
 
+    let parsed: url::Url = api_base.parse().ok()?;
+    let host = parsed.host_str()?;
+
+    if !host.contains("hyprnote.com") && !is_local_host(host) {
+        return None;
+    }
+
+    let existing_params = extract_query_params(&parsed);
+    let mut url = parsed;
+    url.set_query(None);
+    url.set_path(PROXY_PATH);
+    set_scheme_from_host(&mut url);
+
+    Some((url, existing_params))
+}
+
+pub fn append_provider_param(base_url: &str, provider: &str) -> String {
     match url::Url::parse(base_url) {
         Ok(mut url) => {
             url.query_pairs_mut().append_pair("provider", provider);
@@ -152,3 +171,80 @@ impl AdapterKind {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_build_proxy_ws_url() {
+        let cases: &[(&str, Option<(&str, Vec<(&str, &str)>)>)] = &[
+            ("", None),
+            ("https://api.deepgram.com", None),
+            ("https://api.soniox.com", None),
+            ("https://api.fireworks.ai", None),
+            ("https://api.assemblyai.com", None),
+            (
+                "https://api.hyprnote.com?provider=soniox",
+                Some((
+                    "wss://api.hyprnote.com/listen",
+                    vec![("provider", "soniox")],
+                )),
+            ),
+            (
+                "https://api.hyprnote.com/listen?provider=deepgram",
+                Some((
+                    "wss://api.hyprnote.com/listen",
+                    vec![("provider", "deepgram")],
+                )),
+            ),
+            (
+                "https://api.hyprnote.com/some/path?provider=fireworks",
+                Some((
+                    "wss://api.hyprnote.com/listen",
+                    vec![("provider", "fireworks")],
+                )),
+            ),
+            (
+                "http://localhost:8787?provider=soniox",
+                Some(("ws://localhost:8787/listen", vec![("provider", "soniox")])),
+            ),
+            (
+                "http://localhost:8787/listen?provider=deepgram",
+                Some(("ws://localhost:8787/listen", vec![("provider", "deepgram")])),
+            ),
+            (
+                "http://127.0.0.1:8787?provider=assemblyai",
+                Some((
+                    "ws://127.0.0.1:8787/listen",
+                    vec![("provider", "assemblyai")],
+                )),
+            ),
+        ];
+
+        for (input, expected) in cases {
+            let result = build_proxy_ws_url(input);
+            match (result, expected) {
+                (None, None) => {}
+                (Some((url, params)), Some((expected_url, expected_params))) => {
+                    assert_eq!(url.as_str(), *expected_url, "input: {}", input);
+                    assert_eq!(
+                        params,
+                        expected_params
+                            .iter()
+                            .map(|(k, v)| (k.to_string(), v.to_string()))
+                            .collect::<Vec<_>>(),
+                        "input: {}",
+                        input
+                    );
+                }
+                (result, expected) => {
+                    panic!(
+                        "input: {}, expected: {:?}, got: {:?}",
+                        input, expected, result
+                    );
+                }
+            }
+        }
+    }
+}
diff --git a/owhisper/owhisper-client/src/adapter/soniox/live.rs b/owhisper/owhisper-client/src/adapter/soniox/live.rs
@@ -44,13 +44,7 @@ impl RealtimeSttAdapter for SonioxAdapter {
         params: &ListenParams,
         channels: u8,
     ) -> Option<Message> {
-        let api_key = match api_key {
-            Some(key) => key,
-            None => {
-                tracing::warn!("soniox_api_key_missing");
-                return None;
-            }
-        };
+        let api_key = api_key.unwrap_or("");
 
         let requested = params.model.as_deref().unwrap_or("stt-v3");
         let model = match requested {
diff --git a/owhisper/owhisper-client/src/adapter/soniox/mod.rs b/owhisper/owhisper-client/src/adapter/soniox/mod.rs
diff --git a/owhisper/owhisper-client/src/live.rs b/owhisper/owhisper-client/src/live.rs
