Add SessionFs sqlite support for runtime sqlite routing (#1299)

Author: SteveSandersonMS

dotnet/Directory.Packages.props

@@ -7,6 +7,7 @@
   <ItemGroup>
     <PackageVersion Include="coverlet.collector" Version="6.0.4" />
     <PackageVersion Include="Microsoft.Bcl.AsyncInterfaces" Version="10.0.2" />
+    <PackageVersion Include="Microsoft.Data.Sqlite" Version="9.0.6" />
     <PackageVersion Include="Microsoft.Extensions.AI.Abstractions" Version="10.2.0" />
     <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.2" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />

dotnet/src/Client.cs

@@ -1329,6 +1329,7 @@ await Rpc.SessionFs.SetProviderAsync(
             _options.SessionFs.InitialCwd,
             _options.SessionFs.SessionStatePath,
             _options.SessionFs.Conventions,
+            _options.SessionFs.Capabilities,
             cancellationToken: cancellationToken);
     }
 
@@ -1345,8 +1346,16 @@ private void ConfigureSessionFsHandlers(CopilotSession session, Func<CopilotSess
                 "CreateSessionFsHandler is required in the session config when CopilotClientOptions.SessionFs is configured.");
         }
 
-        session.ClientSessionApis.SessionFs = createSessionFsHandler(session)
+        var provider = createSessionFsHandler(session)
             ?? throw new InvalidOperationException("CreateSessionFsHandler returned null.");
+
+        if (_options.SessionFs.Capabilities?.Sqlite == true && provider is not ISessionFsSqliteProvider)
+        {
+            throw new InvalidOperationException(
+                "SessionFsConfig declares capabilities.sqlite but the provider does not implement ISessionFsSqliteProvider.");
+        }
+
+        session.ClientSessionApis.SessionFs = provider;
     }
 
     private async Task VerifyProtocolVersionAsync(Connection connection, CancellationToken cancellationToken)

dotnet/src/SessionFsProvider.cs

@@ -6,11 +6,60 @@
 
 namespace GitHub.Copilot.SDK;
 
