feat: add sessionIdleTimeoutSeconds to Go, Python, and .NET SDKs

Add the session idle timeout option across all remaining SDK languages,
consistent with the Node.js implementation and the runtime CLI's
--session-idle-timeout flag.

- Go: SessionIdleTimeoutSeconds int on ClientOptions
- Python: session_idle_timeout_seconds on SubprocessConfig
- .NET: SessionIdleTimeoutSeconds int? on CopilotClientOptions

Each SDK passes --session-idle-timeout <seconds> to the CLI when the
value is positive, and omits it otherwise (disabled by default).

Includes unit tests for all three languages and updates the .NET clone
test to cover the new property.

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

Author: MackinnonBuck

dotnet/src/Client.cs

@@ -1190,6 +1190,11 @@ private async Task VerifyProtocolVersionAsync(Connection connection, Cancellatio
             args.Add("--no-auto-login");
         }
 
+        if (options.SessionIdleTimeoutSeconds is > 0)
+        {
+            args.AddRange(["--session-idle-timeout", options.SessionIdleTimeoutSeconds.Value.ToString(CultureInfo.InvariantCulture)]);
+        }
+
         var (fileName, processArgs) = ResolveCliCommand(cliPath, args);
 
         var startInfo = new ProcessStartInfo

dotnet/src/Types.cs

@@ -69,6 +69,7 @@ protected CopilotClientOptions(CopilotClientOptions? other)
         UseStdio = other.UseStdio;
         OnListModels = other.OnListModels;
         SessionFs = other.SessionFs;
+        SessionIdleTimeoutSeconds = other.SessionIdleTimeoutSeconds;
     }
 
     /// <summary>
@@ -165,6 +166,16 @@ public string? GithubToken
     /// </summary>
     public TelemetryConfig? Telemetry { get; set; }
 
+    /// <summary>
+    /// Server-wide idle timeout for sessions in seconds.
+    /// Sessions without activity for this duration are automatically cleaned up.
+    /// Set to <c>0</c> or leave as <see langword="null"/> to disable (sessions live indefinitely).
+    /// Minimum value: 300 (5 minutes).
+    /// This option is only used when the SDK spawns the CLI process; it is ignored
+    /// when connecting to an external server via <see cref="CliUrl"/>.
+    /// </summary>
+    public int? SessionIdleTimeoutSeconds { get; set; }
+
     /// <summary>
     /// Creates a shallow clone of this <see cref="CopilotClientOptions"/> instance.
     /// </summary>

dotnet/test/ClientTests.cs

@@ -216,6 +216,25 @@ public void Should_Throw_When_UseLoggedInUser_Used_With_CliUrl()
         });
     }
 
+    [Fact]
+    public void Should_Default_SessionIdleTimeoutSeconds_To_Null()
+    {
+        var options = new CopilotClientOptions();
+
+        Assert.Null(options.SessionIdleTimeoutSeconds);
+    }
+
+    [Fact]
+    public void Should_Accept_SessionIdleTimeoutSeconds_Option()
+    {
+        var options = new CopilotClientOptions
+        {
+            SessionIdleTimeoutSeconds = 600
+        };
+
+        Assert.Equal(600, options.SessionIdleTimeoutSeconds);
+    }
+
     [Fact]
     public async Task Should_Not_Throw_When_Disposing_Session_After_Stopping_Client()
     {

dotnet/test/CloneTests.cs

@@ -26,6 +26,7 @@ public void CopilotClientOptions_Clone_CopiesAllProperties()
             Environment = new Dictionary<string, string> { ["KEY"] = "value" },
             GitHubToken = "ghp_test",
             UseLoggedInUser = false,
+            SessionIdleTimeoutSeconds = 600,
         };
 
         var clone = original.Clone();
@@ -42,6 +43,7 @@ public void CopilotClientOptions_Clone_CopiesAllProperties()
         Assert.Equal(original.Environment, clone.Environment);
         Assert.Equal(original.GitHubToken, clone.GitHubToken);
         Assert.Equal(original.UseLoggedInUser, clone.UseLoggedInUser);
+        Assert.Equal(original.SessionIdleTimeoutSeconds, clone.SessionIdleTimeoutSeconds);
     }
 
     [Fact]

go/client.go

@@ -215,6 +215,12 @@ func NewClient(options *ClientOptions) *Client {
 			sessionFs := *options.SessionFs
 			opts.SessionFs = &sessionFs
 		}
+		if options.Telemetry != nil {
+			opts.Telemetry = options.Telemetry
+		}
+		if options.SessionIdleTimeoutSeconds > 0 {
+			opts.SessionIdleTimeoutSeconds = options.SessionIdleTimeoutSeconds
+		}
 	}
 
 	// Default Env to current environment if not set
