Adapt hand-written SDK code to CLI 1.0.76-0 wire changes

CI was red across all six SDKs after the @github/copilot bump. All failures
were build/typecheck breakages from the regenerated wire types.

1. New `sessionFs.sqliteTransaction` RPC

   The CLI added `sessionFs.sqliteTransaction` to the SessionFs client handler
   interface, so every hand-written provider adapter stopped satisfying it
   (TS2741 / Go interface mismatch / ty invalid-return-type / CS0535). Rust
   dispatches by method name so it still compiled, but silently had no handler.

   Added a required `transaction` member to the SQLite provider interface in
   each language plus the adapter plumbing:

   - nodejs: `SessionFsSqliteStatement`, `SessionFsSqliteTransactionFailure`,
     `SessionFsSqliteProvider.transaction`, adapter `sqliteTransaction`
   - go: `SessionFSSqliteProvider.SqliteTransaction`,
     `SessionFSSqliteTransactionFailure`
   - python: `SessionFsSqliteProvider.sqlite_transaction`,
     `SessionFsSqliteTransactionFailure`
   - dotnet: `ISessionFsSqliteProvider.TransactionAsync`,
     `SessionFsSqliteStatement`, `SessionFsSqliteTransactionException`
   - rust: `SessionFsSqliteProvider::sqlite_transaction`,
     `SessionFsSqliteTransactionError`, dispatch arm

   Provider errors and "sqlite not supported" both surface as a *result-level*
   classified error (busyOrLocked / fatal / postCommitAmbiguous) rather than a
   transport error, since the runtime uses the class for retry decisions.
   In-repo test providers were updated with real BEGIN IMMEDIATE / COMMIT /
   ROLLBACK implementations.

2. Rust codegen bug for primitive RPC results

   `session.cancelAllBackgroundAgents` has an inline `{"type":"integer"}`
   result. `getResultTypeName()` named it `SessionCancelAllBackgroundAgentsResult`,
   but the type-emitting loops in scripts/codegen/rust.ts only handled
   enum/array/map/object schemas, so no alias was emitted (E0425). Added
   `rustScalarType` / `emitRustScalarAlias` and regenerated.

3. Java records gained components

   - `SessionOptionsUpdateParams`: `shell`, `eventsLogIncludesSubagents`
   - `SessionHistoryTruncateResult`: `checkpointCleanupFailed`,
     `checkpointCleanupError`
   - `AssistantMessageEventData`: `rte`

   Fixed the positional constructor call sites in CopilotClient and two tests.

4. Collateral wire changes

   - `permissions.resetSessionApprovals` now takes a params object (Go + Rust
     e2e call sites)
   - `UIExitPlanModeResponse` gained `defer_implementation` (Rust struct literal)

Generated by Copilot

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

Author: stephentoub

dotnet/src/SessionFsProvider.cs

@@ -3,6 +3,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 using GitHub.Copilot.Rpc;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 
 namespace GitHub.Copilot;
@@ -27,6 +28,23 @@ public sealed class SessionFsSqliteResult
     public long? LastInsertRowid { get; set; }
 }
 
+/// <summary>
+/// One statement in an atomic SQLite transaction passed to
+/// <see cref="ISessionFsSqliteProvider.TransactionAsync"/>.
+/// </summary>
+[Experimental(Diagnostics.Experimental)]
+public sealed class SessionFsSqliteStatement
+{
+    /// <summary>How to execute: <c>"exec"</c>, <c>"query"</c>, or <c>"run"</c>.</summary>
+    public SessionFsSqliteQueryType QueryType { get; set; }
+
+    /// <summary>SQL statement to execute.</summary>
+    public string Query { get; set; } = string.Empty;
+
+    /// <summary>Optional named bind parameters.</summary>
+    public IDictionary<string, object?>? Params { get; set; }
+}
+
 /// <summary>
 /// Optional interface for <see cref="SessionFsProvider"/> subclasses that support
 /// per-session SQLite databases. Implement this interface on your provider to enable
@@ -48,13 +66,53 @@ public interface ISessionFsSqliteProvider
         IDictionary<string, object?>? bindParams,
         CancellationToken cancellationToken);
 
