addressed the comments

Author: xianshijing-lk

livekit-api/src/signal_client/mod.rs

@@ -286,12 +286,15 @@ impl SignalInner {
                         return Err(err);
                     }
 
-                    // If using v1 path and it failed, always try fallback to v0 path.
-                    // The v1 endpoint might not be available on older servers, and errors
-                    // can manifest as various HTTP status codes (404, 401, 403) or connection errors.
-                    if use_v1_path {
+                    // Only fallback to v0 if the v1 endpoint returned 404 (not found).
+                    // Other errors (401, 403, 500, etc.) indicate real issues that shouldn't
+                    // be masked by falling back to a different signaling mode.
+                    let is_not_found =
+                        matches!(&err, SignalError::WsError(WsError::Http(e)) if e.status() == 404);
+
+                    if use_v1_path && is_not_found {
                         let lk_url_v0 = get_livekit_url(url, &options, false, false, None, "")?;
-                        log::warn!("v1 path failed, falling back to v0 path");
+                        log::warn!("v1 path not found (404), falling back to v0 path");
                         match SignalStream::connect(lk_url_v0.clone(), token).await {
                             Ok((new_stream, stream_events)) => (new_stream, stream_events, false),
                             Err(err) => {
@@ -304,7 +307,7 @@ impl SignalInner {
                             }
                         }
                     } else {
-                        // Connection failed on v0 path, try to retrieve more information
+                        // Connection failed, try to retrieve more information
                         Self::validate(lk_url).await?;
                         return Err(err);
                     }

livekit/src/rtc_engine/rtc_session.rs

@@ -984,51 +984,33 @@ impl SessionInner {
                 }
             }
             proto::signal_response::Message::Offer(offer) => {
-                // Store mid_to_track_id mapping
-                if !offer.mid_to_track_id.is_empty() {
-                    let mut mapping = self.mid_to_track_id.lock();
-                    for (mid, track_id) in &offer.mid_to_track_id {
-                        mapping.insert(mid.clone(), track_id.clone());
-                    }
+                // In single PC mode, client always offers and server always answers,
+                // so we should never receive an offer from the server.
+                if self.single_pc_mode {
+                    log::warn!("received unexpected offer in single PC mode, ignoring");
+                    return Ok(());
                 }
 
+                // Dual PC mode: handle offer on subscriber PC
+                log::debug!("received subscriber offer: {:?}", offer);
                 let offer_sdp =
                     SessionDescription::parse(&offer.sdp, offer.r#type.parse().unwrap()).unwrap();
 
-                if self.single_pc_mode {
-                    // In single PC mode, handle offer on publisher PC
-                    let answer = self
-                        .publisher_pc
-                        .create_anwser(offer_sdp, AnswerOptions::default())
-                        .await?;
-
-                    self.signal_client
-                        .send(proto::signal_request::Message::Answer(proto::SessionDescription {
-                            r#type: "answer".to_string(),
-                            sdp: answer.to_string(),
-                            id: offer.id,
-                            mid_to_track_id: Default::default(),
-                        }))
-                        .await;
-                } else {
-                    // Dual PC mode: handle offer on subscriber PC
-                    log::debug!("received subscriber offer: {:?}", offer);
-                    let answer = self
-                        .subscriber_pc
-                        .as_ref()
-                        .unwrap()
-                        .create_anwser(offer_sdp, AnswerOptions::default())
-                        .await?;
-
-                    self.signal_client
-                        .send(proto::signal_request::Message::Answer(proto::SessionDescription {
-                            r#type: "answer".to_string(),
-                            sdp: answer.to_string(),
-                            id: 0,
-                            mid_to_track_id: Default::default(),
-                        }))
-                        .await;
-                }
+                let answer = self
+                    .subscriber_pc
+                    .as_ref()
+                    .unwrap()
+                    .create_anwser(offer_sdp, AnswerOptions::default())
+                    .await?;
+
+                self.signal_client
+                    .send(proto::signal_request::Message::Answer(proto::SessionDescription {
+                        r#type: "answer".to_string(),
+                        sdp: answer.to_string(),
+                        id: 0,
+                        mid_to_track_id: Default::default(),
+                    }))
+                    .await;
             }
             proto::signal_response::Message::Trickle(trickle) => {
                 let target = trickle.target();