@@ -1378,6 +1384,10 @@ func (c *Client) startCLIServer(ctx context.Context) error {
 		args = append(args, "--no-auto-login")
 	}
 
+	if c.options.SessionIdleTimeoutSeconds > 0 {
+		args = append(args, "--session-idle-timeout", strconv.Itoa(c.options.SessionIdleTimeoutSeconds))
+	}
+
 	// If CLIPath is a .js file, run it with node
 	// Note we can't rely on the shebang as Windows doesn't support it
 	command := cliPath

go/client_test.go

@@ -391,6 +391,26 @@ func TestClient_EnvOptions(t *testing.T) {
 	})
 }
 
+func TestClient_SessionIdleTimeoutSeconds(t *testing.T) {
+	t.Run("should store SessionIdleTimeoutSeconds option", func(t *testing.T) {
+		client := NewClient(&ClientOptions{
+			SessionIdleTimeoutSeconds: 600,
+		})
+
+		if client.options.SessionIdleTimeoutSeconds != 600 {
+			t.Errorf("Expected SessionIdleTimeoutSeconds to be 600, got %d", client.options.SessionIdleTimeoutSeconds)
+		}
+	})
+
+	t.Run("should default SessionIdleTimeoutSeconds to zero", func(t *testing.T) {
+		client := NewClient(&ClientOptions{})
+
+		if client.options.SessionIdleTimeoutSeconds != 0 {
+			t.Errorf("Expected SessionIdleTimeoutSeconds to be 0, got %d", client.options.SessionIdleTimeoutSeconds)
+		}
+	})
+}
+
 func findCLIPathForTest() string {
 	abs, _ := filepath.Abs("../nodejs/node_modules/@github/copilot/index.js")
 	if fileExistsForTest(abs) {

go/types.go

@@ -71,6 +71,13 @@ type ClientOptions struct {
 	// When non-nil, COPILOT_OTEL_ENABLED=true is set and any populated fields
 	// are mapped to the corresponding environment variables.
 	Telemetry *TelemetryConfig
+	// SessionIdleTimeoutSeconds configures the server-wide session idle timeout in seconds.
+	// Sessions without activity for this duration are automatically cleaned up.
+	// Set to 0 or leave unset to disable (sessions live indefinitely).
+	// Minimum value: 300 (5 minutes).
+	// This option is only used when the SDK spawns the CLI process; it is ignored
+	// when connecting to an external server via CLIUrl.
+	SessionIdleTimeoutSeconds int
 }
 
 // TelemetryConfig configures OpenTelemetry integration for the Copilot CLI process.

python/copilot/client.py

@@ -150,6 +150,14 @@ class SubprocessConfig:
     session_fs: SessionFsConfig | None = None
     """Connection-level session filesystem provider configuration."""
 
+    session_idle_timeout_seconds: int | None = None
+    """Server-wide session idle timeout in seconds.
+
+    Sessions without activity for this duration are automatically cleaned up.
+    Set to ``None`` or ``0`` to disable (sessions live indefinitely).
+    Minimum value: 300 (5 minutes).
+    """
+
 
 @dataclass
 class ExternalServerConfig:
@@ -2261,6 +2269,9 @@ async def _start_cli_server(self) -> None:
         if not cfg.use_logged_in_user:
             args.append("--no-auto-login")
 
+        if cfg.session_idle_timeout_seconds is not None and cfg.session_idle_timeout_seconds > 0:
+            args.extend(["--session-idle-timeout", str(cfg.session_idle_timeout_seconds)])
+
         # If cli_path is a .js file, run it with node
         # Note that we can't rely on the shebang as Windows doesn't support it
         if cli_path.endswith(".js"):

python/test_client.py

@@ -204,6 +204,26 @@ def test_explicit_use_logged_in_user_false_without_token(self):
         assert client._config.use_logged_in_user is False
 
 
+class TestSessionIdleTimeoutSeconds:
+    def test_accepts_session_idle_timeout_seconds(self):
+        client = CopilotClient(
+            SubprocessConfig(
+                cli_path=CLI_PATH,
+                session_idle_timeout_seconds=600,
+                log_level="error",
+            )
+        )
+        assert isinstance(client._config, SubprocessConfig)
+        assert client._config.session_idle_timeout_seconds == 600
+
+    def test_default_session_idle_timeout_seconds_is_none(self):
+        client = CopilotClient(
+            SubprocessConfig(cli_path=CLI_PATH, log_level="error")
+        )
+        assert isinstance(client._config, SubprocessConfig)
+        assert client._config.session_idle_timeout_seconds is None
+
+
 class TestOverridesBuiltInTool:
     @pytest.mark.asyncio
     async def test_overrides_built_in_tool_sent_in_tool_definition(self):