+    /// <summary>
+    /// Executes <paramref name="statements"/> atomically against the per-session database.
+    /// </summary>
+    /// <param name="statements">Statements to execute in order, inside a single transaction.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>One result per statement, in the same order as <paramref name="statements"/>.</returns>
+    /// <exception cref="SessionFsSqliteTransactionException">
+    /// Thrown to tell the runtime how the failure should be classified. Any other exception
+    /// is reported as <see cref="SessionFsSqliteTransactionErrorClass.Fatal"/>.
+    /// </exception>
+    Task<IList<SessionFsSqliteResult>> TransactionAsync(
+        IList<SessionFsSqliteStatement> statements,
+        CancellationToken cancellationToken);
+
     /// <summary>
     /// Checks whether the per-session SQLite database already exists, without creating it.
     /// </summary>
     /// <param name="cancellationToken">Cancellation token.</param>
     Task<bool> ExistsAsync(CancellationToken cancellationToken);
 }
 
+/// <summary>
+/// Thrown by an <see cref="ISessionFsSqliteProvider"/> to classify a failed SQLite transaction.
+/// <see cref="SessionFsSqliteTransactionErrorClass.BusyOrLocked"/> guarantees the transaction
+/// rolled back and is safe to retry; <see cref="SessionFsSqliteTransactionErrorClass.PostCommitAmbiguous"/>
+/// must never be retried.
+/// </summary>
+[Experimental(Diagnostics.Experimental)]
+public sealed class SessionFsSqliteTransactionException : Exception
+{
+    /// <summary>Initializes a new instance of the <see cref="SessionFsSqliteTransactionException"/> class.</summary>
+    /// <param name="message">Human-readable failure description.</param>
+    /// <param name="errorClass">How the runtime should classify the failure.</param>
+    /// <param name="innerException">Optional underlying exception.</param>
+    public SessionFsSqliteTransactionException(
+        string message,
+        SessionFsSqliteTransactionErrorClass errorClass,
+        Exception? innerException = null)
+        : base(message, innerException)
+    {
+        ErrorClass = errorClass;
+    }
+
+    /// <summary>Gets the failure classification reported to the runtime.</summary>
+    public SessionFsSqliteTransactionErrorClass ErrorClass { get; }
+}
+
 /// <summary>
 /// Base class for session filesystem providers. Subclasses override the
 /// virtual methods and use normal C# patterns (return values, throw exceptions).
@@ -309,6 +367,64 @@ async Task<SessionFsSqliteQueryResult> ISessionFsHandler.SqliteQueryAsync(Sessio
         }
     }
 
+    async Task<SessionFsSqliteTransactionResult> ISessionFsHandler.SqliteTransactionAsync(SessionFsSqliteTransactionRequest request, CancellationToken cancellationToken)
+    {
+        if (this is not ISessionFsSqliteProvider sqliteProvider)
+        {
+            return new SessionFsSqliteTransactionResult
+            {
+                Error = new SessionFsSqliteTransactionError
+                {
+                    ErrorClass = SessionFsSqliteTransactionErrorClass.Fatal,
+                    Message = "SQLite is not supported by this provider.",
+                },
+            };
+        }
+
+        IList<SessionFsSqliteResult> results;
+        try
+        {
+            var statements = request.Statements.Select(statement => new SessionFsSqliteStatement
+            {
+                QueryType = statement.QueryType,
+                Query = statement.Query,
+                Params = statement.Params?.ToDictionary(kvp => kvp.Key, kvp => JsonElementToValue(kvp.Value)),
+            }).ToList();
+            results = await sqliteProvider.TransactionAsync(statements, cancellationToken).ConfigureAwait(false);
+        }
+        catch (SessionFsSqliteTransactionException ex)
+        {
+            return new SessionFsSqliteTransactionResult
+            {
+                Error = new SessionFsSqliteTransactionError { ErrorClass = ex.ErrorClass, Message = ex.Message },
+            };
+        }
+        catch (Exception ex)
+        {
+            return new SessionFsSqliteTransactionResult
+            {
+                Error = new SessionFsSqliteTransactionError
+                {
+                    ErrorClass = SessionFsSqliteTransactionErrorClass.Fatal,
+                    Message = ex.Message,
+                },
+            };
+        }
+
+        return new SessionFsSqliteTransactionResult
+        {
+            Results = results.Select(result => new SessionFsSqliteQueryResult
+            {
+                Rows = result.Rows?.Select(row => (IDictionary<string, JsonElement>)row.ToDictionary(
+                    kvp => kvp.Key,
+                    kvp => CopilotClient.ToJsonElementForWire(kvp.Value)!.Value)).ToList() ?? [],
+                Columns = result.Columns ?? [],
+                RowsAffected = result.RowsAffected,
+                LastInsertRowid = result.LastInsertRowid,
+            }).ToList(),
+        };
+    }
+
     async Task<SessionFsSqliteExistsResult> ISessionFsHandler.SqliteExistsAsync(SessionFsSqliteExistsRequest request, CancellationToken cancellationToken)
     {
         if (this is not ISessionFsSqliteProvider sqliteProvider)

dotnet/test/E2E/InMemorySessionFsSqliteHandler.cs

@@ -45,28 +45,68 @@ private SqliteConnection GetOrCreateDb()
         string query,
         IDictionary<string, object?>? bindParams,
         CancellationToken cancellationToken)
