[E2E] session.todos_changed event + readSqlTodosWithDependencies (6 languages)

dotnet/test/E2E/RpcSessionStateE2ETests.cs

@@ -35,16 +35,31 @@ public async Task Should_Call_Session_Rpc_Model_GetCurrent()
     [Fact]
     public async Task Should_Call_Session_Rpc_Model_SwitchTo()
     {
-        await using var session = await CreateSessionAsync(new SessionConfig { Model = "claude-sonnet-4.5" });
+        // The runtime caches /models per (auth, base_url) for 30 minutes (see
+        // capi_client.rs LIST_MODELS_CACHE). Tests in this class share one CLI
+        // subprocess and proxy URL via E2ETestFixture, so the first snapshot's
+        // models list is reused by every later test. SwitchTo needs gpt-5.4 in
+        // the cache; rather than poisoning every other snapshot we spin up an
+        // isolated context with its own proxy → its own (auth, base_url) cache
+        // key.
+        await using var isolatedCtx = await E2ETestContext.CreateAsync();
+        await isolatedCtx.ConfigureForTestAsync("rpc_session_state", nameof(Should_Call_Session_Rpc_Model_SwitchTo));
+        var isolatedClient = isolatedCtx.CreateClient();
+
+        await using var session = await isolatedClient.CreateSessionAsync(new SessionConfig
+        {
+            Model = "claude-sonnet-4.5",
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+        });
 
         var before = await session.Rpc.Model.GetCurrentAsync();
         Assert.Equal("claude-sonnet-4.5", before.ModelId);
 
-        var result = await session.Rpc.Model.SwitchToAsync(modelId: "gpt-4.1", reasoningEffort: "high");
-        var after = await session.Rpc.Model.GetCurrentAsync();
+        var result = await session.Rpc.Model.SwitchToAsync(modelId: "gpt-5.4", reasoningEffort: "high");
+        Assert.Equal("gpt-5.4", result.ModelId);
 
-        Assert.Equal("gpt-4.1", result.ModelId);
-        Assert.True(after.ModelId is "gpt-4.1" || after.ModelId == before.ModelId, $"Unexpected current model after switch: {after.ModelId}");
+        var after = await session.Rpc.Model.GetCurrentAsync();
+        Assert.Equal("gpt-5.4", after.ModelId);
     }
 
     [Fact]

dotnet/test/E2E/SessionTodosChangedE2ETests.cs

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+using GitHub.Copilot.Rpc;
+using GitHub.Copilot.Test.Harness;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace GitHub.Copilot.Test.E2E;
+
+public class SessionTodosChangedE2ETests(E2ETestFixture fixture, ITestOutputHelper output)
+    : E2ETestBase(fixture, "session_todos_changed", output)
+{
+    private static readonly string[] ExpectedTodoIds = ["alpha", "beta"];
+
+    [Fact]
+    public async Task Fires_Session_Todos_Changed_And_Exposes_Rows_And_Dependencies()
+    {
+        await using var session = await CreateSessionAsync(new SessionConfig
+        {
+            OnPermissionRequest = PermissionHandler.ApproveAll,
+        });
+
+        var todosChangedTask = TestHelper.GetNextEventOfTypeAsync<SessionTodosChangedEvent>(
+            session,
+            TimeSpan.FromSeconds(30));
+
+        await session.SendAndWaitAsync(new MessageOptions
+        {
+            Prompt =
+                "Use the sql tool to execute exactly these statements, in order, with no extra rows:\n" +
+                "1. INSERT INTO todos (id, title, status) VALUES ('alpha', 'First todo', 'pending');\n" +
+                "2. INSERT INTO todos (id, title, status) VALUES ('beta', 'Second todo', 'done');\n" +
+                "3. INSERT INTO todo_deps (todo_id, depends_on) VALUES ('beta', 'alpha');\n" +
+                "Then stop. Do not insert any other rows or create any other tables.",
+        });
+
+        await todosChangedTask;
+
+        var result = await session.Rpc.Plan.ReadSqlTodosWithDependenciesAsync();
+
+        var ids = result.Rows
+            .Select(row => row.Id)
+            .OfType<string>()
+            .OrderBy(id => id, StringComparer.Ordinal)
+            .ToArray();
+
+        Assert.Equal(ExpectedTodoIds, ids);
+
+        Assert.Contains(result.Dependencies, dependency =>
+            dependency.TodoId == "beta" &&
+            dependency.DependsOn == "alpha");
+    }
+}

