Rust: full in-process (FFI) parity with .NET/TS

Bring the Rust in-process transport in line with the .NET and TypeScript SDKs.

Product:
- Transport::InProcess passes no per-client env to the FFI worker; the worker
  inherits this host process's ambient environment. Per-client options that lower
  to env vars (env/env_remove, telemetry, github_token, base_directory) are not
  honored in-process, matching .NET/TS; documented as experimental, pointing at
  #1934. Removes the now-unused build_ffi_environment.

E2E harness:
- InProcessEnvGuard mirrors each test's environment onto the real process
  environment (which the in-process worker inherits) and restores it on drop,
  plus disables ambient HMAC so host-side auth picks the token the snapshots
  expect. Forces serial execution in-process (concurrency 1) so the process-wide
  env mutation is coherent; stdio/tcp are unchanged.
- skip_inprocess guard skips tests for features the in-process transport can't
  support; applied to the telemetry file-export test (telemetry lowers to env
  vars) and the unknown-checkpoint test (readCheckpoint decodes the id as u32
  natively in-process and rejects the i64::MAX sentinel).

CI:
- The in-process job now runs the whole E2E suite over the in-process transport
  (serially) instead of only the smoke test, mirroring the .NET/TS inprocess cell.

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

Author: SteveSandersonMS

.github/workflows/rust-sdk-tests.yml

@@ -133,8 +133,10 @@ jobs:
   # analogue of the .NET `RuntimeConnection.ForInProcess()`), mirroring the
   # `inprocess` transport cell in dotnet-sdk-tests.yml. Sets
   # COPILOT_SDK_DEFAULT_CONNECTION=inprocess so the client hosts the runtime
-  # cdylib in-process instead of spawning a stdio child, then runs the
-  # dedicated in-process E2E test.
+  # cdylib in-process instead of spawning a stdio child, then runs the whole
+  # E2E suite over the in-process transport. The suite runs serially in-process
+  # (the harness forces concurrency to 1) because it mirrors each test's
+  # environment onto the shared process environment the in-process worker inherits.
   test-inprocess:
     name: "Rust SDK Tests (in-process transport)"
     if: github.event.repository.fork == false
@@ -184,14 +186,15 @@ jobs:
       - name: Select in-process transport
         run: echo "COPILOT_SDK_DEFAULT_CONNECTION=inprocess" >> "$GITHUB_ENV"
 
-      - name: cargo test (in-process transport)
+      - name: cargo test (in-process transport, full E2E suite)
         timeout-minutes: 60
         env:
-          RUST_E2E_CONCURRENCY: 4
           COPILOT_HMAC_KEY: ${{ secrets.COPILOT_DEVELOPER_CLI_INTEGRATION_HMAC_KEY }}
           COPILOT_CLI_PATH: ${{ steps.setup-copilot.outputs.cli-path }}
           BUNDLED_CLI_CACHE_DIR: ${{ github.workspace }}/rust/.bundled-cli-cache
-        run: cargo test --no-default-features --features test-support --test e2e inprocess -- --nocapture
+        # The harness forces serial execution in-process, so RUST_E2E_CONCURRENCY is
+        # intentionally not set here.
+        run: cargo test --no-default-features --features test-support --test e2e -- --nocapture
 
   # Validates the bundled-CLI build path on all three supported
   # platforms. While the regular `cargo test` job above also exercises

rust/src/lib.rs