+    {
+        return Task.FromResult(RunStatement(GetOrCreateDb(), null, queryType, query, bindParams));
+    }
+
+    public Task<IList<SessionFsSqliteResult>> TransactionAsync(
+        IList<SessionFsSqliteStatement> statements,
+        CancellationToken cancellationToken)
+    {
+        var db = GetOrCreateDb();
+        using var transaction = db.BeginTransaction();
+        try
+        {
+            IList<SessionFsSqliteResult> results = statements
+                .Select(statement => RunStatement(db, transaction, statement.QueryType, statement.Query, statement.Params)
+                    ?? new SessionFsSqliteResult())
+                .ToList();
+            transaction.Commit();
+            return Task.FromResult(results);
+        }
+        catch (SqliteException ex)
+        {
+            transaction.Rollback();
+            var errorClass = ex.SqliteErrorCode is 5 or 6
+                ? SessionFsSqliteTransactionErrorClass.BusyOrLocked
+                : SessionFsSqliteTransactionErrorClass.Fatal;
+            throw new SessionFsSqliteTransactionException(ex.Message, errorClass, ex);
+        }
+        catch (Exception ex)
+        {
+            transaction.Rollback();
+            throw new SessionFsSqliteTransactionException(ex.Message, SessionFsSqliteTransactionErrorClass.Fatal, ex);
+        }
+    }
+
+    private SessionFsSqliteResult? RunStatement(
+        SqliteConnection db,
+        SqliteTransaction? transaction,
+        SessionFsSqliteQueryType queryType,
+        string query,
+        IDictionary<string, object?>? bindParams)
     {
         sqliteCalls.Add(new SqliteCall(sessionId, queryType.Value, query));
 
         var trimmed = query.Trim();
         if (trimmed.Length == 0)
         {
-            return Task.FromResult<SessionFsSqliteResult?>(null);
+            return null;
         }
 
-        var db = GetOrCreateDb();
-
         if (queryType == SessionFsSqliteQueryType.Exec)
         {
             using var cmd = db.CreateCommand();
+            cmd.Transaction = transaction;
             cmd.CommandText = trimmed;
             cmd.ExecuteNonQuery();
-            return Task.FromResult<SessionFsSqliteResult?>(null);
+            return null;
         }
 
         if (queryType == SessionFsSqliteQueryType.Query)
         {
             using var cmd = db.CreateCommand();
+            cmd.Transaction = transaction;
             cmd.CommandText = trimmed;
             AddParams(cmd, bindParams);
 
@@ -88,33 +128,35 @@ private SqliteConnection GetOrCreateDb()
                 rows.Add(row);
             }
 
-            return Task.FromResult<SessionFsSqliteResult?>(new SessionFsSqliteResult
+            return new SessionFsSqliteResult
             {
                 Columns = columns,
                 Rows = rows,
                 RowsAffected = 0,
-            });
+            };
         }
 
         if (queryType == SessionFsSqliteQueryType.Run)
         {
             using var cmd = db.CreateCommand();
+            cmd.Transaction = transaction;
             cmd.CommandText = trimmed;
             AddParams(cmd, bindParams);
 
             var rowsAffected = cmd.ExecuteNonQuery();
 
             using var rowidCmd = db.CreateCommand();
+            rowidCmd.Transaction = transaction;
             rowidCmd.CommandText = "SELECT last_insert_rowid()";
             var lastRowid = rowidCmd.ExecuteScalar();
 
-            return Task.FromResult<SessionFsSqliteResult?>(new SessionFsSqliteResult
+            return new SessionFsSqliteResult
             {
                 Columns = [],
                 Rows = [],
                 RowsAffected = rowsAffected,
                 LastInsertRowid = lastRowid is long l ? l : null,
-            });
+            };
         }
 
         throw new ArgumentException($"Unknown queryType: {queryType}");

dotnet/test/E2E/SessionFsE2ETests.cs

