Address SDK update review feedback

Tighten C# SessionFS exception handling and make Python SessionFS adapter params type-check cleanly.

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

Author: Copilot

dotnet/src/SessionFsProvider.cs

@@ -252,7 +252,7 @@ async Task<SessionFsSqliteQueryResult> ISessionFsHandler.SqliteQueryAsync(Sessio
         {
             return await SqliteQueryAsync(request.SessionId, request.Query, request.QueryType, request.Params, cancellationToken).ConfigureAwait(false);
         }
-        catch (Exception ex)
+        catch (Exception ex) when (!IsCriticalException(ex))
         {
             return new SessionFsSqliteQueryResult { Error = ToSessionFsError(ex) };
         }
@@ -267,12 +267,22 @@ async Task<SessionFsSqliteExistsResult> ISessionFsHandler.SqliteExistsAsync(Sess
             var exists = await SqliteExistsAsync(request.SessionId, cancellationToken).ConfigureAwait(false);
             return new SessionFsSqliteExistsResult { Exists = exists };
         }
-        catch
+        catch (Exception ex) when (!IsCriticalException(ex))
         {
             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)
     {
         var code = ex is FileNotFoundException or DirectoryNotFoundException

dotnet/test/E2E/ModeHandlersE2ETests.cs

@@ -71,7 +71,9 @@ public async Task Should_Invoke_Exit_Plan_Mode_Handler_When_Model_Uses_Tool()
 
         var completedEvent = await completedEventTask;
         Assert.True(completedEvent.Data.Approved);
-        Assert.Equal("interactive", completedEvent.Data.SelectedAction?.Value);
+        var selectedAction = completedEvent.Data.SelectedAction;
+        Assert.NotNull(selectedAction);
+        Assert.Equal("interactive", selectedAction.Value.Value);
         Assert.Equal("Approved by the C# E2E test", completedEvent.Data.Feedback);
 
         Assert.NotNull(response);

python/copilot/session_fs_provider.py

@@ -21,6 +21,7 @@
 from collections.abc import Sequence
 from dataclasses import dataclass
 from datetime import UTC, datetime
+from typing import Any
 
 from .generated.rpc import (
     SessionFSError,
@@ -128,36 +129,36 @@ class _SessionFsAdapter:
     def __init__(self, provider: SessionFsProvider) -> None:
         self._p = provider
 
-    async def read_file(self, params: object) -> SessionFSReadFileResult:
+    async def read_file(self, params: Any) -> SessionFSReadFileResult:
         try:
             content = await self._p.read_file(params.path)  # type: ignore[attr-defined]
             return SessionFSReadFileResult.from_dict({"content": content})
         except Exception as exc:
             err = _to_session_fs_error(exc)
             return SessionFSReadFileResult.from_dict({"content": "", "error": err.to_dict()})
 
-    async def write_file(self, params: object) -> SessionFSError | None:
+    async def write_file(self, params: Any) -> SessionFSError | None:
         try:
             await self._p.write_file(params.path, params.content, getattr(params, "mode", None))  # type: ignore[attr-defined]
             return None
         except Exception as exc:
             return _to_session_fs_error(exc)
 
-    async def append_file(self, params: object) -> SessionFSError | None:
+    async def append_file(self, params: Any) -> SessionFSError | None:
         try:
             await self._p.append_file(params.path, params.content, getattr(params, "mode", None))  # type: ignore[attr-defined]
             return None
         except Exception as exc:
             return _to_session_fs_error(exc)
 
-    async def exists(self, params: object) -> SessionFSExistsResult:
+    async def exists(self, params: Any) -> SessionFSExistsResult:
         try:
             result = await self._p.exists(params.path)  # type: ignore[attr-defined]
             return SessionFSExistsResult.from_dict({"exists": result})
         except Exception:
             return SessionFSExistsResult.from_dict({"exists": False})
 
-    async def stat(self, params: object) -> SessionFSStatResult:
+    async def stat(self, params: Any) -> SessionFSStatResult:
         try:
             info = await self._p.stat(params.path)  # type: ignore[attr-defined]
             return SessionFSStatResult(
@@ -179,7 +180,7 @@ async def stat(self, params: object) -> SessionFSStatResult:
                 error=err,
             )
 
-    async def mkdir(self, params: object) -> SessionFSError | None:
+    async def mkdir(self, params: Any) -> SessionFSError | None:
         try:
             await self._p.mkdir(
                 params.path,  # type: ignore[attr-defined]
@@ -190,15 +191,15 @@ async def mkdir(self, params: object) -> SessionFSError | None:
         except Exception as exc:
             return _to_session_fs_error(exc)
 
-    async def readdir(self, params: object) -> SessionFSReaddirResult:
+    async def readdir(self, params: Any) -> SessionFSReaddirResult:
         try:
             entries = await self._p.readdir(params.path)  # type: ignore[attr-defined]
             return SessionFSReaddirResult.from_dict({"entries": entries})
         except Exception as exc:
             err = _to_session_fs_error(exc)
             return SessionFSReaddirResult.from_dict({"entries": [], "error": err.to_dict()})
 
-    async def readdir_with_types(self, params: object) -> SessionFSReaddirWithTypesResult:
+    async def readdir_with_types(self, params: Any) -> SessionFSReaddirWithTypesResult:
         try:
             entries = await self._p.readdir_with_types(params.path)  # type: ignore[attr-defined]
             return SessionFSReaddirWithTypesResult(entries=list(entries))
@@ -208,7 +209,7 @@ async def readdir_with_types(self, params: object) -> SessionFSReaddirWithTypesR
                 {"entries": [], "error": err.to_dict()}
             )
 
-    async def rm(self, params: object) -> SessionFSError | None:
+    async def rm(self, params: Any) -> SessionFSError | None:
         try:
             await self._p.rm(
                 params.path,  # type: ignore[attr-defined]
@@ -219,14 +220,14 @@ async def rm(self, params: object) -> SessionFSError | None:
         except Exception as exc:
             return _to_session_fs_error(exc)
 
-    async def rename(self, params: object) -> SessionFSError | None:
+    async def rename(self, params: Any) -> SessionFSError | None:
         try:
             await self._p.rename(params.src, params.dest)  # type: ignore[attr-defined]
             return None
         except Exception as exc:
             return _to_session_fs_error(exc)
 
-    async def sqlite_query(self, params: object) -> SessionFSSqliteQueryResult:
+    async def sqlite_query(self, params: Any) -> SessionFSSqliteQueryResult:
         try:
             return await self._p.sqlite_query(  # type: ignore[attr-defined]
                 params.session_id,
@@ -242,7 +243,7 @@ async def sqlite_query(self, params: object) -> SessionFSSqliteQueryResult:
                 error=_to_session_fs_error(exc),
             )
 
-    async def sqlite_exists(self, params: object) -> SessionFSSqliteExistsResult:
+    async def sqlite_exists(self, params: Any) -> SessionFSSqliteExistsResult:
         try:
             result = await self._p.sqlite_exists(params.session_id)  # type: ignore[attr-defined]
             return SessionFSSqliteExistsResult.from_dict({"exists": result})