Fix Rust in-process CI failures

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: da0a9335-969e-4a77-838a-daac9206a454

Author: SteveSandersonMS

rust/src/ffi.rs

@@ -235,15 +235,17 @@ impl FfiHost {
         environment: Vec<(String, String)>,
         args: Vec<String>,
     ) -> Result<Self, Error> {
-        let entrypoint = std::fs::canonicalize(entrypoint).map_err(|e| {
-            Error::with_message(
-                ErrorKind::InvalidConfig,
-                format!(
-                    "failed to resolve in-process CLI entrypoint '{}': {e}",
-                    entrypoint.display()
-                ),
-            )
-        })?;
+        let entrypoint = std::fs::canonicalize(entrypoint)
+            .map(path_for_child_process)
+            .map_err(|e| {
+                Error::with_message(
+                    ErrorKind::InvalidConfig,
+                    format!(
+                        "failed to resolve in-process CLI entrypoint '{}': {e}",
+                        entrypoint.display()
+                    ),
+                )
+            })?;
         let library_path =
             std::fs::canonicalize(resolve_library_path(&entrypoint)?).map_err(|e| {
                 Error::with_message(
@@ -491,6 +493,33 @@ fn resolve_library_path(entrypoint: &Path) -> Result<PathBuf, Error> {
     ))
 }
 
+#[cfg(windows)]
+fn path_for_child_process(path: PathBuf) -> PathBuf {
+    use std::ffi::OsString;
+    use std::os::windows::ffi::{OsStrExt, OsStringExt};
+
+    const VERBATIM_PREFIX: &[u16] = &[b'\\' as u16, b'\\' as u16, b'?' as u16, b'\\' as u16];
+    const UNC_PREFIX: &[u16] = &[b'U' as u16, b'N' as u16, b'C' as u16, b'\\' as u16];
+
+    let encoded: Vec<u16> = path.as_os_str().encode_wide().collect();
+    let Some(stripped) = encoded.strip_prefix(VERBATIM_PREFIX) else {
+        return path;
+    };
+    let normalized = if let Some(unc_path) = stripped.strip_prefix(UNC_PREFIX) {
+        let mut result = vec![b'\\' as u16, b'\\' as u16];
+        result.extend_from_slice(unc_path);
+        result
+    } else {
+        stripped.to_vec()
+    };
+    PathBuf::from(OsString::from_wide(&normalized))
+}
+
+#[cfg(not(windows))]
+fn path_for_child_process(path: PathBuf) -> PathBuf {
+    path
+}
+
 fn build_argv_json(entrypoint: &Path, extra_args: &[String]) -> Vec<u8> {
     // A `.js` entrypoint (dev / dist-cli) is launched via node; the packaged
     // single-file CLI binary embeds its own Node and is invoked directly.
@@ -563,6 +592,19 @@ mod tests {
         );
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn child_process_path_removes_windows_verbatim_prefix() {
+        assert_eq!(
+            path_for_child_process(PathBuf::from(r"\\?\D:\a\copilot-sdk\index.js")),
+            PathBuf::from(r"D:\a\copilot-sdk\index.js")
+        );
+        assert_eq!(
+            path_for_child_process(PathBuf::from(r"\\?\UNC\server\share\copilot-sdk\index.js")),
+            PathBuf::from(r"\\server\share\copilot-sdk\index.js")
+        );
+    }
+
     #[test]
     fn environment_is_omitted_when_empty() {
         assert_eq!(build_env_json(&[]), None);

rust/src/lib.rs

@@ -925,7 +925,7 @@ fn resolve_default_transport(options: &ClientOptions) -> Result<Transport> {
 }
 
 fn resolve_default_transport_value(value: Option<&str>) -> Result<Transport> {
-    match value.as_deref() {
+    match value {
         None => Ok(Transport::Stdio { env: None }),
         Some(v) if v.is_empty() || v.eq_ignore_ascii_case("stdio") => {
             Ok(Transport::Stdio { env: None })

rust/tests/e2e.rs

@@ -37,6 +37,7 @@ mod github_telemetry;
 mod hooks;
 #[path = "e2e/hooks_extended.rs"]
 mod hooks_extended;
+#[cfg(feature = "bundled-in-process")]
 #[path = "e2e/inprocess.rs"]
 mod inprocess;
 #[path = "e2e/mcp_and_agents.rs"]

rust/tests/e2e/inprocess.rs

@@ -1,9 +1,7 @@
 use super::support::with_e2e_context;
 
-/// Mirrors the .NET `Should_Start_And_Connect_Over_InProcess_Ffi`: start a
-/// client that hosts the runtime in-process over FFI, perform a simple
-/// round-trip, and stop cleanly. Fails hard (does not skip) if the in-process
-/// runtime library can't be loaded.
+/// Starts an in-process client, performs a round-trip, and stops cleanly.
+/// Fails hard if the in-process runtime library cannot be loaded.
 #[tokio::test]
 async fn should_start_ping_and_stop_inprocess_client() {
     with_e2e_context("client", "should_start_ping_and_stop_stdio_client", |ctx| {