+/// <summary>
+/// Result of a SQLite query execution via <see cref="ISessionFsSqliteProvider"/>.
+/// Same shape as <see cref="SessionFsSqliteQueryResult"/> but without the <c>Error</c> field,
+/// since providers signal errors by throwing.
+/// </summary>
+public class SessionFsSqliteResult
+{
+    /// <summary>Column names from the result set.</summary>
+    public IList<string> Columns { get; set; } = [];
+
+    /// <summary>For SELECT: rows as column-keyed dictionaries. For others: empty.</summary>
+    public IList<IDictionary<string, object>> Rows { get; set; } = [];
+
+    /// <summary>Number of rows affected (for INSERT/UPDATE/DELETE).</summary>
+    public long RowsAffected { get; set; }
+
+    /// <summary>Last inserted row ID (for INSERT).</summary>
+    public long? LastInsertRowid { get; set; }
+}
+
+/// <summary>
+/// Optional interface for <see cref="SessionFsProvider"/> subclasses that support
+/// per-session SQLite databases. Implement this interface on your provider to enable
+/// the runtime's SQL tool to route queries through your SessionFs implementation.
+/// </summary>
+public interface ISessionFsSqliteProvider
+{
+    /// <summary>
+    /// Executes a SQLite query against the per-session database.
+    /// </summary>
+    /// <param name="queryType">How to execute: <c>"exec"</c> for DDL/multi-statement, <c>"query"</c> for SELECT, <c>"run"</c> for INSERT/UPDATE/DELETE.</param>
+    /// <param name="query">SQL query to execute.</param>
+    /// <param name="bindParams">Optional named bind parameters.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The query result, or <c>null</c> for exec-type queries.</returns>
+    Task<SessionFsSqliteResult?> QueryAsync(
+        SessionFsSqliteQueryType queryType,
+        string query,
+        IDictionary<string, object>? bindParams,
+        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>
 /// Base class for session filesystem providers. Subclasses override the
 /// virtual methods and use normal C# patterns (return values, throw exceptions).
 /// The base class catches exceptions and converts them to <see cref="SessionFsError"/>
 /// results expected by the runtime.
+/// To add SQLite support, also implement <see cref="ISessionFsSqliteProvider"/>.
 /// </summary>
 public abstract class SessionFsProvider : ISessionFsHandler
 {
@@ -75,24 +124,6 @@ public abstract class SessionFsProvider : ISessionFsHandler
     /// <param name="cancellationToken">Cancellation token.</param>
     protected abstract Task RenameAsync(string src, string dest, CancellationToken cancellationToken);
 
-    /// <summary>Executes a SQLite query against the per-session database.</summary>
-    /// <param name="sessionId">Target session identifier.</param>
-    /// <param name="query">SQL query to execute.</param>
-    /// <param name="queryType">How to execute the query.</param>
-    /// <param name="parameters">Optional named bind parameters.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    protected abstract Task<SessionFsSqliteQueryResult> SqliteQueryAsync(
-        string sessionId,
-        string query,
-        SessionFsSqliteQueryType queryType,
-        IDictionary<string, object>? parameters,
-        CancellationToken cancellationToken);
-
-    /// <summary>Checks whether the per-session SQLite database already exists.</summary>
-    /// <param name="sessionId">Target session identifier.</param>
-    /// <param name="cancellationToken">Cancellation token.</param>
-    protected abstract Task<bool> SqliteExistsAsync(string sessionId, CancellationToken cancellationToken);
-
     // ---- ISessionFsHandler implementation (private, handles error mapping) ----
 
     async Task<SessionFsReadFileResult> ISessionFsHandler.ReadFileAsync(SessionFsReadFileRequest request, CancellationToken cancellationToken)
@@ -246,42 +277,50 @@ async Task<SessionFsReaddirWithTypesResult> ISessionFsHandler.ReaddirWithTypesAs
 
     async Task<SessionFsSqliteQueryResult> ISessionFsHandler.SqliteQueryAsync(SessionFsSqliteQueryRequest request, CancellationToken cancellationToken)
     {
-        ArgumentNullException.ThrowIfNull(request);
+        if (this is not ISessionFsSqliteProvider sqliteProvider)
+        {
+            return new SessionFsSqliteQueryResult
+            {
+                Error = new SessionFsError { Code = SessionFsErrorCode.UNKNOWN, Message = "SQLite is not supported by this provider." },
+            };
+        }
 
         try
         {
-            return await SqliteQueryAsync(request.SessionId, request.Query, request.QueryType, request.Params, cancellationToken).ConfigureAwait(false);
+            var result = await sqliteProvider.QueryAsync(request.QueryType, request.Query, request.Params, cancellationToken).ConfigureAwait(false);
+
+            return new SessionFsSqliteQueryResult
+            {
+                Rows = result?.Rows ?? [],
+                Columns = result?.Columns ?? [],
+                RowsAffected = result?.RowsAffected ?? 0,
+                LastInsertRowid = result?.LastInsertRowid,
+            };
         }
-        catch (Exception ex) when (!IsCriticalException(ex))
+        catch (Exception ex)
         {
             return new SessionFsSqliteQueryResult { Error = ToSessionFsError(ex) };
         }
     }
 
     async Task<SessionFsSqliteExistsResult> ISessionFsHandler.SqliteExistsAsync(SessionFsSqliteExistsRequest request, CancellationToken cancellationToken)
     {
-        ArgumentNullException.ThrowIfNull(request);
+        if (this is not ISessionFsSqliteProvider sqliteProvider)
+        {
+            return new SessionFsSqliteExistsResult { Exists = false };
+        }
 
         try
         {
-            var exists = await SqliteExistsAsync(request.SessionId, cancellationToken).ConfigureAwait(false);
+            var exists = await sqliteProvider.ExistsAsync(cancellationToken).ConfigureAwait(false);
             return new SessionFsSqliteExistsResult { Exists = exists };
         }
-        catch (Exception ex) when (!IsCriticalException(ex))
+        catch
         {
             return new SessionFsSqliteExistsResult { Exists = false };
         }
     }
 
-    private static bool IsCriticalException(Exception ex) =>
-        ex is OperationCanceledException
-            or OutOfMemoryException
-            or StackOverflowException
-            or AccessViolationException
-            or AppDomainUnloadedException
-            or BadImageFormatException
-            or CannotUnloadAppDomainException
-            or InvalidProgramException;
 
     private static SessionFsError ToSessionFsError(Exception ex)
     {

dotnet/src/Types.cs

@@ -323,6 +323,13 @@ public sealed class SessionFsConfig
     /// Path conventions used by this filesystem provider.
     /// </summary>
     public required SessionFsSetProviderConventions Conventions { get; init; }
+
+    /// <summary>
+    /// Optional capabilities that this filesystem provider supports.
+    /// When <see cref="SessionFsSetProviderCapabilities.Sqlite"/> is <c>true</c>,
+    /// the runtime routes SQLite queries through the provider instead of using a local database file.
+    /// </summary>
+    public SessionFsSetProviderCapabilities? Capabilities { get; init; }
 }
 
 /// <summary>