@@ -616,6 +616,9 @@ protected override Task RenameAsync(string src, string dest, CancellationToken c
         Task<SessionFsSqliteResult?> ISessionFsSqliteProvider.QueryAsync(SessionFsSqliteQueryType queryType, string query, IDictionary<string, object?>? bindParams, CancellationToken cancellationToken) =>
             Task.FromException<SessionFsSqliteResult?>(exception);
 
+        Task<IList<SessionFsSqliteResult>> ISessionFsSqliteProvider.TransactionAsync(IList<SessionFsSqliteStatement> statements, CancellationToken cancellationToken) =>
+            Task.FromException<IList<SessionFsSqliteResult>>(exception);
+
         Task<bool> ISessionFsSqliteProvider.ExistsAsync(CancellationToken cancellationToken) =>
             Task.FromException<bool>(exception);
     }

go/internal/e2e/rpc_session_state_e2e_test.go

@@ -1083,7 +1083,7 @@ func TestRPCSessionStateE2E(t *testing.T) {
 			t.Errorf("Expected SetApproveAll(true) to succeed, got %+v", approve)
 		}
 
-		reset, err := session.RPC.Permissions.ResetSessionApprovals(t.Context())
+		reset, err := session.RPC.Permissions.ResetSessionApprovals(t.Context(), &rpc.PermissionsResetSessionApprovalsRequest{})
 		if err != nil {
 			t.Fatalf("Failed to call ResetSessionApprovals: %v", err)
 		}

go/internal/e2e/session_fs_sqlite_e2e_test.go

@@ -198,39 +198,55 @@ func (p *inMemorySqliteProvider) Rename(src string, dest string) error {
 func (p *inMemorySqliteProvider) SqliteQuery(queryType rpc.SessionFSSqliteQueryType, query string, params map[string]any) (*copilot.SessionFSSqliteQueryResult, error) {
 	p.mu.Lock()
 	defer p.mu.Unlock()
+	return p.runQueryLocked(queryType, query), nil
+}
+
+func (p *inMemorySqliteProvider) SqliteTransaction(statements []rpc.SessionFSSqliteTransactionStatement) ([]copilot.SessionFSSqliteQueryResult, error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	results := make([]copilot.SessionFSSqliteQueryResult, 0, len(statements))
+	for _, statement := range statements {
+		results = append(results, *p.runQueryLocked(statement.QueryType, statement.Query))
+	}
+	return results, nil
+}
+
+// runQueryLocked returns canned results based on query type. The agent doesn't
+// know or care whether a real SQLite database is behind this — it just receives
+// SQL tool results. These stubs return plausible responses so the agent can
+// proceed normally without pulling in a real SQLite dependency.
+//
+// Callers must hold p.mu.
+func (p *inMemorySqliteProvider) runQueryLocked(queryType rpc.SessionFSSqliteQueryType, query string) *copilot.SessionFSSqliteQueryResult {
 	p.hadQuery = true
 	*p.sqliteCalls = append(*p.sqliteCalls, sqliteCall{
 		SessionID: p.sessionID,
 		QueryType: string(queryType),
 		Query:     query,
 	})
 
-	// Return canned results based on query type. The agent doesn't know or care
-	// whether a real SQLite database is behind this — it just receives SQL tool
-	// results. These stubs return plausible responses so the agent can proceed
-	// normally without pulling in a real SQLite dependency.
 	upper := strings.ToUpper(strings.TrimSpace(query))
 	switch queryType {
 	case rpc.SessionFSSqliteQueryTypeExec:
-		return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}, nil
+		return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}
 	case rpc.SessionFSSqliteQueryTypeRun:
 		lastID := int64(1)
 		return &copilot.SessionFSSqliteQueryResult{
 			Columns:         []string{},
 			Rows:            []map[string]any{},
 			RowsAffected:    1,
 			LastInsertRowid: &lastID,
-		}, nil
+		}
 	case rpc.SessionFSSqliteQueryTypeQuery:
 		if strings.Contains(upper, "SELECT") {
 			return &copilot.SessionFSSqliteQueryResult{
 				Columns: []string{"id", "name"},
 				Rows:    []map[string]any{{"id": "a1", "name": "Widget"}},
-			}, nil
+			}
 		}
-		return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}, nil
+		return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}
 	}
-	return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}, nil
+	return &copilot.SessionFSSqliteQueryResult{Columns: []string{}, Rows: []map[string]any{}}
 }
 
 func (p *inMemorySqliteProvider) SqliteExists() (bool, error) {