Version-independent SDK test and codegen fixes split from the 1.0.76-0 bump (#2110)

* Bound Python e2e tests with a per-test timeout

pytest-timeout has been a declared dev dependency for a while but was never
configured, and the Python job sets no timeout-minutes either. When CLI 1.0.76-0
introduced a session.destroy deadlock, five of the six Python jobs sat
in_progress for hours instead of failing, producing no diagnostic signal at all
and holding runners until GitHub's 6-hour job limit.

Setting timeout = 300 makes a deadlocked test fail in five minutes with a full
stack dump pointing at the blocked call, which is how the other SDKs already
behave (Node uses 30s/60s/180s per test, Go bounds the package at 20m).

The value is deliberately generous: the whole Python suite completes in about
10 minutes, so no individual test comes close to 300s. Verified locally that
pytest honours the setting from pyproject.toml and that it interrupts a hanging
test with a traceback.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e615d062-bcb7-431e-aa9c-d3e47405723a
(cherry picked from commit c33d8e2)

* Close Go/.NET shell-test teardown gap

The "should kill shell process" e2e test exists in all five SDKs, but only
Node, Python and Rust destroy the session at the end of it. Go tears the whole
client down with client.ForceStop() and .NET simply ended at the last assert,
so neither ever exercised session.destroy after a session.shell.exec.

That gap is why Go and .NET stayed green on CLI 1.0.76-0 while Node, Python and
Rust hang: the hang is in session.destroy after a shell exec, and the two green
SDKs never made the call. Adding the teardown makes all five cover the same
sequence.

Verified locally against the same CLI binary (1.0.76-0, sha256 b8bfad2c...):
with the added Disconnect(), the Go test hangs past a 3-minute timeout where it
previously passed in seconds. The same test passes on CLI 1.0.73.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e615d062-bcb7-431e-aa9c-d3e47405723a
(cherry picked from commit 2e54b47)

* Remove Rust e2e test for session.mcp.registerExternalClient

The runtime team confirmed this method is marked `visibility: internal` in the
shared API contract: its `client` and `transport` fields are live in-process MCP
SDK instances that cannot be serialized over JSON-RPC. No SDK exposes it as a
typed method, and the Rust test drove it through a raw `call_session_rpc` with
placeholder JSON objects that could never satisfy that contract.

It passed on CLI 1.0.73 only because the old TypeScript dispatch happened to
route internal methods generically. 1.0.76-0 routes the method through the Rust
native registry, where the host-effect switch has no case for it, so it now
returns -32603 "Unsupported native session host effect". That is correct
behaviour, not a regression, so the test is removed along with its now-orphaned
snapshot and a note recording why the gap is deliberate.

Both `call_session_rpc` and `is_mcp_server_running` remain in use by other tests
in the file, so no helper became dead.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e615d062-bcb7-431e-aa9c-d3e47405723a
(cherry picked from commit f0c846c)

* codegen: emit Rust type aliases for scalar RPC result schemas

The Rust codegen only emitted a named type for result schemas that were an
enum, array, map, or object. A method whose result is an inline primitive
(e.g. {"type":"integer"}) produced a reference to a type that was never
defined, so the generated crate failed to compile with E0425.

No RPC method had a primitive result until session.cancelAllBackgroundAgents
was added, so this latent gap only surfaces on a schema update. Add
rustScalarType()/emitRustScalarAlias() so scalar results emit a plain type
alias alongside the existing shapes.

This is a no-op against the current pinned schema and prevents the next
dependency bump from hitting the same build break.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e615d062-bcb7-431e-aa9c-d3e47405723a

* Ensure shell test teardown on failure

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: b565403c-57ed-4368-84f1-f04bfe39e46e

---------

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot-Session: e615d062-bcb7-431e-aa9c-d3e47405723a
Copilot-Session: b565403c-57ed-4368-84f1-f04bfe39e46e

Author: stephentoub

dotnet/test/E2E/RpcShellAndFleetE2ETests.cs

@@ -28,7 +28,7 @@ public async Task Should_Execute_Shell_Command()
     [Fact]
     public async Task Should_Kill_Shell_Process()
     {
-        var session = await CreateSessionAsync();
+        await using var session = await CreateSessionAsync();
         var command = OperatingSystem.IsWindows()
             ? "powershell -NoLogo -NoProfile -Command \"Start-Sleep -Seconds 30\""
             : "sleep 30";

go/internal/e2e/rpc_shell_and_fleet_e2e_test.go

@@ -55,6 +55,7 @@ func TestRPCShellAndFleetE2E(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Failed to create session: %v", err)
 		}
+		t.Cleanup(func() { _ = session.Disconnect() })
 
 		var command string
 		if runtime.GOOS == "windows" {

python/pyproject.toml

@@ -92,3 +92,7 @@ python_files = "test_*.py"
 python_classes = "Test*"
 python_functions = "test_*"
 asyncio_mode = "auto"
+# Bound every test so a deadlock fails fast with a stack dump instead of occupying the
+# whole CI leg until GitHub's 6-hour job limit. The full suite runs in ~10 minutes, so no
+# individual test legitimately approaches this.
+timeout = 300

rust/tests/e2e/rpc_mcp_lifecycle.rs

@@ -194,58 +194,11 @@ async fn should_start_and_restart_mcp_server() {
     .await;
 }
 
-#[tokio::test]
-async fn should_register_and_unregister_external_mcp_client() {
-    with_e2e_context(
-        "rpc_mcp_lifecycle",
-        "should_register_and_unregister_external_mcp_client",
-        |ctx| {
-            Box::pin(async move {
-                ctx.set_default_copilot_user();
-                let host_server = "rpc-lifecycle-extclient-host";
-                let client = ctx.start_client().await;
-                let session =
-                    client
-                        .create_session(ctx.approve_all_session_config().with_mcp_servers(
-                            create_test_mcp_servers(ctx.repo_root(), host_server),
-                        ))
-                        .await
-                        .expect("create session");
-                wait_for_mcp_server_status(&session, host_server, McpServerStatus::Connected).await;
-
-                let external_name = "rpc-lifecycle-external-client";
-                assert!(!is_mcp_server_running(&session, external_name).await);
-
-                call_session_rpc(
-                    &session,
-                    "session.mcp.registerExternalClient",
-                    json!({
-                        "serverName": external_name,
-                        "client": { "id": external_name },
-                        "transport": { "kind": "in-process" },
-                        "config": { "command": "noop" }
-                    }),
-                )
-                .await
-                .expect("register external MCP client");
-                assert!(is_mcp_server_running(&session, external_name).await);
-
-                call_session_rpc(
-                    &session,
-                    "session.mcp.unregisterExternalClient",
-                    json!({ "serverName": external_name }),
-                )
-                .await
-                .expect("unregister external MCP client");
-                assert!(!is_mcp_server_running(&session, external_name).await);
-
-                session.disconnect().await.expect("disconnect session");
-                client.stop().await.expect("stop client");
-            })
-        },
-    )
-    .await;
-}
+// There is deliberately no e2e test for `session.mcp.registerExternalClient`. That method is
+// marked `visibility: internal` in the shared API contract: its `client` and `transport` fields
+// are live in-process MCP SDK instances, so it cannot be driven over JSON-RPC, and no SDK
+// exposes it as a typed method. A raw-RPC test used to pass only because older CLIs routed
+// internal methods generically; it never exercised a supported wire API.
 
 #[tokio::test]
 async fn should_reload_mcp_servers_with_config() {

scripts/codegen/rust.ts

@@ -575,6 +575,45 @@ function emitRustMapAlias(
 	);
 }
 
+/**
+ * Map a primitive JSON Schema type to its Rust equivalent, or `undefined` when
+ * the schema is not a plain scalar. Mirrors the primitive branches of
+ * {@link resolveRustType}.
+ */
+function rustScalarType(schema: JSONSchema7): string | undefined {
+	if (schema.enum || schema.const !== undefined) return undefined;
+	switch (schema.type) {
+		case "string":
+			return "String";
+		case "number":
+			return "f64";
+		case "integer":
+			return isIntegerSchemaBoundedToInt32(schema) ? "i32" : "i64";
+		case "boolean":
+			return "bool";
+		default:
+			return undefined;
+	}
+}
+
+/**
+ * Emit a type alias for a named schema that resolves to a primitive scalar
+ * (e.g. an RPC result declared as `{ "type": "integer" }`). Without this the
+ * generated RPC surface would reference a `*Result` type that was never
+ * defined.
+ */
+function emitRustScalarAlias(
+	typeName: string,
+	schema: JSONSchema7,
+	ctx: RustCodegenCtx,
+	description?: string,
+): void {
+	if (ctx.generatedNames.has(typeName)) return;
+	const scalarType = rustScalarType(schema);
+	if (!scalarType) return;
+	emitRustTypeAlias(typeName, schema, scalarType, ctx, description);
+}
+
 function rustRpcResultDescription(
 	method: RpcMethod,
 	resultSchema: JSONSchema7 | undefined,
@@ -1527,6 +1566,8 @@ function generateApiTypesCode(
 			} else {
 				tryEmitRustUnion(schema, name, "", ctx);
 			}
+		} else {
+			emitRustScalarAlias(name, schema, ctx, schema.description);
 		}
 	}
 
@@ -1576,6 +1617,8 @@ function generateApiTypesCode(
 					emitRustMapAlias(resultName, resolved, ctx, resolved.description);
 				} else if (isObjectSchema(resolved)) {
 					emitRustStruct(resultName, resolved, ctx, resolved.description);
+				} else {
+					emitRustScalarAlias(resultName, resolved, ctx, resolved.description);
 				}
 			}
 		}