go/internal/e2e/rpc_session_state_e2e_test.go

@@ -42,8 +42,22 @@ func TestRPCSessionStateE2E(t *testing.T) {
 		}
 	})
 
+	// The runtime caches /models per (auth, base_url) for 30 minutes (see
+	// capi_client.rs LIST_MODELS_CACHE). Within this test function all subtests
+	// share one CLI subprocess and proxy URL, so the first subtest's snapshot
+	// models list is reused by every later one. SwitchTo needs gpt-5.4 in the
+	// cache; rather than poison every other snapshot we give this subtest its
+	// own dedicated client + proxy → its own cache entry.
 	t.Run("should call session rpc model switchTo", func(t *testing.T) {
-		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+		switchCtx := testharness.NewTestContext(t)
+		switchClient := switchCtx.NewClient()
+		t.Cleanup(func() { switchClient.ForceStop() })
+		if err := switchClient.Start(t.Context()); err != nil {
+			t.Fatalf("Failed to start switch client: %v", err)
+		}
+		switchCtx.ConfigureForTest(t)
+
+		session, err := switchClient.CreateSession(t.Context(), &copilot.SessionConfig{
 			Model:               "claude-sonnet-4.5",
 			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
 		})
@@ -61,21 +75,21 @@ func TestRPCSessionStateE2E(t *testing.T) {
 
 		reasoningEffort := "high"
 		result, err := session.RPC.Model.SwitchTo(t.Context(), &rpc.ModelSwitchToRequest{
-			ModelID:         "gpt-4.1",
+			ModelID:         "gpt-5.4",
 			ReasoningEffort: &reasoningEffort,
 		})
 		if err != nil {
 			t.Fatalf("Model.SwitchTo failed: %v", err)
 		}
-		if result.ModelID == nil || *result.ModelID != "gpt-4.1" {
-			t.Fatalf("Expected switch result model gpt-4.1, got %+v", result)
+		if result.ModelID == nil || *result.ModelID != "gpt-5.4" {
+			t.Fatalf("Expected switch result model gpt-5.4, got %+v", result)
 		}
 		after, err := session.RPC.Model.GetCurrent(t.Context())
 		if err != nil {
 			t.Fatalf("Model.GetCurrent after switch failed: %v", err)
 		}
-		if after.ModelID == nil || (*after.ModelID != "gpt-4.1" && *after.ModelID != *before.ModelID) {
-			t.Fatalf("Unexpected current model after switch; before=%q after=%+v", *before.ModelID, after)
+		if after.ModelID == nil || *after.ModelID != "gpt-5.4" {
+			t.Fatalf("Model.GetCurrent did not reflect SwitchTo; before=%q after=%+v", *before.ModelID, after)
 		}
 	})
 

go/internal/e2e/session_todos_changed_e2e_test.go

@@ -0,0 +1,79 @@
+package e2e
+
+import (
+	"context"
+	"slices"
+	"sort"
+	"testing"
+	"time"
+
+	copilot "github.com/github/copilot-sdk/go"
+	"github.com/github/copilot-sdk/go/internal/e2e/testharness"
+)
+
+func TestFiresSessionTodosChangedAndExposesRowsAndDependencies(t *testing.T) {
+	ctx := testharness.NewTestContext(t)
+	client := ctx.NewClient()
+	t.Cleanup(func() { client.ForceStop() })
+
+	t.Run("fires session.todos_changed and exposes rows and dependencies", func(t *testing.T) {
+		ctx.ConfigureForTest(t)
+
+		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+		})
+		if err != nil {
+			t.Fatalf("Failed to create session: %v", err)
+		}
+		defer session.Disconnect()
+
+		awaitTodosChanged := waitForMatchingEvent(
+			session,
+			copilot.SessionEventType("session.todos_changed"),
+			func(copilot.SessionEvent) bool { return true },
+			"session.todos_changed event",
+		)
+
+		sendCtx, cancel := context.WithTimeout(t.Context(), 120*time.Second)
+		defer cancel()
+		_, err = session.SendAndWait(sendCtx, copilot.MessageOptions{
+			Prompt: "Use the sql tool to execute exactly these statements, in order, with no extra rows:\n" +
+				"1. INSERT INTO todos (id, title, status) VALUES ('alpha', 'First todo', 'pending');\n" +
+				"2. INSERT INTO todos (id, title, status) VALUES ('beta', 'Second todo', 'done');\n" +
+				"3. INSERT INTO todo_deps (todo_id, depends_on) VALUES ('beta', 'alpha');\n" +
+				"Then stop. Do not insert any other rows or create any other tables.",
+		})
+		if err != nil {
+			t.Fatalf("Failed to send message: %v", err)
+		}
+
+		awaitEvent(t, awaitTodosChanged)
+
+		result, err := session.RPC.Plan.ReadSqlTodosWithDependencies(t.Context())
+		if err != nil {
+			t.Fatalf("Plan.ReadSqlTodosWithDependencies failed: %v", err)
+		}
+
+		var ids []string
+		for _, row := range result.Rows {
+			if row.ID != nil && *row.ID != "" {
+				ids = append(ids, *row.ID)
+			}
+		}
+		sort.Strings(ids)
+		if !slices.Equal(ids, []string{"alpha", "beta"}) {
+			t.Fatalf("Expected todo ids [alpha beta], got %v", ids)
+		}
+
+		foundDependency := false
+		for _, dependency := range result.Dependencies {
+			if dependency.TodoID == "beta" && dependency.DependsOn == "alpha" {
+				foundDependency = true
+				break
+			}
+		}
+		if !foundDependency {
+			t.Fatalf("Expected dependency beta -> alpha, got %+v", result.Dependencies)
+		}
+	})
+}

java/src/test/java/com/github/copilot/SessionTodosChangedTest.java

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+
+package com.github.copilot;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.TimeUnit;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import com.github.copilot.generated.SessionTodosChangedEvent;
+import com.github.copilot.generated.rpc.PlanSqlTodoDependency;
+import com.github.copilot.rpc.MessageOptions;
+import com.github.copilot.rpc.PermissionHandler;
+import com.github.copilot.rpc.SessionConfig;
+
+public class SessionTodosChangedTest {
+
+    private static E2ETestContext ctx;
+
+    @BeforeAll
+    static void setup() throws Exception {
+        ctx = E2ETestContext.create();
+    }
+
+    @AfterAll
+    static void teardown() throws Exception {
+        if (ctx != null) {
+            ctx.close();
+        }
+    }
+
+    @Test
+    void firesSessionTodosChangedAndExposesRowsAndDependencies() throws Exception {
+        ctx.configureForTest("session_todos_changed", "fires_session_todos_changed_and_exposes_rows_and_dependencies");
+
+        try (CopilotClient client = ctx.createClient()) {
+            CopilotSession session = client
+                    .createSession(new SessionConfig().setOnPermissionRequest(PermissionHandler.APPROVE_ALL)).get();
+
+            CompletableFuture<SessionTodosChangedEvent> todosChanged = new CompletableFuture<>();
+            session.on(event -> {
+                if (event instanceof SessionTodosChangedEvent todosEvent && !todosChanged.isDone()) {
+                    todosChanged.complete(todosEvent);
+                }
+            });
+
+            session.sendAndWait(new MessageOptions()
+                    .setPrompt("Use the sql tool to execute exactly these statements, in order, with no extra rows:\n"
+                            + "1. INSERT INTO todos (id, title, status) VALUES ('alpha', 'First todo', 'pending');\n"
+                            + "2. INSERT INTO todos (id, title, status) VALUES ('beta', 'Second todo', 'done');\n"
+                            + "3. INSERT INTO todo_deps (todo_id, depends_on) VALUES ('beta', 'alpha');\n"
+                            + "Then stop. Do not insert any other rows or create any other tables."))
+                    .get(120, TimeUnit.SECONDS);
+
+            assertNotNull(todosChanged.get(15, TimeUnit.SECONDS),
+                    "Should have received at least one session.todos_changed event");
+
+            var result = session.getRpc().plan.readSqlTodosWithDependencies().get(15, TimeUnit.SECONDS);
+            assertEquals(2, result.rows().size());
+            var ids = result.rows().stream().map(row -> row.id()).filter(id -> id != null).sorted().toList();
+
+            assertEquals(java.util.List.of("alpha", "beta"), ids);
+            assertTrue(result.dependencies().stream().anyMatch(SessionTodosChangedTest::isBetaDependsOnAlpha),
+                    "Should contain beta -> alpha dependency");
+
+            session.close();
+        }
+    }
+
+    private static boolean isBetaDependsOnAlpha(PlanSqlTodoDependency dependency) {
+        return "beta".equals(dependency.todoId()) && "alpha".equals(dependency.dependsOn());
+    }
+}

nodejs/test/e2e/rpc_session_state.e2e.test.ts

@@ -49,25 +49,39 @@ describe("Session-scoped RPC", async () => {
         await session.disconnect();
     });
 
-    it("should call session rpc model switchto", async () => {
-        const session = await client.createSession({
-            onPermissionRequest: approveAll,
-            model: "claude-sonnet-4.5",
-        });
+    // The runtime caches the /models response per (auth, base_url) for 30
+    // minutes (see capi_client.rs LIST_MODELS_CACHE), so within a single
+    // describe — where all tests share one CLI subprocess and proxy URL —
+    // the cache is primed by whichever test creates a session first. That
+    // makes any test which calls switchTo to a model not present in the
+    // first snapshot's models list fail silently (the runtime accepts the
+    // switch synchronously, then tool revalidation refetches the cached
+    // list, doesn't see the model, and reverts _selectedModel). Wrapping
+    // switchTo in its own describe gives it a dedicated subprocess + proxy
+    // → its own cache entry, so its snapshot's models list is authoritative.
+    describe("model switchTo (isolated to avoid models cache contamination)", async () => {
+        const { copilotClient: switchClient } = await createSdkTestContext();
+
+        it("should call session rpc model switchto", async () => {
+            const session = await switchClient.createSession({
+                onPermissionRequest: approveAll,
+                model: "claude-sonnet-4.5",
+            });
 
-        const before = await session.rpc.model.getCurrent();
-        expect(before.modelId).toBeTruthy();
+            const before = await session.rpc.model.getCurrent();
+            expect(before.modelId).toBeTruthy();
 
-        const result = await session.rpc.model.switchTo({
-            modelId: "gpt-4.1",
-            reasoningEffort: "high",
-        });
-        const after = await session.rpc.model.getCurrent();
+            const result = await session.rpc.model.switchTo({
+                modelId: "gpt-5.4",
+                reasoningEffort: "high",
+            });
+            const after = await session.rpc.model.getCurrent();
 
-        expect(result.modelId).toBe("gpt-4.1");
-        expect(after.modelId).toBe(before.modelId);
+            expect(result.modelId).toBe("gpt-5.4");
+            expect(after.modelId).toBe("gpt-5.4");
 
-        await session.disconnect();
+            await session.disconnect();
+        });
     });
 
     it("should shutdown session with routine type", async () => {