@@ -120,6 +120,15 @@ pub enum Transport {
     /// entrypoint and speaks JSON-RPC over its C ABI. The runtime spawns its
     /// own worker; the SDK never launches a CLI child process. This is the
     /// Rust analogue of the .NET `RuntimeConnection.ForInProcess()`.
+    ///
+    /// **Experimental.** Per-client options that lower to environment variables
+    /// — [`ClientOptions::env`]/[`ClientOptions::env_remove`],
+    /// [`ClientOptions::telemetry`], [`ClientOptions::github_token`], and
+    /// [`ClientOptions::base_directory`] — are **not** honored with this
+    /// transport: the runtime loads into the shared host process and its worker
+    /// inherits that process's ambient environment. Configure the runtime via
+    /// the host process environment instead. See
+    /// <https://github.com/github/copilot-sdk/issues/1934>.
     InProcess,
     /// Spawn the CLI with `--port` and connect via TCP.
     Tcp {
@@ -1148,9 +1157,15 @@ impl Client {
                 )?
             }
             Transport::InProcess => {
-                let environment = Self::build_ffi_environment(&options);
+                // Per-client options that lower to environment variables (env,
+                // telemetry, github_token, base_directory) are not honored over the
+                // in-process transport: the runtime loads into this shared host
+                // process and its worker inherits this process's ambient environment,
+                // which a single env block cannot vary per client. Pass no per-client
+                // env; configure the runtime via the host process environment instead.
+                // See https://github.com/github/copilot-sdk/issues/1934.
                 info!(entrypoint = %program.display(), "hosting copilot runtime in-process (FFI)");
-                let host = crate::ffi::FfiHost::create(&program, environment)?;
+                let host = crate::ffi::FfiHost::create(&program, Vec::new())?;
                 let (reader, writer, shared) = host.start().await?;
                 let client = Self::from_transport(
                     reader,
@@ -1436,66 +1451,6 @@ impl Client {
         });
     }
 
-    fn build_ffi_environment(options: &ClientOptions) -> Vec<(String, String)> {
-        let mut env: std::collections::BTreeMap<String, String> = std::env::vars_os()
-            .map(|(k, v)| {
-                (
-                    k.to_string_lossy().into_owned(),
-                    v.to_string_lossy().into_owned(),
-                )
-            })
-            .collect();
-        let mut set = |key: &str, value: String| {
-            env.insert(key.to_string(), value);
-        };
-        if let Some(token) = &options.github_token {
-            set("COPILOT_SDK_AUTH_TOKEN", token.clone());
-        }
-        if let Some(telemetry) = &options.telemetry {
-            set("COPILOT_OTEL_ENABLED", "true".to_string());
-            if let Some(endpoint) = &telemetry.otlp_endpoint {
-                set("OTEL_EXPORTER_OTLP_ENDPOINT", endpoint.clone());
-            }
-            if let Some(protocol) = telemetry.otlp_protocol {
-                set("OTEL_EXPORTER_OTLP_PROTOCOL", protocol.as_str().to_string());
-            }
-            if let Some(path) = &telemetry.file_path {
-                set(
-                    "COPILOT_OTEL_FILE_EXPORTER_PATH",
-                    path.to_string_lossy().into_owned(),
-                );
-            }
-            if let Some(exporter) = telemetry.exporter_type {
-                set("COPILOT_OTEL_EXPORTER_TYPE", exporter.as_str().to_string());
-            }
-            if let Some(source) = &telemetry.source_name {
-                set("COPILOT_OTEL_SOURCE_NAME", source.clone());
-            }
-            if let Some(capture) = telemetry.capture_content {
-                set(
-                    "OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT",
-                    if capture { "true" } else { "false" }.to_string(),
-                );
-            }
-        }
-        if let Some(dir) = &options.base_directory {
-            set("COPILOT_HOME", dir.to_string_lossy().into_owned());
-        }
-        if options.mode == ClientMode::Empty {
-            set("COPILOT_DISABLE_KEYTAR", "1".to_string());
-        }
-        for (key, value) in &options.env {
-            env.insert(
-                key.to_string_lossy().into_owned(),
-                value.to_string_lossy().into_owned(),
-            );
-        }
-        for key in &options.env_remove {
-            env.remove(&*key.to_string_lossy());
-        }
-        env.into_iter().collect()
-    }
-
     fn build_command(program: &Path, options: &ClientOptions) -> Command {
         let mut command = Command::new(program);
         for arg in &options.prefix_args {

rust/tests/e2e/rpc_workspace_checkpoints.rs

@@ -40,6 +40,12 @@ async fn should_list_no_checkpoints_for_fresh_session() {
 
 #[tokio::test]
 async fn should_return_null_or_empty_content_for_unknown_checkpoint() {
+    // In-process, session.workspaces.readCheckpoint is answered by the native runtime,
+    // which decodes the checkpoint number as a u32 and rejects the i64::MAX sentinel this
+    // test uses. Covered by the default (stdio) transport. See issue #1934.
+    if super::support::skip_inprocess("readCheckpoint decodes the id as u32 in-process") {
+        return;
+    }
     with_e2e_context(
         "rpc_workspace_checkpoints",
         "should_return_null_or_empty_content_for_unknown_checkpoint",

rust/tests/e2e/support.rs

@@ -36,6 +36,13 @@ where
         .await
         .unwrap_or_else(|err| panic!("create E2E context: {err}"));
 
+    // In-process hosting: the runtime loads into this test process and its worker
+    // inherits the ambient environment (per-client env is not honored in-process, see
+    // https://github.com/github/copilot-sdk/issues/1934), so mirror this context's env
+    // onto the process for the duration of the test and restore on drop. Safe because
+    // E2E_CONCURRENCY is 1 in-process, serializing the whole critical section.
+    let _env_guard = InProcessEnvGuard::activate(&ctx);
+
     let timed_out = tokio::time::timeout(default_test_timeout(), test(&mut ctx))
         .await
         .is_err();
@@ -65,6 +72,10 @@ where
         .await
         .unwrap_or_else(|err| panic!("create E2E context: {err}"));
 
+    // See `with_e2e_context` for why the in-process transport mirrors env onto the
+    // process (restored on drop).
+    let _env_guard = InProcessEnvGuard::activate(&ctx);
+
     let timed_out = tokio::time::timeout(default_test_timeout(), test(&mut ctx))
         .await
         .is_err();
@@ -546,13 +557,89 @@ fn default_test_timeout() -> Duration {
 }
 
 fn e2e_concurrency() -> usize {
+    // The in-process transport mirrors per-test environment onto the shared process
+    // environment (see `InProcessEnvGuard`), which is only coherent when one test runs
+    // at a time. Force serial execution in-process; otherwise honor RUST_E2E_CONCURRENCY.
+    if is_inprocess_default() {
+        return 1;
+    }
     std::env::var("RUST_E2E_CONCURRENCY")
         .ok()
         .and_then(|value| value.parse::<usize>().ok())
         .filter(|&value| value > 0)
         .unwrap_or(4)
 }
 
+/// True when the E2E suite runs over the in-process (FFI) transport, i.e. the SDK
+/// resolves `COPILOT_SDK_DEFAULT_CONNECTION=inprocess` to [`Transport::InProcess`].
+pub fn is_inprocess_default() -> bool {
+    std::env::var("COPILOT_SDK_DEFAULT_CONNECTION")
+        .map(|value| value.eq_ignore_ascii_case("inprocess"))
+        .unwrap_or(false)
+}
+
+/// Skip guard for E2E tests exercising features the in-process (FFI) transport does not
+/// support (the runtime loads into the shared host process). Returns `true` — and logs —
+/// when running in-process so the caller can `return` early; such tests remain covered
+/// by the default (stdio) transport. See <https://github.com/github/copilot-sdk/issues/1934>.
+pub fn skip_inprocess(reason: &str) -> bool {
+    if is_inprocess_default() {
+        eprintln!("skipping test over the in-process (FFI) transport: {reason}");
+        true
+    } else {
+        false
+    }
+}
+
+/// Mirrors an [`E2eContext`]'s environment onto the real process environment for the
+/// in-process transport, whose worker inherits this process's ambient environment
+/// rather than a per-client env block. Restores the previous values on drop. Only the
+/// in-process transport needs this; for stdio/tcp the environment is handed to the
+/// spawned child directly. Auth flows via GH_TOKEN/GITHUB_TOKEN and HMAC is disabled so
+/// host-side auth resolution picks the token the replay snapshots expect.
+struct InProcessEnvGuard {
+    saved: Vec<(OsString, Option<OsString>)>,
+}
+
+impl InProcessEnvGuard {
+    /// Returns `Some` guard (having applied the env) when in-process, else `None`.
+    fn activate(ctx: &E2eContext) -> Option<Self> {
+        if !is_inprocess_default() {
+            return None;
+        }
+        let mut pairs: Vec<(OsString, OsString)> = ctx.environment();
+        pairs.push(("GH_TOKEN".into(), "fake-token-for-e2e-tests".into()));
+        pairs.push(("GITHUB_TOKEN".into(), "fake-token-for-e2e-tests".into()));
+
+        let mut saved: Vec<(OsString, Option<OsString>)> = Vec::new();
+        for (key, value) in &pairs {
+            saved.push((key.clone(), std::env::var_os(key)));
+            // SAFETY: the E2E suite runs serially in-process (concurrency 1), so no
+            // other thread races these process-wide env mutations.
+            unsafe { std::env::set_var(key, value) };
+        }
+        for key in ["COPILOT_HMAC_KEY", "CAPI_HMAC_KEY"] {
+            let key = OsString::from(key);
+            saved.push((key.clone(), std::env::var_os(&key)));
+            // SAFETY: as above.
+            unsafe { std::env::remove_var(&key) };
+        }
+        Some(Self { saved })
+    }
+}
+
+impl Drop for InProcessEnvGuard {
+    fn drop(&mut self) {
+        for (key, previous) in self.saved.iter().rev() {
+            // SAFETY: as in `activate` — serial execution in-process.
+            match previous {
+                Some(value) => unsafe { std::env::set_var(key, value) },
+                None => unsafe { std::env::remove_var(key) },
+            }
+        }
+    }
+}
+
 pub fn get_system_message(exchange: &serde_json::Value) -> String {
     exchange
         .get("request")

rust/tests/e2e/telemetry.rs

@@ -13,6 +13,11 @@ use super::support::{assistant_message_content, with_e2e_context};
 
 #[tokio::test]
 async fn should_export_file_telemetry_for_sdk_interactions() {
+    // Telemetry lowers to environment variables the in-process worker cannot receive
+    // per-client; covered by the default (stdio) transport. See issue #1934.
+    if super::support::skip_inprocess("telemetry configuration is not honored in-process") {
+        return;
+    }
     with_e2e_context(
         "telemetry",
         "should_export_file_telemetry_for_sdk_interactions",