From 16df2408b2b17445ca079cf77f54f06eeb2220ac Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 14 Apr 2026 22:06:41 +0000 Subject: [PATCH 1/5] Update @github/copilot to 1.0.26 - Updated nodejs and test harness dependencies - Re-ran code generators - Formatted generated code --- dotnet/src/Generated/Rpc.cs | 249 +++++++++++++++++++++++++++---- go/rpc/generated_rpc.go | 133 ++++++++++++++--- nodejs/package-lock.json | 56 +++---- nodejs/package.json | 2 +- nodejs/samples/package-lock.json | 2 +- nodejs/src/generated/rpc.ts | 67 +++++++-- python/copilot/generated/rpc.py | 236 ++++++++++++++++++++++++----- test/harness/package-lock.json | 56 +++---- test/harness/package.json | 2 +- 9 files changed, 647 insertions(+), 156 deletions(-) diff --git a/dotnet/src/Generated/Rpc.cs b/dotnet/src/Generated/Rpc.cs index 0bea6e8db..5b7db655f 100644 --- a/dotnet/src/Generated/Rpc.cs +++ b/dotnet/src/Generated/Rpc.cs @@ -493,6 +493,37 @@ internal sealed class ModeSetRequest public SessionMode Mode { get; set; } } +/// RPC data type for NameGet operations. +public sealed class NameGetResult +{ + /// The session name, falling back to the auto-generated summary, or null if neither exists. + [JsonPropertyName("name")] + public string? Name { get; set; } +} + +/// RPC data type for SessionNameGet operations. +internal sealed class SessionNameGetRequest +{ + /// Target session identifier. + [JsonPropertyName("sessionId")] + public string SessionId { get; set; } = string.Empty; +} + +/// RPC data type for NameSet operations. +internal sealed class NameSetRequest +{ + /// Target session identifier. + [JsonPropertyName("sessionId")] + public string SessionId { get; set; } = string.Empty; + + /// New session name (1–100 characters, trimmed of leading/trailing whitespace). + [MinLength(1)] + [MaxLength(100)] + [JsonPropertyName("name")] + [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "")] + public string Name { get; set; } = string.Empty; +} + /// RPC data type for PlanRead operations. public sealed class PlanReadResult { @@ -537,32 +568,113 @@ internal sealed class SessionPlanDeleteRequest public string SessionId { get; set; } = string.Empty; } -/// RPC data type for WorkspaceListFiles operations. -public sealed class WorkspaceListFilesResult +/// RPC data type for WorkspacesGetWorkspaceResultWorkspace operations. +public sealed class WorkspacesGetWorkspaceResultWorkspace +{ + /// Gets or sets the id value. + [JsonPropertyName("id")] + public Guid Id { get; set; } + + /// Gets or sets the cwd value. + [JsonPropertyName("cwd")] + public string? Cwd { get; set; } + + /// Gets or sets the git_root value. + [JsonPropertyName("git_root")] + public string? GitRoot { get; set; } + + /// Gets or sets the repository value. + [JsonPropertyName("repository")] + public string? Repository { get; set; } + + /// Gets or sets the host_type value. + [JsonPropertyName("host_type")] + public WorkspacesGetWorkspaceResultWorkspaceHostType? HostType { get; set; } + + /// Gets or sets the branch value. + [JsonPropertyName("branch")] + public string? Branch { get; set; } + + /// Gets or sets the summary value. + [JsonPropertyName("summary")] + public string? Summary { get; set; } + + /// Gets or sets the name value. + [JsonPropertyName("name")] + public string? Name { get; set; } + + /// Gets or sets the summary_count value. + [Range((double)0, (double)long.MaxValue)] + [JsonPropertyName("summary_count")] + public long? SummaryCount { get; set; } + + /// Gets or sets the created_at value. + [JsonPropertyName("created_at")] + public DateTimeOffset? CreatedAt { get; set; } + + /// Gets or sets the updated_at value. + [JsonPropertyName("updated_at")] + public DateTimeOffset? UpdatedAt { get; set; } + + /// Gets or sets the mc_task_id value. + [JsonPropertyName("mc_task_id")] + public string? McTaskId { get; set; } + + /// Gets or sets the mc_session_id value. + [JsonPropertyName("mc_session_id")] + public string? McSessionId { get; set; } + + /// Gets or sets the mc_last_event_id value. + [JsonPropertyName("mc_last_event_id")] + public string? McLastEventId { get; set; } + + /// Gets or sets the session_sync_level value. + [JsonPropertyName("session_sync_level")] + public WorkspacesGetWorkspaceResultWorkspaceSessionSyncLevel? SessionSyncLevel { get; set; } +} + +/// RPC data type for WorkspacesGetWorkspace operations. +public sealed class WorkspacesGetWorkspaceResult +{ + /// Current workspace metadata, or null if not available. + [JsonPropertyName("workspace")] + public WorkspacesGetWorkspaceResultWorkspace? Workspace { get; set; } +} + +/// RPC data type for SessionWorkspacesGetWorkspace operations. +internal sealed class SessionWorkspacesGetWorkspaceRequest +{ + /// Target session identifier. + [JsonPropertyName("sessionId")] + public string SessionId { get; set; } = string.Empty; +} + +/// RPC data type for WorkspacesListFiles operations. +public sealed class WorkspacesListFilesResult { /// Relative file paths in the workspace files directory. [JsonPropertyName("files")] public IList Files { get => field ??= []; set; } } -/// RPC data type for SessionWorkspaceListFiles operations. -internal sealed class SessionWorkspaceListFilesRequest +/// RPC data type for SessionWorkspacesListFiles operations. +internal sealed class SessionWorkspacesListFilesRequest { /// Target session identifier. [JsonPropertyName("sessionId")] public string SessionId { get; set; } = string.Empty; } -/// RPC data type for WorkspaceReadFile operations. -public sealed class WorkspaceReadFileResult +/// RPC data type for WorkspacesReadFile operations. +public sealed class WorkspacesReadFileResult { /// File content as a UTF-8 string. [JsonPropertyName("content")] public string Content { get; set; } = string.Empty; } -/// RPC data type for WorkspaceReadFile operations. -internal sealed class WorkspaceReadFileRequest +/// RPC data type for WorkspacesReadFile operations. +internal sealed class WorkspacesReadFileRequest { /// Target session identifier. [JsonPropertyName("sessionId")] @@ -573,8 +685,8 @@ internal sealed class WorkspaceReadFileRequest public string Path { get; set; } = string.Empty; } -/// RPC data type for WorkspaceCreateFile operations. -internal sealed class WorkspaceCreateFileRequest +/// RPC data type for WorkspacesCreateFile operations. +internal sealed class WorkspacesCreateFileRequest { /// Target session identifier. [JsonPropertyName("sessionId")] @@ -1754,6 +1866,35 @@ public enum SessionMode } +/// Defines the allowed values. +[JsonConverter(typeof(JsonStringEnumConverter))] +public enum WorkspacesGetWorkspaceResultWorkspaceHostType +{ + /// The github variant. + [JsonStringEnumMemberName("github")] + Github, + /// The ado variant. + [JsonStringEnumMemberName("ado")] + Ado, +} + + +/// Defines the allowed values. +[JsonConverter(typeof(JsonStringEnumConverter))] +public enum WorkspacesGetWorkspaceResultWorkspaceSessionSyncLevel +{ + /// The local variant. + [JsonStringEnumMemberName("local")] + Local, + /// The user variant. + [JsonStringEnumMemberName("user")] + User, + /// The repo_and_user variant. + [JsonStringEnumMemberName("repo_and_user")] + RepoAndUser, +} + + /// Connection status: connected, failed, needs-auth, pending, disabled, or not_configured. [JsonConverter(typeof(JsonStringEnumConverter))] public enum McpServerStatus @@ -2036,8 +2177,9 @@ internal SessionRpc(JsonRpc rpc, string sessionId) _sessionId = sessionId; Model = new ModelApi(rpc, sessionId); Mode = new ModeApi(rpc, sessionId); + Name = new NameApi(rpc, sessionId); Plan = new PlanApi(rpc, sessionId); - Workspace = new WorkspaceApi(rpc, sessionId); + Workspaces = new WorkspacesApi(rpc, sessionId); Fleet = new FleetApi(rpc, sessionId); Agent = new AgentApi(rpc, sessionId); Skills = new SkillsApi(rpc, sessionId); @@ -2059,11 +2201,14 @@ internal SessionRpc(JsonRpc rpc, string sessionId) /// Mode APIs. public ModeApi Mode { get; } + /// Name APIs. + public NameApi Name { get; } + /// Plan APIs. public PlanApi Plan { get; } - /// Workspace APIs. - public WorkspaceApi Workspace { get; } + /// Workspaces APIs. + public WorkspacesApi Workspaces { get; } /// Fleet APIs. public FleetApi Fleet { get; } @@ -2166,6 +2311,33 @@ public async Task SetAsync(SessionMode mode, CancellationToken cancellationToken } } +/// Provides session-scoped Name APIs. +public sealed class NameApi +{ + private readonly JsonRpc _rpc; + private readonly string _sessionId; + + internal NameApi(JsonRpc rpc, string sessionId) + { + _rpc = rpc; + _sessionId = sessionId; + } + + /// Calls "session.name.get". + public async Task GetAsync(CancellationToken cancellationToken = default) + { + var request = new SessionNameGetRequest { SessionId = _sessionId }; + return await CopilotClient.InvokeRpcAsync(_rpc, "session.name.get", [request], cancellationToken); + } + + /// Calls "session.name.set". + public async Task SetAsync(string name, CancellationToken cancellationToken = default) + { + var request = new NameSetRequest { SessionId = _sessionId, Name = name }; + await CopilotClient.InvokeRpcAsync(_rpc, "session.name.set", [request], cancellationToken); + } +} + /// Provides session-scoped Plan APIs. public sealed class PlanApi { @@ -2200,37 +2372,44 @@ public async Task DeleteAsync(CancellationToken cancellationToken = default) } } -/// Provides session-scoped Workspace APIs. -public sealed class WorkspaceApi +/// Provides session-scoped Workspaces APIs. +public sealed class WorkspacesApi { private readonly JsonRpc _rpc; private readonly string _sessionId; - internal WorkspaceApi(JsonRpc rpc, string sessionId) + internal WorkspacesApi(JsonRpc rpc, string sessionId) { _rpc = rpc; _sessionId = sessionId; } - /// Calls "session.workspace.listFiles". - public async Task ListFilesAsync(CancellationToken cancellationToken = default) + /// Calls "session.workspaces.getWorkspace". + public async Task GetWorkspaceAsync(CancellationToken cancellationToken = default) + { + var request = new SessionWorkspacesGetWorkspaceRequest { SessionId = _sessionId }; + return await CopilotClient.InvokeRpcAsync(_rpc, "session.workspaces.getWorkspace", [request], cancellationToken); + } + + /// Calls "session.workspaces.listFiles". + public async Task ListFilesAsync(CancellationToken cancellationToken = default) { - var request = new SessionWorkspaceListFilesRequest { SessionId = _sessionId }; - return await CopilotClient.InvokeRpcAsync(_rpc, "session.workspace.listFiles", [request], cancellationToken); + var request = new SessionWorkspacesListFilesRequest { SessionId = _sessionId }; + return await CopilotClient.InvokeRpcAsync(_rpc, "session.workspaces.listFiles", [request], cancellationToken); } - /// Calls "session.workspace.readFile". - public async Task ReadFileAsync(string path, CancellationToken cancellationToken = default) + /// Calls "session.workspaces.readFile". + public async Task ReadFileAsync(string path, CancellationToken cancellationToken = default) { - var request = new WorkspaceReadFileRequest { SessionId = _sessionId, Path = path }; - return await CopilotClient.InvokeRpcAsync(_rpc, "session.workspace.readFile", [request], cancellationToken); + var request = new WorkspacesReadFileRequest { SessionId = _sessionId, Path = path }; + return await CopilotClient.InvokeRpcAsync(_rpc, "session.workspaces.readFile", [request], cancellationToken); } - /// Calls "session.workspace.createFile". + /// Calls "session.workspaces.createFile". public async Task CreateFileAsync(string path, string content, CancellationToken cancellationToken = default) { - var request = new WorkspaceCreateFileRequest { SessionId = _sessionId, Path = path, Content = content }; - await CopilotClient.InvokeRpcAsync(_rpc, "session.workspace.createFile", [request], cancellationToken); + var request = new WorkspacesCreateFileRequest { SessionId = _sessionId, Path = path, Content = content }; + await CopilotClient.InvokeRpcAsync(_rpc, "session.workspaces.createFile", [request], cancellationToken); } } @@ -2812,6 +2991,8 @@ public static void RegisterClientSessionApiHandlers(JsonRpc rpc, Func): Promise => connection.sendRequest("session.mode.set", { sessionId, ...params }), }, + name: { + get: async (): Promise => + connection.sendRequest("session.name.get", { sessionId }), + set: async (params: Omit): Promise => + connection.sendRequest("session.name.set", { sessionId, ...params }), + }, plan: { read: async (): Promise => connection.sendRequest("session.plan.read", { sessionId }), @@ -1601,13 +1644,15 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin delete: async (): Promise => connection.sendRequest("session.plan.delete", { sessionId }), }, - workspace: { - listFiles: async (): Promise => - connection.sendRequest("session.workspace.listFiles", { sessionId }), - readFile: async (params: Omit): Promise => - connection.sendRequest("session.workspace.readFile", { sessionId, ...params }), - createFile: async (params: Omit): Promise => - connection.sendRequest("session.workspace.createFile", { sessionId, ...params }), + workspaces: { + getWorkspace: async (): Promise => + connection.sendRequest("session.workspaces.getWorkspace", { sessionId }), + listFiles: async (): Promise => + connection.sendRequest("session.workspaces.listFiles", { sessionId }), + readFile: async (params: Omit): Promise => + connection.sendRequest("session.workspaces.readFile", { sessionId, ...params }), + createFile: async (params: Omit): Promise => + connection.sendRequest("session.workspaces.createFile", { sessionId, ...params }), }, /** @experimental */ fleet: { diff --git a/python/copilot/generated/rpc.py b/python/copilot/generated/rpc.py index b24f74e51..19a2660d5 100644 --- a/python/copilot/generated/rpc.py +++ b/python/copilot/generated/rpc.py @@ -1130,6 +1130,38 @@ def to_dict(self) -> dict: result["mode"] = to_enum(SessionMode, self.mode) return result +@dataclass +class NameGetResult: + name: str | None = None + """The session name, falling back to the auto-generated summary, or null if neither exists""" + + @staticmethod + def from_dict(obj: Any) -> 'NameGetResult': + assert isinstance(obj, dict) + name = from_union([from_none, from_str], obj.get("name")) + return NameGetResult(name) + + def to_dict(self) -> dict: + result: dict = {} + result["name"] = from_union([from_none, from_str], self.name) + return result + +@dataclass +class NameSetRequest: + name: str + """New session name (1–100 characters, trimmed of leading/trailing whitespace)""" + + @staticmethod + def from_dict(obj: Any) -> 'NameSetRequest': + assert isinstance(obj, dict) + name = from_str(obj.get("name")) + return NameSetRequest(name) + + def to_dict(self) -> dict: + result: dict = {} + result["name"] = from_str(self.name) + return result + @dataclass class PlanReadResult: exists: bool @@ -1172,16 +1204,112 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result +class HostType(Enum): + ADO = "ado" + GITHUB = "github" + +class SessionSyncLevel(Enum): + LOCAL = "local" + REPO_AND_USER = "repo_and_user" + USER = "user" + @dataclass -class WorkspaceListFilesResult: +class Workspace: + id: UUID + branch: str | None = None + created_at: datetime | None = None + cwd: str | None = None + git_root: str | None = None + host_type: HostType | None = None + mc_last_event_id: str | None = None + mc_session_id: str | None = None + mc_task_id: str | None = None + name: str | None = None + repository: str | None = None + session_sync_level: SessionSyncLevel | None = None + summary: str | None = None + summary_count: int | None = None + updated_at: datetime | None = None + + @staticmethod + def from_dict(obj: Any) -> 'Workspace': + assert isinstance(obj, dict) + id = UUID(obj.get("id")) + branch = from_union([from_str, from_none], obj.get("branch")) + created_at = from_union([from_datetime, from_none], obj.get("created_at")) + cwd = from_union([from_str, from_none], obj.get("cwd")) + git_root = from_union([from_str, from_none], obj.get("git_root")) + host_type = from_union([HostType, from_none], obj.get("host_type")) + mc_last_event_id = from_union([from_str, from_none], obj.get("mc_last_event_id")) + mc_session_id = from_union([from_str, from_none], obj.get("mc_session_id")) + mc_task_id = from_union([from_str, from_none], obj.get("mc_task_id")) + name = from_union([from_str, from_none], obj.get("name")) + repository = from_union([from_str, from_none], obj.get("repository")) + session_sync_level = from_union([SessionSyncLevel, from_none], obj.get("session_sync_level")) + summary = from_union([from_str, from_none], obj.get("summary")) + summary_count = from_union([from_int, from_none], obj.get("summary_count")) + updated_at = from_union([from_datetime, from_none], obj.get("updated_at")) + return Workspace(id, branch, created_at, cwd, git_root, host_type, mc_last_event_id, mc_session_id, mc_task_id, name, repository, session_sync_level, summary, summary_count, updated_at) + + def to_dict(self) -> dict: + result: dict = {} + result["id"] = str(self.id) + if self.branch is not None: + result["branch"] = from_union([from_str, from_none], self.branch) + if self.created_at is not None: + result["created_at"] = from_union([lambda x: x.isoformat(), from_none], self.created_at) + if self.cwd is not None: + result["cwd"] = from_union([from_str, from_none], self.cwd) + if self.git_root is not None: + result["git_root"] = from_union([from_str, from_none], self.git_root) + if self.host_type is not None: + result["host_type"] = from_union([lambda x: to_enum(HostType, x), from_none], self.host_type) + if self.mc_last_event_id is not None: + result["mc_last_event_id"] = from_union([from_str, from_none], self.mc_last_event_id) + if self.mc_session_id is not None: + result["mc_session_id"] = from_union([from_str, from_none], self.mc_session_id) + if self.mc_task_id is not None: + result["mc_task_id"] = from_union([from_str, from_none], self.mc_task_id) + if self.name is not None: + result["name"] = from_union([from_str, from_none], self.name) + if self.repository is not None: + result["repository"] = from_union([from_str, from_none], self.repository) + if self.session_sync_level is not None: + result["session_sync_level"] = from_union([lambda x: to_enum(SessionSyncLevel, x), from_none], self.session_sync_level) + if self.summary is not None: + result["summary"] = from_union([from_str, from_none], self.summary) + if self.summary_count is not None: + result["summary_count"] = from_union([from_int, from_none], self.summary_count) + if self.updated_at is not None: + result["updated_at"] = from_union([lambda x: x.isoformat(), from_none], self.updated_at) + return result + +@dataclass +class WorkspacesGetWorkspaceResult: + workspace: Workspace | None = None + """Current workspace metadata, or null if not available""" + + @staticmethod + def from_dict(obj: Any) -> 'WorkspacesGetWorkspaceResult': + assert isinstance(obj, dict) + workspace = from_union([Workspace.from_dict, from_none], obj.get("workspace")) + return WorkspacesGetWorkspaceResult(workspace) + + def to_dict(self) -> dict: + result: dict = {} + result["workspace"] = from_union([lambda x: to_class(Workspace, x), from_none], self.workspace) + return result + +@dataclass +class WorkspacesListFilesResult: files: list[str] """Relative file paths in the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspaceListFilesResult': + def from_dict(obj: Any) -> 'WorkspacesListFilesResult': assert isinstance(obj, dict) files = from_list(from_str, obj.get("files")) - return WorkspaceListFilesResult(files) + return WorkspacesListFilesResult(files) def to_dict(self) -> dict: result: dict = {} @@ -1189,15 +1317,15 @@ def to_dict(self) -> dict: return result @dataclass -class WorkspaceReadFileResult: +class WorkspacesReadFileResult: content: str """File content as a UTF-8 string""" @staticmethod - def from_dict(obj: Any) -> 'WorkspaceReadFileResult': + def from_dict(obj: Any) -> 'WorkspacesReadFileResult': assert isinstance(obj, dict) content = from_str(obj.get("content")) - return WorkspaceReadFileResult(content) + return WorkspacesReadFileResult(content) def to_dict(self) -> dict: result: dict = {} @@ -1205,15 +1333,15 @@ def to_dict(self) -> dict: return result @dataclass -class WorkspaceReadFileRequest: +class WorkspacesReadFileRequest: path: str """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspaceReadFileRequest': + def from_dict(obj: Any) -> 'WorkspacesReadFileRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) - return WorkspaceReadFileRequest(path) + return WorkspacesReadFileRequest(path) def to_dict(self) -> dict: result: dict = {} @@ -1221,7 +1349,7 @@ def to_dict(self) -> dict: return result @dataclass -class WorkspaceCreateFileRequest: +class WorkspacesCreateFileRequest: content: str """File content to write as a UTF-8 string""" @@ -1229,11 +1357,11 @@ class WorkspaceCreateFileRequest: """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspaceCreateFileRequest': + def from_dict(obj: Any) -> 'WorkspacesCreateFileRequest': assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) - return WorkspaceCreateFileRequest(content, path) + return WorkspacesCreateFileRequest(content, path) def to_dict(self) -> dict: result: dict = {} @@ -3235,6 +3363,18 @@ def mode_set_request_from_dict(s: Any) -> ModeSetRequest: def mode_set_request_to_dict(x: ModeSetRequest) -> Any: return to_class(ModeSetRequest, x) +def name_get_result_from_dict(s: Any) -> NameGetResult: + return NameGetResult.from_dict(s) + +def name_get_result_to_dict(x: NameGetResult) -> Any: + return to_class(NameGetResult, x) + +def name_set_request_from_dict(s: Any) -> NameSetRequest: + return NameSetRequest.from_dict(s) + +def name_set_request_to_dict(x: NameSetRequest) -> Any: + return to_class(NameSetRequest, x) + def plan_read_result_from_dict(s: Any) -> PlanReadResult: return PlanReadResult.from_dict(s) @@ -3247,29 +3387,35 @@ def plan_update_request_from_dict(s: Any) -> PlanUpdateRequest: def plan_update_request_to_dict(x: PlanUpdateRequest) -> Any: return to_class(PlanUpdateRequest, x) -def workspace_list_files_result_from_dict(s: Any) -> WorkspaceListFilesResult: - return WorkspaceListFilesResult.from_dict(s) +def workspaces_get_workspace_result_from_dict(s: Any) -> WorkspacesGetWorkspaceResult: + return WorkspacesGetWorkspaceResult.from_dict(s) + +def workspaces_get_workspace_result_to_dict(x: WorkspacesGetWorkspaceResult) -> Any: + return to_class(WorkspacesGetWorkspaceResult, x) -def workspace_list_files_result_to_dict(x: WorkspaceListFilesResult) -> Any: - return to_class(WorkspaceListFilesResult, x) +def workspaces_list_files_result_from_dict(s: Any) -> WorkspacesListFilesResult: + return WorkspacesListFilesResult.from_dict(s) -def workspace_read_file_result_from_dict(s: Any) -> WorkspaceReadFileResult: - return WorkspaceReadFileResult.from_dict(s) +def workspaces_list_files_result_to_dict(x: WorkspacesListFilesResult) -> Any: + return to_class(WorkspacesListFilesResult, x) -def workspace_read_file_result_to_dict(x: WorkspaceReadFileResult) -> Any: - return to_class(WorkspaceReadFileResult, x) +def workspaces_read_file_result_from_dict(s: Any) -> WorkspacesReadFileResult: + return WorkspacesReadFileResult.from_dict(s) -def workspace_read_file_request_from_dict(s: Any) -> WorkspaceReadFileRequest: - return WorkspaceReadFileRequest.from_dict(s) +def workspaces_read_file_result_to_dict(x: WorkspacesReadFileResult) -> Any: + return to_class(WorkspacesReadFileResult, x) -def workspace_read_file_request_to_dict(x: WorkspaceReadFileRequest) -> Any: - return to_class(WorkspaceReadFileRequest, x) +def workspaces_read_file_request_from_dict(s: Any) -> WorkspacesReadFileRequest: + return WorkspacesReadFileRequest.from_dict(s) -def workspace_create_file_request_from_dict(s: Any) -> WorkspaceCreateFileRequest: - return WorkspaceCreateFileRequest.from_dict(s) +def workspaces_read_file_request_to_dict(x: WorkspacesReadFileRequest) -> Any: + return to_class(WorkspacesReadFileRequest, x) -def workspace_create_file_request_to_dict(x: WorkspaceCreateFileRequest) -> Any: - return to_class(WorkspaceCreateFileRequest, x) +def workspaces_create_file_request_from_dict(s: Any) -> WorkspacesCreateFileRequest: + return WorkspacesCreateFileRequest.from_dict(s) + +def workspaces_create_file_request_to_dict(x: WorkspacesCreateFileRequest) -> Any: + return to_class(WorkspacesCreateFileRequest, x) def fleet_start_result_from_dict(s: Any) -> FleetStartResult: return FleetStartResult.from_dict(s) @@ -3709,6 +3855,20 @@ async def set(self, params: ModeSetRequest, *, timeout: float | None = None) -> await self._client.request("session.mode.set", params_dict, **_timeout_kwargs(timeout)) +class NameApi: + def __init__(self, client: "JsonRpcClient", session_id: str): + self._client = client + self._session_id = session_id + + async def get(self, *, timeout: float | None = None) -> NameGetResult: + return NameGetResult.from_dict(await self._client.request("session.name.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def set(self, params: NameSetRequest, *, timeout: float | None = None) -> None: + params_dict = {k: v for k, v in params.to_dict().items() if v is not None} + params_dict["sessionId"] = self._session_id + await self._client.request("session.name.set", params_dict, **_timeout_kwargs(timeout)) + + class PlanApi: def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client @@ -3726,23 +3886,26 @@ async def delete(self, *, timeout: float | None = None) -> None: await self._client.request("session.plan.delete", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) -class WorkspaceApi: +class WorkspacesApi: def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def list_files(self, *, timeout: float | None = None) -> WorkspaceListFilesResult: - return WorkspaceListFilesResult.from_dict(await self._client.request("session.workspace.listFiles", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + async def get_workspace(self, *, timeout: float | None = None) -> WorkspacesGetWorkspaceResult: + return WorkspacesGetWorkspaceResult.from_dict(await self._client.request("session.workspaces.getWorkspace", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def list_files(self, *, timeout: float | None = None) -> WorkspacesListFilesResult: + return WorkspacesListFilesResult.from_dict(await self._client.request("session.workspaces.listFiles", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - async def read_file(self, params: WorkspaceReadFileRequest, *, timeout: float | None = None) -> WorkspaceReadFileResult: + async def read_file(self, params: WorkspacesReadFileRequest, *, timeout: float | None = None) -> WorkspacesReadFileResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return WorkspaceReadFileResult.from_dict(await self._client.request("session.workspace.readFile", params_dict, **_timeout_kwargs(timeout))) + return WorkspacesReadFileResult.from_dict(await self._client.request("session.workspaces.readFile", params_dict, **_timeout_kwargs(timeout))) - async def create_file(self, params: WorkspaceCreateFileRequest, *, timeout: float | None = None) -> None: + async def create_file(self, params: WorkspacesCreateFileRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request("session.workspace.createFile", params_dict, **_timeout_kwargs(timeout)) + await self._client.request("session.workspaces.createFile", params_dict, **_timeout_kwargs(timeout)) # Experimental: this API group is experimental and may change or be removed. @@ -3957,8 +4120,9 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id self.model = ModelApi(client, session_id) self.mode = ModeApi(client, session_id) + self.name = NameApi(client, session_id) self.plan = PlanApi(client, session_id) - self.workspace = WorkspaceApi(client, session_id) + self.workspaces = WorkspacesApi(client, session_id) self.fleet = FleetApi(client, session_id) self.agent = AgentApi(client, session_id) self.skills = SkillsApi(client, session_id) diff --git a/test/harness/package-lock.json b/test/harness/package-lock.json index 691d66bf9..ba4ed7d10 100644 --- a/test/harness/package-lock.json +++ b/test/harness/package-lock.json @@ -9,7 +9,7 @@ "version": "1.0.0", "license": "ISC", "devDependencies": { - "@github/copilot": "^1.0.22", + "@github/copilot": "^1.0.26", "@modelcontextprotocol/sdk": "^1.26.0", "@types/node": "^25.3.3", "openai": "^6.17.0", @@ -462,27 +462,27 @@ } }, "node_modules/@github/copilot": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot/-/copilot-1.0.22.tgz", - "integrity": "sha512-BR9oTJ1tQ51RV81xcxmlZe0zB3Tf8i/vFsKSTm2f5wRLJgtuVl2LgaFStoI/peTFcmgtZbhrqsnWTu5GkEPK5Q==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot/-/copilot-1.0.26.tgz", + "integrity": "sha512-F7P6yimFzjvWxOF/A0F6k//vcpSVcVusQjaybb3IKyrEDhnd/LOv2tD+x6W0IoxCftGDDhkzBA2aon3rL9lPhQ==", "dev": true, "license": "SEE LICENSE IN LICENSE.md", "bin": { "copilot": "npm-loader.js" }, "optionalDependencies": { - "@github/copilot-darwin-arm64": "1.0.22", - "@github/copilot-darwin-x64": "1.0.22", - "@github/copilot-linux-arm64": "1.0.22", - "@github/copilot-linux-x64": "1.0.22", - "@github/copilot-win32-arm64": "1.0.22", - "@github/copilot-win32-x64": "1.0.22" + "@github/copilot-darwin-arm64": "1.0.26", + "@github/copilot-darwin-x64": "1.0.26", + "@github/copilot-linux-arm64": "1.0.26", + "@github/copilot-linux-x64": "1.0.26", + "@github/copilot-win32-arm64": "1.0.26", + "@github/copilot-win32-x64": "1.0.26" } }, "node_modules/@github/copilot-darwin-arm64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-darwin-arm64/-/copilot-darwin-arm64-1.0.22.tgz", - "integrity": "sha512-cK42uX+oz46Cjsb7z+rdPw+DIGczfVSFWlc1WDcdVlwBW4cEfV0pzFXExpN1r1z179TFgAaVMbhkgLqhOZ/PeQ==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-darwin-arm64/-/copilot-darwin-arm64-1.0.26.tgz", + "integrity": "sha512-eV+jDMj4vnjdGcG+c4zg11zZKVAp94Hm4sK4f9LnyWw8MumTfS5F2Yyse9zt7A3oGlegyczmJopKwuwZbQd4ww==", "cpu": [ "arm64" ], @@ -497,9 +497,9 @@ } }, "node_modules/@github/copilot-darwin-x64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-darwin-x64/-/copilot-darwin-x64-1.0.22.tgz", - "integrity": "sha512-Pmw0ipF+yeLbP6JctsEoMS2LUCpVdC2r557BnCoe48BN8lO8i9JLnkpuDDrJ1AZuCk1VjnujFKEQywOOdfVlpA==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-darwin-x64/-/copilot-darwin-x64-1.0.26.tgz", + "integrity": "sha512-2AAgu19F3scDlYhsiHxCn0cz4ZkINq8gxnqW0an8VQn6p15lDcah6PqHw+RJ+12qiYX5L5NNACty9UOkIK7Kzg==", "cpu": [ "x64" ], @@ -514,9 +514,9 @@ } }, "node_modules/@github/copilot-linux-arm64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-linux-arm64/-/copilot-linux-arm64-1.0.22.tgz", - "integrity": "sha512-WVgG67VmZgHoD7GMlkTxEVe1qK8k9Ek9A02/Da7obpsDdtBInt3nJTwBEgm4cNDM4XaenQH17/jmwVtTwXB6lw==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-linux-arm64/-/copilot-linux-arm64-1.0.26.tgz", + "integrity": "sha512-SnM7+TGAZ/i9dim5FfHM7+ii01hdpHJzzh8vnnA1Fa7RPFJaQ2KTOdTDJFgfv6e/jLhKXZEelYIidgCA3vSQCQ==", "cpu": [ "arm64" ], @@ -531,9 +531,9 @@ } }, "node_modules/@github/copilot-linux-x64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-linux-x64/-/copilot-linux-x64-1.0.22.tgz", - "integrity": "sha512-XRkHVFmdC7FMrczXOdPjbNKiknMr13asKtwJoErJO/Xdy4cmzKQHSvNsBk8VNrr7oyWrUcB1F6mbIxb2LFxPOw==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-linux-x64/-/copilot-linux-x64-1.0.26.tgz", + "integrity": "sha512-x76vcwVbi0j03hFMhiQs+Eqefd9Xmc4qJoaj44YA2VsJuDbZw2Yv7ZBq7Vyxd/shJwJZjaKv36MHcx5bVUMBJQ==", "cpu": [ "x64" ], @@ -548,9 +548,9 @@ } }, "node_modules/@github/copilot-win32-arm64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-win32-arm64/-/copilot-win32-arm64-1.0.22.tgz", - "integrity": "sha512-Ao6gv1f2ZV+HVlkB1MV7YFdCuaB3NcFCnNu0a6/WLl2ypsfP1vWosPPkIB32jQJeBkT9ku3exOZLRj+XC0P3Mg==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-win32-arm64/-/copilot-win32-arm64-1.0.26.tgz", + "integrity": "sha512-enVRcy7W9RD1bwYkF+mcxR+biXsG/X5m46XBaD0opvfDeiBHceDnI8hEI0O1A5PYvRo88AZFvDEmEW3Gdj6+rQ==", "cpu": [ "arm64" ], @@ -565,9 +565,9 @@ } }, "node_modules/@github/copilot-win32-x64": { - "version": "1.0.22", - "resolved": "https://registry.npmjs.org/@github/copilot-win32-x64/-/copilot-win32-x64-1.0.22.tgz", - "integrity": "sha512-EppcL+3TpxC+X/eQEIYtkN0PaA3/cvtI9UJqldLIkKDPXNYk/0mw877Ru9ypRcBWBWokDN6iKIWk5IxYH+JIvg==", + "version": "1.0.26", + "resolved": "https://registry.npmjs.org/@github/copilot-win32-x64/-/copilot-win32-x64-1.0.26.tgz", + "integrity": "sha512-DpJF6C1x4+sYIXUx5+vWCu6cFAbD2YlrXQ/BRttf2MMdc0DHwdgJxrttBBF2qCvmpfzjSE8cr5G0kt5EUk7FGw==", "cpu": [ "x64" ], diff --git a/test/harness/package.json b/test/harness/package.json index def9f09cf..527c036b7 100644 --- a/test/harness/package.json +++ b/test/harness/package.json @@ -11,7 +11,7 @@ "test": "vitest run" }, "devDependencies": { - "@github/copilot": "^1.0.22", + "@github/copilot": "^1.0.26", "@modelcontextprotocol/sdk": "^1.26.0", "@types/node": "^25.3.3", "openai": "^6.17.0", From 4013d4a30086f88cdf53aa73e48d46db4a165ea0 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 14 Apr 2026 22:20:13 +0000 Subject: [PATCH 2/5] =?UTF-8?q?Fix=20build:=20update=20.NET=20test=20Works?= =?UTF-8?q?pace=E2=86=92Workspaces,=20fix=20Python=20rpc.py=20lint=20error?= =?UTF-8?q?s?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Agent-Logs-Url: https://github.com/github/copilot-sdk/sessions/89ca7d21-b99f-493f-9155-4ba940ad7293 Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> --- dotnet/test/RpcTests.cs | 12 +- python/copilot/generated/rpc.py | 1518 +++++++++++++++++++++++++------ 2 files changed, 1221 insertions(+), 309 deletions(-) diff --git a/dotnet/test/RpcTests.cs b/dotnet/test/RpcTests.cs index a978a5f3f..4d247a6c9 100644 --- a/dotnet/test/RpcTests.cs +++ b/dotnet/test/RpcTests.cs @@ -135,25 +135,25 @@ public async Task Should_Create_List_And_Read_Workspace_Files() var session = await CreateSessionAsync(); // Initially no files - var initialFiles = await session.Rpc.Workspace.ListFilesAsync(); + var initialFiles = await session.Rpc.Workspaces.ListFilesAsync(); Assert.Empty(initialFiles.Files); // Create a file var fileContent = "Hello, workspace!"; - await session.Rpc.Workspace.CreateFileAsync("test.txt", fileContent); + await session.Rpc.Workspaces.CreateFileAsync("test.txt", fileContent); // List files - var afterCreate = await session.Rpc.Workspace.ListFilesAsync(); + var afterCreate = await session.Rpc.Workspaces.ListFilesAsync(); Assert.Contains("test.txt", afterCreate.Files); // Read file - var readResult = await session.Rpc.Workspace.ReadFileAsync("test.txt"); + var readResult = await session.Rpc.Workspaces.ReadFileAsync("test.txt"); Assert.Equal(fileContent, readResult.Content); // Create nested file - await session.Rpc.Workspace.CreateFileAsync("subdir/nested.txt", "Nested content"); + await session.Rpc.Workspaces.CreateFileAsync("subdir/nested.txt", "Nested content"); - var afterNested = await session.Rpc.Workspace.ListFilesAsync(); + var afterNested = await session.Rpc.Workspaces.ListFilesAsync(); Assert.Contains("test.txt", afterNested.Files); Assert.Contains(afterNested.Files, f => f.Contains("nested.txt")); } diff --git a/python/copilot/generated/rpc.py b/python/copilot/generated/rpc.py index 19a2660d5..d1f4338ef 100644 --- a/python/copilot/generated/rpc.py +++ b/python/copilot/generated/rpc.py @@ -10,31 +10,32 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Protocol - - -from dataclasses import dataclass -from typing import Any, TypeVar, Callable, cast from datetime import datetime from enum import Enum +from typing import Any, Protocol, TypeVar, cast from uuid import UUID + import dateutil.parser T = TypeVar("T") EnumT = TypeVar("EnumT", bound=Enum) + def from_str(x: Any) -> str: assert isinstance(x, str) return x + def from_int(x: Any) -> int: assert isinstance(x, int) and not isinstance(x, bool) return x + def from_none(x: Any) -> Any: assert x is None return x + def from_union(fs, x): for f in fs: try: @@ -43,37 +44,46 @@ def from_union(fs, x): pass assert False + def from_float(x: Any) -> float: assert isinstance(x, (float, int)) and not isinstance(x, bool) return float(x) + def to_float(x: Any) -> float: assert isinstance(x, (int, float)) return x + def from_list(f: Callable[[Any], T], x: Any) -> list[T]: assert isinstance(x, list) return [f(y) for y in x] + def to_class(c: type[T], x: Any) -> dict: assert isinstance(x, c) return cast(Any, x).to_dict() + def from_bool(x: Any) -> bool: assert isinstance(x, bool) return x + def from_dict(f: Callable[[Any], T], x: Any) -> dict[str, T]: assert isinstance(x, dict) - return { k: f(v) for (k, v) in x.items() } + return {k: f(v) for (k, v) in x.items()} + def from_datetime(x: Any) -> datetime: return dateutil.parser.parse(x) + def to_enum(c: type[EnumT], x: Any) -> EnumT: assert isinstance(x, c) return x.value + @dataclass class PingResult: message: str @@ -86,7 +96,7 @@ class PingResult: """Server timestamp in milliseconds""" @staticmethod - def from_dict(obj: Any) -> 'PingResult': + def from_dict(obj: Any) -> "PingResult": assert isinstance(obj, dict) message = from_str(obj.get("message")) protocol_version = from_int(obj.get("protocolVersion")) @@ -100,13 +110,14 @@ def to_dict(self) -> dict: result["timestamp"] = from_int(self.timestamp) return result + @dataclass class PingRequest: message: str | None = None """Optional message to echo back""" @staticmethod - def from_dict(obj: Any) -> 'PingRequest': + def from_dict(obj: Any) -> "PingRequest": assert isinstance(obj, dict) message = from_union([from_str, from_none], obj.get("message")) return PingRequest(message) @@ -117,6 +128,7 @@ def to_dict(self) -> dict: result["message"] = from_union([from_str, from_none], self.message) return result + @dataclass class ModelBilling: """Billing information""" @@ -125,7 +137,7 @@ class ModelBilling: """Billing cost multiplier relative to the base rate""" @staticmethod - def from_dict(obj: Any) -> 'ModelBilling': + def from_dict(obj: Any) -> "ModelBilling": assert isinstance(obj, dict) multiplier = from_float(obj.get("multiplier")) return ModelBilling(multiplier) @@ -135,6 +147,7 @@ def to_dict(self) -> dict: result["multiplier"] = to_float(self.multiplier) return result + @dataclass class ModelCapabilitiesLimitsVision: """Vision-specific limits""" @@ -149,12 +162,14 @@ class ModelCapabilitiesLimitsVision: """MIME types the model accepts""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesLimitsVision': + def from_dict(obj: Any) -> "ModelCapabilitiesLimitsVision": assert isinstance(obj, dict) max_prompt_image_size = from_int(obj.get("max_prompt_image_size")) max_prompt_images = from_int(obj.get("max_prompt_images")) supported_media_types = from_list(from_str, obj.get("supported_media_types")) - return ModelCapabilitiesLimitsVision(max_prompt_image_size, max_prompt_images, supported_media_types) + return ModelCapabilitiesLimitsVision( + max_prompt_image_size, max_prompt_images, supported_media_types + ) def to_dict(self) -> dict: result: dict = {} @@ -163,6 +178,7 @@ def to_dict(self) -> dict: result["supported_media_types"] = from_list(from_str, self.supported_media_types) return result + @dataclass class ModelCapabilitiesLimits: """Token limits for prompts, outputs, and context window""" @@ -180,13 +196,15 @@ class ModelCapabilitiesLimits: """Vision-specific limits""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesLimits': + def from_dict(obj: Any) -> "ModelCapabilitiesLimits": assert isinstance(obj, dict) max_context_window_tokens = from_int(obj.get("max_context_window_tokens")) max_output_tokens = from_union([from_int, from_none], obj.get("max_output_tokens")) max_prompt_tokens = from_union([from_int, from_none], obj.get("max_prompt_tokens")) vision = from_union([ModelCapabilitiesLimitsVision.from_dict, from_none], obj.get("vision")) - return ModelCapabilitiesLimits(max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision) + return ModelCapabilitiesLimits( + max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision + ) def to_dict(self) -> dict: result: dict = {} @@ -196,9 +214,12 @@ def to_dict(self) -> dict: if self.max_prompt_tokens is not None: result["max_prompt_tokens"] = from_union([from_int, from_none], self.max_prompt_tokens) if self.vision is not None: - result["vision"] = from_union([lambda x: to_class(ModelCapabilitiesLimitsVision, x), from_none], self.vision) + result["vision"] = from_union( + [lambda x: to_class(ModelCapabilitiesLimitsVision, x), from_none], self.vision + ) return result + @dataclass class ModelCapabilitiesSupports: """Feature flags indicating what the model supports""" @@ -210,7 +231,7 @@ class ModelCapabilitiesSupports: """Whether this model supports vision/image input""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesSupports': + def from_dict(obj: Any) -> "ModelCapabilitiesSupports": assert isinstance(obj, dict) reasoning_effort = from_union([from_bool, from_none], obj.get("reasoningEffort")) vision = from_union([from_bool, from_none], obj.get("vision")) @@ -224,6 +245,7 @@ def to_dict(self) -> dict: result["vision"] = from_union([from_bool, from_none], self.vision) return result + @dataclass class ModelCapabilities: """Model capabilities and limits""" @@ -235,7 +257,7 @@ class ModelCapabilities: """Feature flags indicating what the model supports""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilities': + def from_dict(obj: Any) -> "ModelCapabilities": assert isinstance(obj, dict) limits = ModelCapabilitiesLimits.from_dict(obj.get("limits")) supports = ModelCapabilitiesSupports.from_dict(obj.get("supports")) @@ -247,6 +269,7 @@ def to_dict(self) -> dict: result["supports"] = to_class(ModelCapabilitiesSupports, self.supports) return result + @dataclass class ModelPolicy: """Policy state (if applicable)""" @@ -258,7 +281,7 @@ class ModelPolicy: """Usage terms or conditions for this model""" @staticmethod - def from_dict(obj: Any) -> 'ModelPolicy': + def from_dict(obj: Any) -> "ModelPolicy": assert isinstance(obj, dict) state = from_str(obj.get("state")) terms = from_str(obj.get("terms")) @@ -270,6 +293,7 @@ def to_dict(self) -> dict: result["terms"] = from_str(self.terms) return result + @dataclass class Model: capabilities: ModelCapabilities @@ -294,16 +318,28 @@ class Model: """Supported reasoning effort levels (only present if model supports reasoning effort)""" @staticmethod - def from_dict(obj: Any) -> 'Model': + def from_dict(obj: Any) -> "Model": assert isinstance(obj, dict) capabilities = ModelCapabilities.from_dict(obj.get("capabilities")) id = from_str(obj.get("id")) name = from_str(obj.get("name")) billing = from_union([ModelBilling.from_dict, from_none], obj.get("billing")) - default_reasoning_effort = from_union([from_str, from_none], obj.get("defaultReasoningEffort")) + default_reasoning_effort = from_union( + [from_str, from_none], obj.get("defaultReasoningEffort") + ) policy = from_union([ModelPolicy.from_dict, from_none], obj.get("policy")) - supported_reasoning_efforts = from_union([lambda x: from_list(from_str, x), from_none], obj.get("supportedReasoningEfforts")) - return Model(capabilities, id, name, billing, default_reasoning_effort, policy, supported_reasoning_efforts) + supported_reasoning_efforts = from_union( + [lambda x: from_list(from_str, x), from_none], obj.get("supportedReasoningEfforts") + ) + return Model( + capabilities, + id, + name, + billing, + default_reasoning_effort, + policy, + supported_reasoning_efforts, + ) def to_dict(self) -> dict: result: dict = {} @@ -311,22 +347,31 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) result["name"] = from_str(self.name) if self.billing is not None: - result["billing"] = from_union([lambda x: to_class(ModelBilling, x), from_none], self.billing) + result["billing"] = from_union( + [lambda x: to_class(ModelBilling, x), from_none], self.billing + ) if self.default_reasoning_effort is not None: - result["defaultReasoningEffort"] = from_union([from_str, from_none], self.default_reasoning_effort) + result["defaultReasoningEffort"] = from_union( + [from_str, from_none], self.default_reasoning_effort + ) if self.policy is not None: - result["policy"] = from_union([lambda x: to_class(ModelPolicy, x), from_none], self.policy) + result["policy"] = from_union( + [lambda x: to_class(ModelPolicy, x), from_none], self.policy + ) if self.supported_reasoning_efforts is not None: - result["supportedReasoningEfforts"] = from_union([lambda x: from_list(from_str, x), from_none], self.supported_reasoning_efforts) + result["supportedReasoningEfforts"] = from_union( + [lambda x: from_list(from_str, x), from_none], self.supported_reasoning_efforts + ) return result + @dataclass class ModelList: models: list[Model] """List of available models with full metadata""" @staticmethod - def from_dict(obj: Any) -> 'ModelList': + def from_dict(obj: Any) -> "ModelList": assert isinstance(obj, dict) models = from_list(Model.from_dict, obj.get("models")) return ModelList(models) @@ -336,6 +381,7 @@ def to_dict(self) -> dict: result["models"] = from_list(lambda x: to_class(Model, x), self.models) return result + @dataclass class Tool: description: str @@ -355,13 +401,15 @@ class Tool: """JSON Schema for the tool's input parameters""" @staticmethod - def from_dict(obj: Any) -> 'Tool': + def from_dict(obj: Any) -> "Tool": assert isinstance(obj, dict) description = from_str(obj.get("description")) name = from_str(obj.get("name")) instructions = from_union([from_str, from_none], obj.get("instructions")) namespaced_name = from_union([from_str, from_none], obj.get("namespacedName")) - parameters = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("parameters")) + parameters = from_union( + [lambda x: from_dict(lambda x: x, x), from_none], obj.get("parameters") + ) return Tool(description, name, instructions, namespaced_name, parameters) def to_dict(self) -> dict: @@ -373,16 +421,19 @@ def to_dict(self) -> dict: if self.namespaced_name is not None: result["namespacedName"] = from_union([from_str, from_none], self.namespaced_name) if self.parameters is not None: - result["parameters"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.parameters) + result["parameters"] = from_union( + [lambda x: from_dict(lambda x: x, x), from_none], self.parameters + ) return result + @dataclass class ToolList: tools: list[Tool] """List of available built-in tools with metadata""" @staticmethod - def from_dict(obj: Any) -> 'ToolList': + def from_dict(obj: Any) -> "ToolList": assert isinstance(obj, dict) tools = from_list(Tool.from_dict, obj.get("tools")) return ToolList(tools) @@ -392,6 +443,7 @@ def to_dict(self) -> dict: result["tools"] = from_list(lambda x: to_class(Tool, x), self.tools) return result + @dataclass class ToolsListRequest: model: str | None = None @@ -400,7 +452,7 @@ class ToolsListRequest: """ @staticmethod - def from_dict(obj: Any) -> 'ToolsListRequest': + def from_dict(obj: Any) -> "ToolsListRequest": assert isinstance(obj, dict) model = from_union([from_str, from_none], obj.get("model")) return ToolsListRequest(model) @@ -411,6 +463,7 @@ def to_dict(self) -> dict: result["model"] = from_union([from_str, from_none], self.model) return result + @dataclass class AccountQuotaSnapshot: entitlement_requests: int @@ -432,54 +485,71 @@ class AccountQuotaSnapshot: """Date when the quota resets (ISO 8601)""" @staticmethod - def from_dict(obj: Any) -> 'AccountQuotaSnapshot': + def from_dict(obj: Any) -> "AccountQuotaSnapshot": assert isinstance(obj, dict) entitlement_requests = from_int(obj.get("entitlementRequests")) overage = from_int(obj.get("overage")) - overage_allowed_with_exhausted_quota = from_bool(obj.get("overageAllowedWithExhaustedQuota")) + overage_allowed_with_exhausted_quota = from_bool( + obj.get("overageAllowedWithExhaustedQuota") + ) remaining_percentage = from_float(obj.get("remainingPercentage")) used_requests = from_int(obj.get("usedRequests")) reset_date = from_union([from_datetime, from_none], obj.get("resetDate")) - return AccountQuotaSnapshot(entitlement_requests, overage, overage_allowed_with_exhausted_quota, remaining_percentage, used_requests, reset_date) + return AccountQuotaSnapshot( + entitlement_requests, + overage, + overage_allowed_with_exhausted_quota, + remaining_percentage, + used_requests, + reset_date, + ) def to_dict(self) -> dict: result: dict = {} result["entitlementRequests"] = from_int(self.entitlement_requests) result["overage"] = from_int(self.overage) - result["overageAllowedWithExhaustedQuota"] = from_bool(self.overage_allowed_with_exhausted_quota) + result["overageAllowedWithExhaustedQuota"] = from_bool( + self.overage_allowed_with_exhausted_quota + ) result["remainingPercentage"] = to_float(self.remaining_percentage) result["usedRequests"] = from_int(self.used_requests) if self.reset_date is not None: result["resetDate"] = from_union([lambda x: x.isoformat(), from_none], self.reset_date) return result + @dataclass class AccountGetQuotaResult: quota_snapshots: dict[str, AccountQuotaSnapshot] """Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)""" @staticmethod - def from_dict(obj: Any) -> 'AccountGetQuotaResult': + def from_dict(obj: Any) -> "AccountGetQuotaResult": assert isinstance(obj, dict) quota_snapshots = from_dict(AccountQuotaSnapshot.from_dict, obj.get("quotaSnapshots")) return AccountGetQuotaResult(quota_snapshots) def to_dict(self) -> dict: result: dict = {} - result["quotaSnapshots"] = from_dict(lambda x: to_class(AccountQuotaSnapshot, x), self.quota_snapshots) + result["quotaSnapshots"] = from_dict( + lambda x: to_class(AccountQuotaSnapshot, x), self.quota_snapshots + ) return result + class MCPConfigFilterMappingString(Enum): HIDDEN_CHARACTERS = "hidden_characters" MARKDOWN = "markdown" NONE = "none" + class MCPConfigType(Enum): HTTP = "http" LOCAL = "local" SSE = "sse" STDIO = "stdio" + @dataclass class MCPConfigServer: """MCP server configuration (local/stdio or remote/http)""" @@ -488,7 +558,9 @@ class MCPConfigServer: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None + filter_mapping: ( + dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None + ) = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -503,13 +575,20 @@ class MCPConfigServer: url: str | None = None @staticmethod - def from_dict(obj: Any) -> 'MCPConfigServer': + def from_dict(obj: Any) -> "MCPConfigServer": assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) + filter_mapping = from_union( + [ + lambda x: from_dict(MCPConfigFilterMappingString, x), + MCPConfigFilterMappingString, + from_none, + ], + obj.get("filterMapping"), + ) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -518,7 +597,21 @@ def from_dict(obj: Any) -> 'MCPConfigServer': oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigServer(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) + return MCPConfigServer( + args, + command, + cwd, + env, + filter_mapping, + is_default_server, + timeout, + tools, + type, + headers, + oauth_client_id, + oauth_public_client, + url, + ) def to_dict(self) -> dict: result: dict = {} @@ -531,7 +624,14 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) + result["filterMapping"] = from_union( + [ + lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), + lambda x: to_enum(MCPConfigFilterMappingString, x), + from_none, + ], + self.filter_mapping, + ) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -541,22 +641,27 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) + result["headers"] = from_union( + [lambda x: from_dict(from_str, x), from_none], self.headers + ) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) + result["oauthPublicClient"] = from_union( + [from_bool, from_none], self.oauth_public_client + ) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result + @dataclass class MCPConfigList: servers: dict[str, MCPConfigServer] """All MCP servers from user config, keyed by name""" @staticmethod - def from_dict(obj: Any) -> 'MCPConfigList': + def from_dict(obj: Any) -> "MCPConfigList": assert isinstance(obj, dict) servers = from_dict(MCPConfigServer.from_dict, obj.get("servers")) return MCPConfigList(servers) @@ -566,6 +671,7 @@ def to_dict(self) -> dict: result["servers"] = from_dict(lambda x: to_class(MCPConfigServer, x), self.servers) return result + @dataclass class MCPConfigAddConfig: """MCP server configuration (local/stdio or remote/http)""" @@ -574,7 +680,9 @@ class MCPConfigAddConfig: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None + filter_mapping: ( + dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None + ) = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -589,13 +697,20 @@ class MCPConfigAddConfig: url: str | None = None @staticmethod - def from_dict(obj: Any) -> 'MCPConfigAddConfig': + def from_dict(obj: Any) -> "MCPConfigAddConfig": assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) + filter_mapping = from_union( + [ + lambda x: from_dict(MCPConfigFilterMappingString, x), + MCPConfigFilterMappingString, + from_none, + ], + obj.get("filterMapping"), + ) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -604,7 +719,21 @@ def from_dict(obj: Any) -> 'MCPConfigAddConfig': oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigAddConfig(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) + return MCPConfigAddConfig( + args, + command, + cwd, + env, + filter_mapping, + is_default_server, + timeout, + tools, + type, + headers, + oauth_client_id, + oauth_public_client, + url, + ) def to_dict(self) -> dict: result: dict = {} @@ -617,7 +746,14 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) + result["filterMapping"] = from_union( + [ + lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), + lambda x: to_enum(MCPConfigFilterMappingString, x), + from_none, + ], + self.filter_mapping, + ) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -627,15 +763,20 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) + result["headers"] = from_union( + [lambda x: from_dict(from_str, x), from_none], self.headers + ) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) + result["oauthPublicClient"] = from_union( + [from_bool, from_none], self.oauth_public_client + ) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result + @dataclass class MCPConfigAddRequest: config: MCPConfigAddConfig @@ -645,7 +786,7 @@ class MCPConfigAddRequest: """Unique name for the MCP server""" @staticmethod - def from_dict(obj: Any) -> 'MCPConfigAddRequest': + def from_dict(obj: Any) -> "MCPConfigAddRequest": assert isinstance(obj, dict) config = MCPConfigAddConfig.from_dict(obj.get("config")) name = from_str(obj.get("name")) @@ -657,6 +798,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + @dataclass class MCPConfigUpdateConfig: """MCP server configuration (local/stdio or remote/http)""" @@ -665,7 +807,9 @@ class MCPConfigUpdateConfig: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None + filter_mapping: ( + dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None + ) = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -680,13 +824,20 @@ class MCPConfigUpdateConfig: url: str | None = None @staticmethod - def from_dict(obj: Any) -> 'MCPConfigUpdateConfig': + def from_dict(obj: Any) -> "MCPConfigUpdateConfig": assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) + filter_mapping = from_union( + [ + lambda x: from_dict(MCPConfigFilterMappingString, x), + MCPConfigFilterMappingString, + from_none, + ], + obj.get("filterMapping"), + ) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -695,7 +846,21 @@ def from_dict(obj: Any) -> 'MCPConfigUpdateConfig': oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigUpdateConfig(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) + return MCPConfigUpdateConfig( + args, + command, + cwd, + env, + filter_mapping, + is_default_server, + timeout, + tools, + type, + headers, + oauth_client_id, + oauth_public_client, + url, + ) def to_dict(self) -> dict: result: dict = {} @@ -708,7 +873,14 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) + result["filterMapping"] = from_union( + [ + lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), + lambda x: to_enum(MCPConfigFilterMappingString, x), + from_none, + ], + self.filter_mapping, + ) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -718,15 +890,20 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) + result["headers"] = from_union( + [lambda x: from_dict(from_str, x), from_none], self.headers + ) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) + result["oauthPublicClient"] = from_union( + [from_bool, from_none], self.oauth_public_client + ) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result + @dataclass class MCPConfigUpdateRequest: config: MCPConfigUpdateConfig @@ -736,7 +913,7 @@ class MCPConfigUpdateRequest: """Name of the MCP server to update""" @staticmethod - def from_dict(obj: Any) -> 'MCPConfigUpdateRequest': + def from_dict(obj: Any) -> "MCPConfigUpdateRequest": assert isinstance(obj, dict) config = MCPConfigUpdateConfig.from_dict(obj.get("config")) name = from_str(obj.get("name")) @@ -748,13 +925,14 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + @dataclass class MCPConfigRemoveRequest: name: str """Name of the MCP server to remove""" @staticmethod - def from_dict(obj: Any) -> 'MCPConfigRemoveRequest': + def from_dict(obj: Any) -> "MCPConfigRemoveRequest": assert isinstance(obj, dict) name = from_str(obj.get("name")) return MCPConfigRemoveRequest(name) @@ -764,16 +942,19 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + class MCPServerSource(Enum): """Configuration source - + Configuration source: user, workspace, plugin, or builtin """ + BUILTIN = "builtin" PLUGIN = "plugin" USER = "user" WORKSPACE = "workspace" + class DiscoveredMCPServerType(Enum): """Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)""" @@ -782,6 +963,7 @@ class DiscoveredMCPServerType(Enum): SSE = "sse" STDIO = "stdio" + @dataclass class DiscoveredMCPServer: enabled: bool @@ -797,7 +979,7 @@ class DiscoveredMCPServer: """Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)""" @staticmethod - def from_dict(obj: Any) -> 'DiscoveredMCPServer': + def from_dict(obj: Any) -> "DiscoveredMCPServer": assert isinstance(obj, dict) enabled = from_bool(obj.get("enabled")) name = from_str(obj.get("name")) @@ -811,16 +993,19 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) result["source"] = to_enum(MCPServerSource, self.source) if self.type is not None: - result["type"] = from_union([lambda x: to_enum(DiscoveredMCPServerType, x), from_none], self.type) + result["type"] = from_union( + [lambda x: to_enum(DiscoveredMCPServerType, x), from_none], self.type + ) return result + @dataclass class MCPDiscoverResult: servers: list[DiscoveredMCPServer] """MCP servers discovered from all sources""" @staticmethod - def from_dict(obj: Any) -> 'MCPDiscoverResult': + def from_dict(obj: Any) -> "MCPDiscoverResult": assert isinstance(obj, dict) servers = from_list(DiscoveredMCPServer.from_dict, obj.get("servers")) return MCPDiscoverResult(servers) @@ -830,13 +1015,14 @@ def to_dict(self) -> dict: result["servers"] = from_list(lambda x: to_class(DiscoveredMCPServer, x), self.servers) return result + @dataclass class MCPDiscoverRequest: working_directory: str | None = None """Working directory used as context for discovery (e.g., plugin resolution)""" @staticmethod - def from_dict(obj: Any) -> 'MCPDiscoverRequest': + def from_dict(obj: Any) -> "MCPDiscoverRequest": assert isinstance(obj, dict) working_directory = from_union([from_str, from_none], obj.get("workingDirectory")) return MCPDiscoverRequest(working_directory) @@ -847,13 +1033,14 @@ def to_dict(self) -> dict: result["workingDirectory"] = from_union([from_str, from_none], self.working_directory) return result + @dataclass class SessionFSSetProviderResult: success: bool """Whether the provider was set successfully""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSSetProviderResult': + def from_dict(obj: Any) -> "SessionFSSetProviderResult": assert isinstance(obj, dict) success = from_bool(obj.get("success")) return SessionFSSetProviderResult(success) @@ -863,12 +1050,14 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result + class SessionFSSetProviderConventions(Enum): """Path conventions used by this filesystem""" POSIX = "posix" WINDOWS = "windows" + @dataclass class SessionFSSetProviderRequest: conventions: SessionFSSetProviderConventions @@ -881,7 +1070,7 @@ class SessionFSSetProviderRequest: """Path within each session's SessionFs where the runtime stores files for that session""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSSetProviderRequest': + def from_dict(obj: Any) -> "SessionFSSetProviderRequest": assert isinstance(obj, dict) conventions = SessionFSSetProviderConventions(obj.get("conventions")) initial_cwd = from_str(obj.get("initialCwd")) @@ -895,6 +1084,7 @@ def to_dict(self) -> dict: result["sessionStatePath"] = from_str(self.session_state_path) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SessionsForkResult: @@ -902,7 +1092,7 @@ class SessionsForkResult: """The new forked session's ID""" @staticmethod - def from_dict(obj: Any) -> 'SessionsForkResult': + def from_dict(obj: Any) -> "SessionsForkResult": assert isinstance(obj, dict) session_id = from_str(obj.get("sessionId")) return SessionsForkResult(session_id) @@ -912,6 +1102,7 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SessionsForkRequest: @@ -924,7 +1115,7 @@ class SessionsForkRequest: """ @staticmethod - def from_dict(obj: Any) -> 'SessionsForkRequest': + def from_dict(obj: Any) -> "SessionsForkRequest": assert isinstance(obj, dict) session_id = from_str(obj.get("sessionId")) to_event_id = from_union([from_str, from_none], obj.get("toEventId")) @@ -937,13 +1128,14 @@ def to_dict(self) -> dict: result["toEventId"] = from_union([from_str, from_none], self.to_event_id) return result + @dataclass class CurrentModel: model_id: str | None = None """Currently active model identifier""" @staticmethod - def from_dict(obj: Any) -> 'CurrentModel': + def from_dict(obj: Any) -> "CurrentModel": assert isinstance(obj, dict) model_id = from_union([from_str, from_none], obj.get("modelId")) return CurrentModel(model_id) @@ -954,13 +1146,14 @@ def to_dict(self) -> dict: result["modelId"] = from_union([from_str, from_none], self.model_id) return result + @dataclass class ModelSwitchToResult: model_id: str | None = None """Currently active model identifier after the switch""" @staticmethod - def from_dict(obj: Any) -> 'ModelSwitchToResult': + def from_dict(obj: Any) -> "ModelSwitchToResult": assert isinstance(obj, dict) model_id = from_union([from_str, from_none], obj.get("modelId")) return ModelSwitchToResult(model_id) @@ -971,6 +1164,7 @@ def to_dict(self) -> dict: result["modelId"] = from_union([from_str, from_none], self.model_id) return result + @dataclass class ModelCapabilitiesOverrideLimitsVision: max_prompt_image_size: int | None = None @@ -983,23 +1177,32 @@ class ModelCapabilitiesOverrideLimitsVision: """MIME types the model accepts""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideLimitsVision': + def from_dict(obj: Any) -> "ModelCapabilitiesOverrideLimitsVision": assert isinstance(obj, dict) max_prompt_image_size = from_union([from_int, from_none], obj.get("max_prompt_image_size")) max_prompt_images = from_union([from_int, from_none], obj.get("max_prompt_images")) - supported_media_types = from_union([lambda x: from_list(from_str, x), from_none], obj.get("supported_media_types")) - return ModelCapabilitiesOverrideLimitsVision(max_prompt_image_size, max_prompt_images, supported_media_types) + supported_media_types = from_union( + [lambda x: from_list(from_str, x), from_none], obj.get("supported_media_types") + ) + return ModelCapabilitiesOverrideLimitsVision( + max_prompt_image_size, max_prompt_images, supported_media_types + ) def to_dict(self) -> dict: result: dict = {} if self.max_prompt_image_size is not None: - result["max_prompt_image_size"] = from_union([from_int, from_none], self.max_prompt_image_size) + result["max_prompt_image_size"] = from_union( + [from_int, from_none], self.max_prompt_image_size + ) if self.max_prompt_images is not None: result["max_prompt_images"] = from_union([from_int, from_none], self.max_prompt_images) if self.supported_media_types is not None: - result["supported_media_types"] = from_union([lambda x: from_list(from_str, x), from_none], self.supported_media_types) + result["supported_media_types"] = from_union( + [lambda x: from_list(from_str, x), from_none], self.supported_media_types + ) return result + @dataclass class ModelCapabilitiesOverrideLimits: """Token limits for prompts, outputs, and context window""" @@ -1012,26 +1215,38 @@ class ModelCapabilitiesOverrideLimits: vision: ModelCapabilitiesOverrideLimitsVision | None = None @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideLimits': + def from_dict(obj: Any) -> "ModelCapabilitiesOverrideLimits": assert isinstance(obj, dict) - max_context_window_tokens = from_union([from_int, from_none], obj.get("max_context_window_tokens")) + max_context_window_tokens = from_union( + [from_int, from_none], obj.get("max_context_window_tokens") + ) max_output_tokens = from_union([from_int, from_none], obj.get("max_output_tokens")) max_prompt_tokens = from_union([from_int, from_none], obj.get("max_prompt_tokens")) - vision = from_union([ModelCapabilitiesOverrideLimitsVision.from_dict, from_none], obj.get("vision")) - return ModelCapabilitiesOverrideLimits(max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision) + vision = from_union( + [ModelCapabilitiesOverrideLimitsVision.from_dict, from_none], obj.get("vision") + ) + return ModelCapabilitiesOverrideLimits( + max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision + ) def to_dict(self) -> dict: result: dict = {} if self.max_context_window_tokens is not None: - result["max_context_window_tokens"] = from_union([from_int, from_none], self.max_context_window_tokens) + result["max_context_window_tokens"] = from_union( + [from_int, from_none], self.max_context_window_tokens + ) if self.max_output_tokens is not None: result["max_output_tokens"] = from_union([from_int, from_none], self.max_output_tokens) if self.max_prompt_tokens is not None: result["max_prompt_tokens"] = from_union([from_int, from_none], self.max_prompt_tokens) if self.vision is not None: - result["vision"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideLimitsVision, x), from_none], self.vision) + result["vision"] = from_union( + [lambda x: to_class(ModelCapabilitiesOverrideLimitsVision, x), from_none], + self.vision, + ) return result + @dataclass class ModelCapabilitiesOverrideSupports: """Feature flags indicating what the model supports""" @@ -1040,7 +1255,7 @@ class ModelCapabilitiesOverrideSupports: vision: bool | None = None @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideSupports': + def from_dict(obj: Any) -> "ModelCapabilitiesOverrideSupports": assert isinstance(obj, dict) reasoning_effort = from_union([from_bool, from_none], obj.get("reasoningEffort")) vision = from_union([from_bool, from_none], obj.get("vision")) @@ -1054,6 +1269,7 @@ def to_dict(self) -> dict: result["vision"] = from_union([from_bool, from_none], self.vision) return result + @dataclass class ModelCapabilitiesOverride: """Override individual model capabilities resolved by the runtime""" @@ -1065,20 +1281,29 @@ class ModelCapabilitiesOverride: """Feature flags indicating what the model supports""" @staticmethod - def from_dict(obj: Any) -> 'ModelCapabilitiesOverride': + def from_dict(obj: Any) -> "ModelCapabilitiesOverride": assert isinstance(obj, dict) - limits = from_union([ModelCapabilitiesOverrideLimits.from_dict, from_none], obj.get("limits")) - supports = from_union([ModelCapabilitiesOverrideSupports.from_dict, from_none], obj.get("supports")) + limits = from_union( + [ModelCapabilitiesOverrideLimits.from_dict, from_none], obj.get("limits") + ) + supports = from_union( + [ModelCapabilitiesOverrideSupports.from_dict, from_none], obj.get("supports") + ) return ModelCapabilitiesOverride(limits, supports) def to_dict(self) -> dict: result: dict = {} if self.limits is not None: - result["limits"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideLimits, x), from_none], self.limits) + result["limits"] = from_union( + [lambda x: to_class(ModelCapabilitiesOverrideLimits, x), from_none], self.limits + ) if self.supports is not None: - result["supports"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideSupports, x), from_none], self.supports) + result["supports"] = from_union( + [lambda x: to_class(ModelCapabilitiesOverrideSupports, x), from_none], self.supports + ) return result + @dataclass class ModelSwitchToRequest: model_id: str @@ -1091,10 +1316,12 @@ class ModelSwitchToRequest: """Reasoning effort level to use for the model""" @staticmethod - def from_dict(obj: Any) -> 'ModelSwitchToRequest': + def from_dict(obj: Any) -> "ModelSwitchToRequest": assert isinstance(obj, dict) model_id = from_str(obj.get("modelId")) - model_capabilities = from_union([ModelCapabilitiesOverride.from_dict, from_none], obj.get("modelCapabilities")) + model_capabilities = from_union( + [ModelCapabilitiesOverride.from_dict, from_none], obj.get("modelCapabilities") + ) reasoning_effort = from_union([from_str, from_none], obj.get("reasoningEffort")) return ModelSwitchToRequest(model_id, model_capabilities, reasoning_effort) @@ -1102,11 +1329,15 @@ def to_dict(self) -> dict: result: dict = {} result["modelId"] = from_str(self.model_id) if self.model_capabilities is not None: - result["modelCapabilities"] = from_union([lambda x: to_class(ModelCapabilitiesOverride, x), from_none], self.model_capabilities) + result["modelCapabilities"] = from_union( + [lambda x: to_class(ModelCapabilitiesOverride, x), from_none], + self.model_capabilities, + ) if self.reasoning_effort is not None: result["reasoningEffort"] = from_union([from_str, from_none], self.reasoning_effort) return result + class SessionMode(Enum): """The agent mode. Valid values: "interactive", "plan", "autopilot".""" @@ -1114,13 +1345,14 @@ class SessionMode(Enum): INTERACTIVE = "interactive" PLAN = "plan" + @dataclass class ModeSetRequest: mode: SessionMode """The agent mode. Valid values: "interactive", "plan", "autopilot".""" @staticmethod - def from_dict(obj: Any) -> 'ModeSetRequest': + def from_dict(obj: Any) -> "ModeSetRequest": assert isinstance(obj, dict) mode = SessionMode(obj.get("mode")) return ModeSetRequest(mode) @@ -1130,13 +1362,14 @@ def to_dict(self) -> dict: result["mode"] = to_enum(SessionMode, self.mode) return result + @dataclass class NameGetResult: name: str | None = None """The session name, falling back to the auto-generated summary, or null if neither exists""" @staticmethod - def from_dict(obj: Any) -> 'NameGetResult': + def from_dict(obj: Any) -> "NameGetResult": assert isinstance(obj, dict) name = from_union([from_none, from_str], obj.get("name")) return NameGetResult(name) @@ -1146,13 +1379,14 @@ def to_dict(self) -> dict: result["name"] = from_union([from_none, from_str], self.name) return result + @dataclass class NameSetRequest: name: str """New session name (1–100 characters, trimmed of leading/trailing whitespace)""" @staticmethod - def from_dict(obj: Any) -> 'NameSetRequest': + def from_dict(obj: Any) -> "NameSetRequest": assert isinstance(obj, dict) name = from_str(obj.get("name")) return NameSetRequest(name) @@ -1162,6 +1396,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + @dataclass class PlanReadResult: exists: bool @@ -1174,7 +1409,7 @@ class PlanReadResult: """Absolute file path of the plan file, or null if workspace is not enabled""" @staticmethod - def from_dict(obj: Any) -> 'PlanReadResult': + def from_dict(obj: Any) -> "PlanReadResult": assert isinstance(obj, dict) exists = from_bool(obj.get("exists")) content = from_union([from_none, from_str], obj.get("content")) @@ -1188,13 +1423,14 @@ def to_dict(self) -> dict: result["path"] = from_union([from_none, from_str], self.path) return result + @dataclass class PlanUpdateRequest: content: str """The new content for the plan file""" @staticmethod - def from_dict(obj: Any) -> 'PlanUpdateRequest': + def from_dict(obj: Any) -> "PlanUpdateRequest": assert isinstance(obj, dict) content = from_str(obj.get("content")) return PlanUpdateRequest(content) @@ -1204,15 +1440,18 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result + class HostType(Enum): ADO = "ado" GITHUB = "github" + class SessionSyncLevel(Enum): LOCAL = "local" REPO_AND_USER = "repo_and_user" USER = "user" + @dataclass class Workspace: id: UUID @@ -1232,7 +1471,7 @@ class Workspace: updated_at: datetime | None = None @staticmethod - def from_dict(obj: Any) -> 'Workspace': + def from_dict(obj: Any) -> "Workspace": assert isinstance(obj, dict) id = UUID(obj.get("id")) branch = from_union([from_str, from_none], obj.get("branch")) @@ -1245,11 +1484,29 @@ def from_dict(obj: Any) -> 'Workspace': mc_task_id = from_union([from_str, from_none], obj.get("mc_task_id")) name = from_union([from_str, from_none], obj.get("name")) repository = from_union([from_str, from_none], obj.get("repository")) - session_sync_level = from_union([SessionSyncLevel, from_none], obj.get("session_sync_level")) + session_sync_level = from_union( + [SessionSyncLevel, from_none], obj.get("session_sync_level") + ) summary = from_union([from_str, from_none], obj.get("summary")) summary_count = from_union([from_int, from_none], obj.get("summary_count")) updated_at = from_union([from_datetime, from_none], obj.get("updated_at")) - return Workspace(id, branch, created_at, cwd, git_root, host_type, mc_last_event_id, mc_session_id, mc_task_id, name, repository, session_sync_level, summary, summary_count, updated_at) + return Workspace( + id, + branch, + created_at, + cwd, + git_root, + host_type, + mc_last_event_id, + mc_session_id, + mc_task_id, + name, + repository, + session_sync_level, + summary, + summary_count, + updated_at, + ) def to_dict(self) -> dict: result: dict = {} @@ -1263,7 +1520,9 @@ def to_dict(self) -> dict: if self.git_root is not None: result["git_root"] = from_union([from_str, from_none], self.git_root) if self.host_type is not None: - result["host_type"] = from_union([lambda x: to_enum(HostType, x), from_none], self.host_type) + result["host_type"] = from_union( + [lambda x: to_enum(HostType, x), from_none], self.host_type + ) if self.mc_last_event_id is not None: result["mc_last_event_id"] = from_union([from_str, from_none], self.mc_last_event_id) if self.mc_session_id is not None: @@ -1275,7 +1534,9 @@ def to_dict(self) -> dict: if self.repository is not None: result["repository"] = from_union([from_str, from_none], self.repository) if self.session_sync_level is not None: - result["session_sync_level"] = from_union([lambda x: to_enum(SessionSyncLevel, x), from_none], self.session_sync_level) + result["session_sync_level"] = from_union( + [lambda x: to_enum(SessionSyncLevel, x), from_none], self.session_sync_level + ) if self.summary is not None: result["summary"] = from_union([from_str, from_none], self.summary) if self.summary_count is not None: @@ -1284,29 +1545,33 @@ def to_dict(self) -> dict: result["updated_at"] = from_union([lambda x: x.isoformat(), from_none], self.updated_at) return result + @dataclass class WorkspacesGetWorkspaceResult: workspace: Workspace | None = None """Current workspace metadata, or null if not available""" @staticmethod - def from_dict(obj: Any) -> 'WorkspacesGetWorkspaceResult': + def from_dict(obj: Any) -> "WorkspacesGetWorkspaceResult": assert isinstance(obj, dict) workspace = from_union([Workspace.from_dict, from_none], obj.get("workspace")) return WorkspacesGetWorkspaceResult(workspace) def to_dict(self) -> dict: result: dict = {} - result["workspace"] = from_union([lambda x: to_class(Workspace, x), from_none], self.workspace) + result["workspace"] = from_union( + [lambda x: to_class(Workspace, x), from_none], self.workspace + ) return result + @dataclass class WorkspacesListFilesResult: files: list[str] """Relative file paths in the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspacesListFilesResult': + def from_dict(obj: Any) -> "WorkspacesListFilesResult": assert isinstance(obj, dict) files = from_list(from_str, obj.get("files")) return WorkspacesListFilesResult(files) @@ -1316,13 +1581,14 @@ def to_dict(self) -> dict: result["files"] = from_list(from_str, self.files) return result + @dataclass class WorkspacesReadFileResult: content: str """File content as a UTF-8 string""" @staticmethod - def from_dict(obj: Any) -> 'WorkspacesReadFileResult': + def from_dict(obj: Any) -> "WorkspacesReadFileResult": assert isinstance(obj, dict) content = from_str(obj.get("content")) return WorkspacesReadFileResult(content) @@ -1332,13 +1598,14 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result + @dataclass class WorkspacesReadFileRequest: path: str """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspacesReadFileRequest': + def from_dict(obj: Any) -> "WorkspacesReadFileRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) return WorkspacesReadFileRequest(path) @@ -1348,6 +1615,7 @@ def to_dict(self) -> dict: result["path"] = from_str(self.path) return result + @dataclass class WorkspacesCreateFileRequest: content: str @@ -1357,7 +1625,7 @@ class WorkspacesCreateFileRequest: """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> 'WorkspacesCreateFileRequest': + def from_dict(obj: Any) -> "WorkspacesCreateFileRequest": assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -1369,6 +1637,7 @@ def to_dict(self) -> dict: result["path"] = from_str(self.path) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class FleetStartResult: @@ -1376,7 +1645,7 @@ class FleetStartResult: """Whether fleet mode was successfully activated""" @staticmethod - def from_dict(obj: Any) -> 'FleetStartResult': + def from_dict(obj: Any) -> "FleetStartResult": assert isinstance(obj, dict) started = from_bool(obj.get("started")) return FleetStartResult(started) @@ -1386,6 +1655,7 @@ def to_dict(self) -> dict: result["started"] = from_bool(self.started) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class FleetStartRequest: @@ -1393,7 +1663,7 @@ class FleetStartRequest: """Optional user prompt to combine with fleet instructions""" @staticmethod - def from_dict(obj: Any) -> 'FleetStartRequest': + def from_dict(obj: Any) -> "FleetStartRequest": assert isinstance(obj, dict) prompt = from_union([from_str, from_none], obj.get("prompt")) return FleetStartRequest(prompt) @@ -1404,6 +1674,7 @@ def to_dict(self) -> dict: result["prompt"] = from_union([from_str, from_none], self.prompt) return result + @dataclass class Agent: description: str @@ -1416,7 +1687,7 @@ class Agent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> 'Agent': + def from_dict(obj: Any) -> "Agent": assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1430,6 +1701,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentList: @@ -1437,7 +1709,7 @@ class AgentList: """Available custom agents""" @staticmethod - def from_dict(obj: Any) -> 'AgentList': + def from_dict(obj: Any) -> "AgentList": assert isinstance(obj, dict) agents = from_list(Agent.from_dict, obj.get("agents")) return AgentList(agents) @@ -1447,6 +1719,7 @@ def to_dict(self) -> dict: result["agents"] = from_list(lambda x: to_class(Agent, x), self.agents) return result + @dataclass class AgentGetCurrentResultAgent: description: str @@ -1459,7 +1732,7 @@ class AgentGetCurrentResultAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> 'AgentGetCurrentResultAgent': + def from_dict(obj: Any) -> "AgentGetCurrentResultAgent": assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1473,6 +1746,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentGetCurrentResult: @@ -1480,16 +1754,19 @@ class AgentGetCurrentResult: """Currently selected custom agent, or null if using the default agent""" @staticmethod - def from_dict(obj: Any) -> 'AgentGetCurrentResult': + def from_dict(obj: Any) -> "AgentGetCurrentResult": assert isinstance(obj, dict) agent = from_union([AgentGetCurrentResultAgent.from_dict, from_none], obj.get("agent")) return AgentGetCurrentResult(agent) def to_dict(self) -> dict: result: dict = {} - result["agent"] = from_union([lambda x: to_class(AgentGetCurrentResultAgent, x), from_none], self.agent) + result["agent"] = from_union( + [lambda x: to_class(AgentGetCurrentResultAgent, x), from_none], self.agent + ) return result + @dataclass class AgentSelectAgent: """The newly selected custom agent""" @@ -1504,7 +1781,7 @@ class AgentSelectAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> 'AgentSelectAgent': + def from_dict(obj: Any) -> "AgentSelectAgent": assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1518,6 +1795,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentSelectResult: @@ -1525,7 +1803,7 @@ class AgentSelectResult: """The newly selected custom agent""" @staticmethod - def from_dict(obj: Any) -> 'AgentSelectResult': + def from_dict(obj: Any) -> "AgentSelectResult": assert isinstance(obj, dict) agent = AgentSelectAgent.from_dict(obj.get("agent")) return AgentSelectResult(agent) @@ -1535,6 +1813,7 @@ def to_dict(self) -> dict: result["agent"] = to_class(AgentSelectAgent, self.agent) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentSelectRequest: @@ -1542,7 +1821,7 @@ class AgentSelectRequest: """Name of the custom agent to select""" @staticmethod - def from_dict(obj: Any) -> 'AgentSelectRequest': + def from_dict(obj: Any) -> "AgentSelectRequest": assert isinstance(obj, dict) name = from_str(obj.get("name")) return AgentSelectRequest(name) @@ -1552,6 +1831,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + @dataclass class AgentReloadAgent: description: str @@ -1564,7 +1844,7 @@ class AgentReloadAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> 'AgentReloadAgent': + def from_dict(obj: Any) -> "AgentReloadAgent": assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1578,6 +1858,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentReloadResult: @@ -1585,7 +1866,7 @@ class AgentReloadResult: """Reloaded custom agents""" @staticmethod - def from_dict(obj: Any) -> 'AgentReloadResult': + def from_dict(obj: Any) -> "AgentReloadResult": assert isinstance(obj, dict) agents = from_list(AgentReloadAgent.from_dict, obj.get("agents")) return AgentReloadResult(agents) @@ -1595,6 +1876,7 @@ def to_dict(self) -> dict: result["agents"] = from_list(lambda x: to_class(AgentReloadAgent, x), self.agents) return result + @dataclass class Skill: description: str @@ -1616,7 +1898,7 @@ class Skill: """Absolute path to the skill file""" @staticmethod - def from_dict(obj: Any) -> 'Skill': + def from_dict(obj: Any) -> "Skill": assert isinstance(obj, dict) description = from_str(obj.get("description")) enabled = from_bool(obj.get("enabled")) @@ -1637,6 +1919,7 @@ def to_dict(self) -> dict: result["path"] = from_union([from_str, from_none], self.path) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillList: @@ -1644,7 +1927,7 @@ class SkillList: """Available skills""" @staticmethod - def from_dict(obj: Any) -> 'SkillList': + def from_dict(obj: Any) -> "SkillList": assert isinstance(obj, dict) skills = from_list(Skill.from_dict, obj.get("skills")) return SkillList(skills) @@ -1654,6 +1937,7 @@ def to_dict(self) -> dict: result["skills"] = from_list(lambda x: to_class(Skill, x), self.skills) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillsEnableRequest: @@ -1661,7 +1945,7 @@ class SkillsEnableRequest: """Name of the skill to enable""" @staticmethod - def from_dict(obj: Any) -> 'SkillsEnableRequest': + def from_dict(obj: Any) -> "SkillsEnableRequest": assert isinstance(obj, dict) name = from_str(obj.get("name")) return SkillsEnableRequest(name) @@ -1671,6 +1955,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillsDisableRequest: @@ -1678,7 +1963,7 @@ class SkillsDisableRequest: """Name of the skill to disable""" @staticmethod - def from_dict(obj: Any) -> 'SkillsDisableRequest': + def from_dict(obj: Any) -> "SkillsDisableRequest": assert isinstance(obj, dict) name = from_str(obj.get("name")) return SkillsDisableRequest(name) @@ -1688,6 +1973,7 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result + class MCPServerStatus(Enum): """Connection status: connected, failed, needs-auth, pending, disabled, or not_configured""" @@ -1698,6 +1984,7 @@ class MCPServerStatus(Enum): NOT_CONFIGURED = "not_configured" PENDING = "pending" + @dataclass class MCPServer: name: str @@ -1713,7 +2000,7 @@ class MCPServer: """Configuration source: user, workspace, plugin, or builtin""" @staticmethod - def from_dict(obj: Any) -> 'MCPServer': + def from_dict(obj: Any) -> "MCPServer": assert isinstance(obj, dict) name = from_str(obj.get("name")) status = MCPServerStatus(obj.get("status")) @@ -1728,16 +2015,19 @@ def to_dict(self) -> dict: if self.error is not None: result["error"] = from_union([from_str, from_none], self.error) if self.source is not None: - result["source"] = from_union([lambda x: to_enum(MCPServerSource, x), from_none], self.source) + result["source"] = from_union( + [lambda x: to_enum(MCPServerSource, x), from_none], self.source + ) return result + @dataclass class MCPServerList: servers: list[MCPServer] """Configured MCP servers""" @staticmethod - def from_dict(obj: Any) -> 'MCPServerList': + def from_dict(obj: Any) -> "MCPServerList": assert isinstance(obj, dict) servers = from_list(MCPServer.from_dict, obj.get("servers")) return MCPServerList(servers) @@ -1747,13 +2037,14 @@ def to_dict(self) -> dict: result["servers"] = from_list(lambda x: to_class(MCPServer, x), self.servers) return result + @dataclass class MCPEnableRequest: server_name: str """Name of the MCP server to enable""" @staticmethod - def from_dict(obj: Any) -> 'MCPEnableRequest': + def from_dict(obj: Any) -> "MCPEnableRequest": assert isinstance(obj, dict) server_name = from_str(obj.get("serverName")) return MCPEnableRequest(server_name) @@ -1763,13 +2054,14 @@ def to_dict(self) -> dict: result["serverName"] = from_str(self.server_name) return result + @dataclass class MCPDisableRequest: server_name: str """Name of the MCP server to disable""" @staticmethod - def from_dict(obj: Any) -> 'MCPDisableRequest': + def from_dict(obj: Any) -> "MCPDisableRequest": assert isinstance(obj, dict) server_name = from_str(obj.get("serverName")) return MCPDisableRequest(server_name) @@ -1779,6 +2071,7 @@ def to_dict(self) -> dict: result["serverName"] = from_str(self.server_name) return result + @dataclass class Plugin: enabled: bool @@ -1794,7 +2087,7 @@ class Plugin: """Installed version""" @staticmethod - def from_dict(obj: Any) -> 'Plugin': + def from_dict(obj: Any) -> "Plugin": assert isinstance(obj, dict) enabled = from_bool(obj.get("enabled")) marketplace = from_str(obj.get("marketplace")) @@ -1811,6 +2104,7 @@ def to_dict(self) -> dict: result["version"] = from_union([from_str, from_none], self.version) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class PluginList: @@ -1818,7 +2112,7 @@ class PluginList: """Installed plugins""" @staticmethod - def from_dict(obj: Any) -> 'PluginList': + def from_dict(obj: Any) -> "PluginList": assert isinstance(obj, dict) plugins = from_list(Plugin.from_dict, obj.get("plugins")) return PluginList(plugins) @@ -1828,12 +2122,14 @@ def to_dict(self) -> dict: result["plugins"] = from_list(lambda x: to_class(Plugin, x), self.plugins) return result + class ExtensionSource(Enum): """Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)""" PROJECT = "project" USER = "user" + class ExtensionStatus(Enum): """Current status: running, disabled, failed, or starting""" @@ -1842,6 +2138,7 @@ class ExtensionStatus(Enum): RUNNING = "running" STARTING = "starting" + @dataclass class Extension: id: str @@ -1860,7 +2157,7 @@ class Extension: """Process ID if the extension is running""" @staticmethod - def from_dict(obj: Any) -> 'Extension': + def from_dict(obj: Any) -> "Extension": assert isinstance(obj, dict) id = from_str(obj.get("id")) name = from_str(obj.get("name")) @@ -1879,6 +2176,7 @@ def to_dict(self) -> dict: result["pid"] = from_union([from_int, from_none], self.pid) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionList: @@ -1886,7 +2184,7 @@ class ExtensionList: """Discovered extensions and their current status""" @staticmethod - def from_dict(obj: Any) -> 'ExtensionList': + def from_dict(obj: Any) -> "ExtensionList": assert isinstance(obj, dict) extensions = from_list(Extension.from_dict, obj.get("extensions")) return ExtensionList(extensions) @@ -1896,6 +2194,7 @@ def to_dict(self) -> dict: result["extensions"] = from_list(lambda x: to_class(Extension, x), self.extensions) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionsEnableRequest: @@ -1903,7 +2202,7 @@ class ExtensionsEnableRequest: """Source-qualified extension ID to enable""" @staticmethod - def from_dict(obj: Any) -> 'ExtensionsEnableRequest': + def from_dict(obj: Any) -> "ExtensionsEnableRequest": assert isinstance(obj, dict) id = from_str(obj.get("id")) return ExtensionsEnableRequest(id) @@ -1913,6 +2212,7 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionsDisableRequest: @@ -1920,7 +2220,7 @@ class ExtensionsDisableRequest: """Source-qualified extension ID to disable""" @staticmethod - def from_dict(obj: Any) -> 'ExtensionsDisableRequest': + def from_dict(obj: Any) -> "ExtensionsDisableRequest": assert isinstance(obj, dict) id = from_str(obj.get("id")) return ExtensionsDisableRequest(id) @@ -1930,13 +2230,14 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) return result + @dataclass class HandleToolCallResult: success: bool """Whether the tool call result was handled successfully""" @staticmethod - def from_dict(obj: Any) -> 'HandleToolCallResult': + def from_dict(obj: Any) -> "HandleToolCallResult": assert isinstance(obj, dict) success = from_bool(obj.get("success")) return HandleToolCallResult(success) @@ -1946,6 +2247,7 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result + @dataclass class ToolCallResult: text_result_for_llm: str @@ -1961,12 +2263,14 @@ class ToolCallResult: """Telemetry data from tool execution""" @staticmethod - def from_dict(obj: Any) -> 'ToolCallResult': + def from_dict(obj: Any) -> "ToolCallResult": assert isinstance(obj, dict) text_result_for_llm = from_str(obj.get("textResultForLlm")) error = from_union([from_str, from_none], obj.get("error")) result_type = from_union([from_str, from_none], obj.get("resultType")) - tool_telemetry = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("toolTelemetry")) + tool_telemetry = from_union( + [lambda x: from_dict(lambda x: x, x), from_none], obj.get("toolTelemetry") + ) return ToolCallResult(text_result_for_llm, error, result_type, tool_telemetry) def to_dict(self) -> dict: @@ -1977,9 +2281,12 @@ def to_dict(self) -> dict: if self.result_type is not None: result["resultType"] = from_union([from_str, from_none], self.result_type) if self.tool_telemetry is not None: - result["toolTelemetry"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.tool_telemetry) + result["toolTelemetry"] = from_union( + [lambda x: from_dict(lambda x: x, x), from_none], self.tool_telemetry + ) return result + @dataclass class ToolsHandlePendingToolCallRequest: request_id: str @@ -1992,7 +2299,7 @@ class ToolsHandlePendingToolCallRequest: """Tool call result (string or expanded result object)""" @staticmethod - def from_dict(obj: Any) -> 'ToolsHandlePendingToolCallRequest': + def from_dict(obj: Any) -> "ToolsHandlePendingToolCallRequest": assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) error = from_union([from_str, from_none], obj.get("error")) @@ -2005,16 +2312,19 @@ def to_dict(self) -> dict: if self.error is not None: result["error"] = from_union([from_str, from_none], self.error) if self.result is not None: - result["result"] = from_union([lambda x: to_class(ToolCallResult, x), from_str, from_none], self.result) + result["result"] = from_union( + [lambda x: to_class(ToolCallResult, x), from_str, from_none], self.result + ) return result + @dataclass class CommandsHandlePendingCommandResult: success: bool """Whether the command was handled successfully""" @staticmethod - def from_dict(obj: Any) -> 'CommandsHandlePendingCommandResult': + def from_dict(obj: Any) -> "CommandsHandlePendingCommandResult": assert isinstance(obj, dict) success = from_bool(obj.get("success")) return CommandsHandlePendingCommandResult(success) @@ -2024,6 +2334,7 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result + @dataclass class CommandsHandlePendingCommandRequest: request_id: str @@ -2033,7 +2344,7 @@ class CommandsHandlePendingCommandRequest: """Error message if the command handler failed""" @staticmethod - def from_dict(obj: Any) -> 'CommandsHandlePendingCommandRequest': + def from_dict(obj: Any) -> "CommandsHandlePendingCommandRequest": assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) error = from_union([from_str, from_none], obj.get("error")) @@ -2046,6 +2357,7 @@ def to_dict(self) -> dict: result["error"] = from_union([from_str, from_none], self.error) return result + class UIElicitationResponseAction(Enum): """The user's response: accept (submitted), decline (rejected), or cancel (dismissed)""" @@ -2053,6 +2365,7 @@ class UIElicitationResponseAction(Enum): CANCEL = "cancel" DECLINE = "decline" + @dataclass class UIElicitationResponse: """The elicitation response (accept with form values, decline, or cancel)""" @@ -2064,32 +2377,56 @@ class UIElicitationResponse: """The form values submitted by the user (present when action is 'accept')""" @staticmethod - def from_dict(obj: Any) -> 'UIElicitationResponse': + def from_dict(obj: Any) -> "UIElicitationResponse": assert isinstance(obj, dict) action = UIElicitationResponseAction(obj.get("action")) - content = from_union([lambda x: from_dict(lambda x: from_union([from_float, from_bool, lambda x: from_list(from_str, x), from_str], x), x), from_none], obj.get("content")) + content = from_union( + [ + lambda x: from_dict( + lambda x: from_union( + [from_float, from_bool, lambda x: from_list(from_str, x), from_str], x + ), + x, + ), + from_none, + ], + obj.get("content"), + ) return UIElicitationResponse(action, content) def to_dict(self) -> dict: result: dict = {} result["action"] = to_enum(UIElicitationResponseAction, self.action) if self.content is not None: - result["content"] = from_union([lambda x: from_dict(lambda x: from_union([to_float, from_bool, lambda x: from_list(from_str, x), from_str], x), x), from_none], self.content) + result["content"] = from_union( + [ + lambda x: from_dict( + lambda x: from_union( + [to_float, from_bool, lambda x: from_list(from_str, x), from_str], x + ), + x, + ), + from_none, + ], + self.content, + ) return result + class UIElicitationSchemaPropertyStringFormat(Enum): DATE = "date" DATE_TIME = "date-time" EMAIL = "email" URI = "uri" + @dataclass class UIElicitationArrayAnyOfFieldItemsAnyOf: const: str title: str @staticmethod - def from_dict(obj: Any) -> 'UIElicitationArrayAnyOfFieldItemsAnyOf': + def from_dict(obj: Any) -> "UIElicitationArrayAnyOfFieldItemsAnyOf": assert isinstance(obj, dict) const = from_str(obj.get("const")) title = from_str(obj.get("title")) @@ -2101,9 +2438,11 @@ def to_dict(self) -> dict: result["title"] = from_str(self.title) return result + class ItemsType(Enum): STRING = "string" + @dataclass class UIElicitationArrayFieldItems: enum: list[str] | None = None @@ -2111,11 +2450,14 @@ class UIElicitationArrayFieldItems: any_of: list[UIElicitationArrayAnyOfFieldItemsAnyOf] | None = None @staticmethod - def from_dict(obj: Any) -> 'UIElicitationArrayFieldItems': + def from_dict(obj: Any) -> "UIElicitationArrayFieldItems": assert isinstance(obj, dict) enum = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enum")) type = from_union([ItemsType, from_none], obj.get("type")) - any_of = from_union([lambda x: from_list(UIElicitationArrayAnyOfFieldItemsAnyOf.from_dict, x), from_none], obj.get("anyOf")) + any_of = from_union( + [lambda x: from_list(UIElicitationArrayAnyOfFieldItemsAnyOf.from_dict, x), from_none], + obj.get("anyOf"), + ) return UIElicitationArrayFieldItems(enum, type, any_of) def to_dict(self) -> dict: @@ -2125,16 +2467,25 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(ItemsType, x), from_none], self.type) if self.any_of is not None: - result["anyOf"] = from_union([lambda x: from_list(lambda x: to_class(UIElicitationArrayAnyOfFieldItemsAnyOf, x), x), from_none], self.any_of) + result["anyOf"] = from_union( + [ + lambda x: from_list( + lambda x: to_class(UIElicitationArrayAnyOfFieldItemsAnyOf, x), x + ), + from_none, + ], + self.any_of, + ) return result + @dataclass class UIElicitationStringOneOfFieldOneOf: const: str title: str @staticmethod - def from_dict(obj: Any) -> 'UIElicitationStringOneOfFieldOneOf': + def from_dict(obj: Any) -> "UIElicitationStringOneOfFieldOneOf": assert isinstance(obj, dict) const = from_str(obj.get("const")) title = from_str(obj.get("title")) @@ -2146,6 +2497,7 @@ def to_dict(self) -> dict: result["title"] = from_str(self.title) return result + class UIElicitationSchemaPropertyNumberType(Enum): ARRAY = "array" BOOLEAN = "boolean" @@ -2153,6 +2505,7 @@ class UIElicitationSchemaPropertyNumberType(Enum): NUMBER = "number" STRING = "string" + @dataclass class UIElicitationSchemaProperty: type: UIElicitationSchemaPropertyNumberType @@ -2172,15 +2525,21 @@ class UIElicitationSchemaProperty: minimum: float | None = None @staticmethod - def from_dict(obj: Any) -> 'UIElicitationSchemaProperty': + def from_dict(obj: Any) -> "UIElicitationSchemaProperty": assert isinstance(obj, dict) type = UIElicitationSchemaPropertyNumberType(obj.get("type")) - default = from_union([from_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], obj.get("default")) + default = from_union( + [from_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], + obj.get("default"), + ) description = from_union([from_str, from_none], obj.get("description")) enum = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enum")) enum_names = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enumNames")) title = from_union([from_str, from_none], obj.get("title")) - one_of = from_union([lambda x: from_list(UIElicitationStringOneOfFieldOneOf.from_dict, x), from_none], obj.get("oneOf")) + one_of = from_union( + [lambda x: from_list(UIElicitationStringOneOfFieldOneOf.from_dict, x), from_none], + obj.get("oneOf"), + ) items = from_union([UIElicitationArrayFieldItems.from_dict, from_none], obj.get("items")) max_items = from_union([from_float, from_none], obj.get("maxItems")) min_items = from_union([from_float, from_none], obj.get("minItems")) @@ -2189,31 +2548,65 @@ def from_dict(obj: Any) -> 'UIElicitationSchemaProperty': min_length = from_union([from_float, from_none], obj.get("minLength")) maximum = from_union([from_float, from_none], obj.get("maximum")) minimum = from_union([from_float, from_none], obj.get("minimum")) - return UIElicitationSchemaProperty(type, default, description, enum, enum_names, title, one_of, items, max_items, min_items, format, max_length, min_length, maximum, minimum) + return UIElicitationSchemaProperty( + type, + default, + description, + enum, + enum_names, + title, + one_of, + items, + max_items, + min_items, + format, + max_length, + min_length, + maximum, + minimum, + ) def to_dict(self) -> dict: result: dict = {} result["type"] = to_enum(UIElicitationSchemaPropertyNumberType, self.type) if self.default is not None: - result["default"] = from_union([to_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], self.default) + result["default"] = from_union( + [to_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], + self.default, + ) if self.description is not None: result["description"] = from_union([from_str, from_none], self.description) if self.enum is not None: result["enum"] = from_union([lambda x: from_list(from_str, x), from_none], self.enum) if self.enum_names is not None: - result["enumNames"] = from_union([lambda x: from_list(from_str, x), from_none], self.enum_names) + result["enumNames"] = from_union( + [lambda x: from_list(from_str, x), from_none], self.enum_names + ) if self.title is not None: result["title"] = from_union([from_str, from_none], self.title) if self.one_of is not None: - result["oneOf"] = from_union([lambda x: from_list(lambda x: to_class(UIElicitationStringOneOfFieldOneOf, x), x), from_none], self.one_of) + result["oneOf"] = from_union( + [ + lambda x: from_list( + lambda x: to_class(UIElicitationStringOneOfFieldOneOf, x), x + ), + from_none, + ], + self.one_of, + ) if self.items is not None: - result["items"] = from_union([lambda x: to_class(UIElicitationArrayFieldItems, x), from_none], self.items) + result["items"] = from_union( + [lambda x: to_class(UIElicitationArrayFieldItems, x), from_none], self.items + ) if self.max_items is not None: result["maxItems"] = from_union([to_float, from_none], self.max_items) if self.min_items is not None: result["minItems"] = from_union([to_float, from_none], self.min_items) if self.format is not None: - result["format"] = from_union([lambda x: to_enum(UIElicitationSchemaPropertyStringFormat, x), from_none], self.format) + result["format"] = from_union( + [lambda x: to_enum(UIElicitationSchemaPropertyStringFormat, x), from_none], + self.format, + ) if self.max_length is not None: result["maxLength"] = from_union([to_float, from_none], self.max_length) if self.min_length is not None: @@ -2224,9 +2617,11 @@ def to_dict(self) -> dict: result["minimum"] = from_union([to_float, from_none], self.minimum) return result + class RequestedSchemaType(Enum): OBJECT = "object" + @dataclass class UIElicitationSchema: """JSON Schema describing the form fields to present to the user""" @@ -2241,7 +2636,7 @@ class UIElicitationSchema: """List of required field names""" @staticmethod - def from_dict(obj: Any) -> 'UIElicitationSchema': + def from_dict(obj: Any) -> "UIElicitationSchema": assert isinstance(obj, dict) properties = from_dict(UIElicitationSchemaProperty.from_dict, obj.get("properties")) type = RequestedSchemaType(obj.get("type")) @@ -2250,12 +2645,17 @@ def from_dict(obj: Any) -> 'UIElicitationSchema': def to_dict(self) -> dict: result: dict = {} - result["properties"] = from_dict(lambda x: to_class(UIElicitationSchemaProperty, x), self.properties) + result["properties"] = from_dict( + lambda x: to_class(UIElicitationSchemaProperty, x), self.properties + ) result["type"] = to_enum(RequestedSchemaType, self.type) if self.required is not None: - result["required"] = from_union([lambda x: from_list(from_str, x), from_none], self.required) + result["required"] = from_union( + [lambda x: from_list(from_str, x), from_none], self.required + ) return result + @dataclass class UIElicitationRequest: message: str @@ -2265,7 +2665,7 @@ class UIElicitationRequest: """JSON Schema describing the form fields to present to the user""" @staticmethod - def from_dict(obj: Any) -> 'UIElicitationRequest': + def from_dict(obj: Any) -> "UIElicitationRequest": assert isinstance(obj, dict) message = from_str(obj.get("message")) requested_schema = UIElicitationSchema.from_dict(obj.get("requestedSchema")) @@ -2277,6 +2677,7 @@ def to_dict(self) -> dict: result["requestedSchema"] = to_class(UIElicitationSchema, self.requested_schema) return result + @dataclass class UIElicitationResult: success: bool @@ -2285,7 +2686,7 @@ class UIElicitationResult: """ @staticmethod - def from_dict(obj: Any) -> 'UIElicitationResult': + def from_dict(obj: Any) -> "UIElicitationResult": assert isinstance(obj, dict) success = from_bool(obj.get("success")) return UIElicitationResult(success) @@ -2295,6 +2696,7 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result + @dataclass class UIHandlePendingElicitationRequest: request_id: str @@ -2304,7 +2706,7 @@ class UIHandlePendingElicitationRequest: """The elicitation response (accept with form values, decline, or cancel)""" @staticmethod - def from_dict(obj: Any) -> 'UIHandlePendingElicitationRequest': + def from_dict(obj: Any) -> "UIHandlePendingElicitationRequest": assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) result = UIElicitationResponse.from_dict(obj.get("result")) @@ -2316,13 +2718,14 @@ def to_dict(self) -> dict: result["result"] = to_class(UIElicitationResponse, self.result) return result + @dataclass class PermissionRequestResult: success: bool """Whether the permission request was handled successfully""" @staticmethod - def from_dict(obj: Any) -> 'PermissionRequestResult': + def from_dict(obj: Any) -> "PermissionRequestResult": assert isinstance(obj, dict) success = from_bool(obj.get("success")) return PermissionRequestResult(success) @@ -2332,27 +2735,31 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result + class Kind(Enum): APPROVED = "approved" DENIED_BY_CONTENT_EXCLUSION_POLICY = "denied-by-content-exclusion-policy" DENIED_BY_PERMISSION_REQUEST_HOOK = "denied-by-permission-request-hook" DENIED_BY_RULES = "denied-by-rules" DENIED_INTERACTIVELY_BY_USER = "denied-interactively-by-user" - DENIED_NO_APPROVAL_RULE_AND_COULD_NOT_REQUEST_FROM_USER = "denied-no-approval-rule-and-could-not-request-from-user" + DENIED_NO_APPROVAL_RULE_AND_COULD_NOT_REQUEST_FROM_USER = ( + "denied-no-approval-rule-and-could-not-request-from-user" + ) + @dataclass class PermissionDecision: kind: Kind """The permission request was approved - + Denied because approval rules explicitly blocked it - + Denied because no approval rule matched and user confirmation was unavailable - + Denied by the user during an interactive prompt - + Denied by the organization's content exclusion policy - + Denied by a permission request hook registered by an extension or plugin """ rules: list[Any] | None = None @@ -2363,7 +2770,7 @@ class PermissionDecision: message: str | None = None """Human-readable explanation of why the path was excluded - + Optional message from the hook explaining the denial """ path: str | None = None @@ -2373,7 +2780,7 @@ class PermissionDecision: """Whether to interrupt the current agent turn""" @staticmethod - def from_dict(obj: Any) -> 'PermissionDecision': + def from_dict(obj: Any) -> "PermissionDecision": assert isinstance(obj, dict) kind = Kind(obj.get("kind")) rules = from_union([lambda x: from_list(lambda x: x, x), from_none], obj.get("rules")) @@ -2387,7 +2794,9 @@ def to_dict(self) -> dict: result: dict = {} result["kind"] = to_enum(Kind, self.kind) if self.rules is not None: - result["rules"] = from_union([lambda x: from_list(lambda x: x, x), from_none], self.rules) + result["rules"] = from_union( + [lambda x: from_list(lambda x: x, x), from_none], self.rules + ) if self.feedback is not None: result["feedback"] = from_union([from_str, from_none], self.feedback) if self.message is not None: @@ -2398,6 +2807,7 @@ def to_dict(self) -> dict: result["interrupt"] = from_union([from_bool, from_none], self.interrupt) return result + @dataclass class PermissionDecisionRequest: request_id: str @@ -2406,7 +2816,7 @@ class PermissionDecisionRequest: result: PermissionDecision @staticmethod - def from_dict(obj: Any) -> 'PermissionDecisionRequest': + def from_dict(obj: Any) -> "PermissionDecisionRequest": assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) result = PermissionDecision.from_dict(obj.get("result")) @@ -2418,13 +2828,14 @@ def to_dict(self) -> dict: result["result"] = to_class(PermissionDecision, self.result) return result + @dataclass class LogResult: event_id: UUID """The unique identifier of the emitted session event""" @staticmethod - def from_dict(obj: Any) -> 'LogResult': + def from_dict(obj: Any) -> "LogResult": assert isinstance(obj, dict) event_id = UUID(obj.get("eventId")) return LogResult(event_id) @@ -2434,14 +2845,17 @@ def to_dict(self) -> dict: result["eventId"] = str(self.event_id) return result + class SessionLogLevel(Enum): """Log severity level. Determines how the message is displayed in the timeline. Defaults to "info". """ + ERROR = "error" INFO = "info" WARNING = "warning" + @dataclass class LogRequest: message: str @@ -2458,7 +2872,7 @@ class LogRequest: """Optional URL the user can open in their browser for more details""" @staticmethod - def from_dict(obj: Any) -> 'LogRequest': + def from_dict(obj: Any) -> "LogRequest": assert isinstance(obj, dict) message = from_str(obj.get("message")) ephemeral = from_union([from_bool, from_none], obj.get("ephemeral")) @@ -2472,18 +2886,21 @@ def to_dict(self) -> dict: if self.ephemeral is not None: result["ephemeral"] = from_union([from_bool, from_none], self.ephemeral) if self.level is not None: - result["level"] = from_union([lambda x: to_enum(SessionLogLevel, x), from_none], self.level) + result["level"] = from_union( + [lambda x: to_enum(SessionLogLevel, x), from_none], self.level + ) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result + @dataclass class ShellExecResult: process_id: str """Unique identifier for tracking streamed output""" @staticmethod - def from_dict(obj: Any) -> 'ShellExecResult': + def from_dict(obj: Any) -> "ShellExecResult": assert isinstance(obj, dict) process_id = from_str(obj.get("processId")) return ShellExecResult(process_id) @@ -2493,6 +2910,7 @@ def to_dict(self) -> dict: result["processId"] = from_str(self.process_id) return result + @dataclass class ShellExecRequest: command: str @@ -2505,7 +2923,7 @@ class ShellExecRequest: """Timeout in milliseconds (default: 30000)""" @staticmethod - def from_dict(obj: Any) -> 'ShellExecRequest': + def from_dict(obj: Any) -> "ShellExecRequest": assert isinstance(obj, dict) command = from_str(obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) @@ -2521,13 +2939,14 @@ def to_dict(self) -> dict: result["timeout"] = from_union([from_int, from_none], self.timeout) return result + @dataclass class ShellKillResult: killed: bool """Whether the signal was sent successfully""" @staticmethod - def from_dict(obj: Any) -> 'ShellKillResult': + def from_dict(obj: Any) -> "ShellKillResult": assert isinstance(obj, dict) killed = from_bool(obj.get("killed")) return ShellKillResult(killed) @@ -2537,6 +2956,7 @@ def to_dict(self) -> dict: result["killed"] = from_bool(self.killed) return result + class ShellKillSignal(Enum): """Signal to send (default: SIGTERM)""" @@ -2544,6 +2964,7 @@ class ShellKillSignal(Enum): SIGKILL = "SIGKILL" SIGTERM = "SIGTERM" + @dataclass class ShellKillRequest: process_id: str @@ -2553,7 +2974,7 @@ class ShellKillRequest: """Signal to send (default: SIGTERM)""" @staticmethod - def from_dict(obj: Any) -> 'ShellKillRequest': + def from_dict(obj: Any) -> "ShellKillRequest": assert isinstance(obj, dict) process_id = from_str(obj.get("processId")) signal = from_union([ShellKillSignal, from_none], obj.get("signal")) @@ -2563,9 +2984,12 @@ def to_dict(self) -> dict: result: dict = {} result["processId"] = from_str(self.process_id) if self.signal is not None: - result["signal"] = from_union([lambda x: to_enum(ShellKillSignal, x), from_none], self.signal) + result["signal"] = from_union( + [lambda x: to_enum(ShellKillSignal, x), from_none], self.signal + ) return result + @dataclass class HistoryCompactContextWindow: """Post-compaction context window usage breakdown""" @@ -2589,15 +3013,24 @@ class HistoryCompactContextWindow: """Token count from tool definitions""" @staticmethod - def from_dict(obj: Any) -> 'HistoryCompactContextWindow': + def from_dict(obj: Any) -> "HistoryCompactContextWindow": assert isinstance(obj, dict) current_tokens = from_int(obj.get("currentTokens")) messages_length = from_int(obj.get("messagesLength")) token_limit = from_int(obj.get("tokenLimit")) conversation_tokens = from_union([from_int, from_none], obj.get("conversationTokens")) system_tokens = from_union([from_int, from_none], obj.get("systemTokens")) - tool_definitions_tokens = from_union([from_int, from_none], obj.get("toolDefinitionsTokens")) - return HistoryCompactContextWindow(current_tokens, messages_length, token_limit, conversation_tokens, system_tokens, tool_definitions_tokens) + tool_definitions_tokens = from_union( + [from_int, from_none], obj.get("toolDefinitionsTokens") + ) + return HistoryCompactContextWindow( + current_tokens, + messages_length, + token_limit, + conversation_tokens, + system_tokens, + tool_definitions_tokens, + ) def to_dict(self) -> dict: result: dict = {} @@ -2605,13 +3038,18 @@ def to_dict(self) -> dict: result["messagesLength"] = from_int(self.messages_length) result["tokenLimit"] = from_int(self.token_limit) if self.conversation_tokens is not None: - result["conversationTokens"] = from_union([from_int, from_none], self.conversation_tokens) + result["conversationTokens"] = from_union( + [from_int, from_none], self.conversation_tokens + ) if self.system_tokens is not None: result["systemTokens"] = from_union([from_int, from_none], self.system_tokens) if self.tool_definitions_tokens is not None: - result["toolDefinitionsTokens"] = from_union([from_int, from_none], self.tool_definitions_tokens) + result["toolDefinitionsTokens"] = from_union( + [from_int, from_none], self.tool_definitions_tokens + ) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryCompactResult: @@ -2628,12 +3066,14 @@ class HistoryCompactResult: """Post-compaction context window usage breakdown""" @staticmethod - def from_dict(obj: Any) -> 'HistoryCompactResult': + def from_dict(obj: Any) -> "HistoryCompactResult": assert isinstance(obj, dict) messages_removed = from_int(obj.get("messagesRemoved")) success = from_bool(obj.get("success")) tokens_removed = from_int(obj.get("tokensRemoved")) - context_window = from_union([HistoryCompactContextWindow.from_dict, from_none], obj.get("contextWindow")) + context_window = from_union( + [HistoryCompactContextWindow.from_dict, from_none], obj.get("contextWindow") + ) return HistoryCompactResult(messages_removed, success, tokens_removed, context_window) def to_dict(self) -> dict: @@ -2642,9 +3082,12 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) result["tokensRemoved"] = from_int(self.tokens_removed) if self.context_window is not None: - result["contextWindow"] = from_union([lambda x: to_class(HistoryCompactContextWindow, x), from_none], self.context_window) + result["contextWindow"] = from_union( + [lambda x: to_class(HistoryCompactContextWindow, x), from_none], self.context_window + ) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryTruncateResult: @@ -2652,7 +3095,7 @@ class HistoryTruncateResult: """Number of events that were removed""" @staticmethod - def from_dict(obj: Any) -> 'HistoryTruncateResult': + def from_dict(obj: Any) -> "HistoryTruncateResult": assert isinstance(obj, dict) events_removed = from_int(obj.get("eventsRemoved")) return HistoryTruncateResult(events_removed) @@ -2662,6 +3105,7 @@ def to_dict(self) -> dict: result["eventsRemoved"] = from_int(self.events_removed) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryTruncateRequest: @@ -2669,7 +3113,7 @@ class HistoryTruncateRequest: """Event ID to truncate to. This event and all events after it are removed from the session.""" @staticmethod - def from_dict(obj: Any) -> 'HistoryTruncateRequest': + def from_dict(obj: Any) -> "HistoryTruncateRequest": assert isinstance(obj, dict) event_id = from_str(obj.get("eventId")) return HistoryTruncateRequest(event_id) @@ -2679,6 +3123,7 @@ def to_dict(self) -> dict: result["eventId"] = from_str(self.event_id) return result + @dataclass class UsageMetricsCodeChanges: """Aggregated code change metrics""" @@ -2693,7 +3138,7 @@ class UsageMetricsCodeChanges: """Total lines of code removed""" @staticmethod - def from_dict(obj: Any) -> 'UsageMetricsCodeChanges': + def from_dict(obj: Any) -> "UsageMetricsCodeChanges": assert isinstance(obj, dict) files_modified_count = from_int(obj.get("filesModifiedCount")) lines_added = from_int(obj.get("linesAdded")) @@ -2707,6 +3152,7 @@ def to_dict(self) -> dict: result["linesRemoved"] = from_int(self.lines_removed) return result + @dataclass class UsageMetricsModelMetricRequests: """Request count and cost metrics for this model""" @@ -2718,7 +3164,7 @@ class UsageMetricsModelMetricRequests: """Number of API requests made with this model""" @staticmethod - def from_dict(obj: Any) -> 'UsageMetricsModelMetricRequests': + def from_dict(obj: Any) -> "UsageMetricsModelMetricRequests": assert isinstance(obj, dict) cost = from_float(obj.get("cost")) count = from_int(obj.get("count")) @@ -2730,6 +3176,7 @@ def to_dict(self) -> dict: result["count"] = from_int(self.count) return result + @dataclass class UsageMetricsModelMetricUsage: """Token usage metrics for this model""" @@ -2750,14 +3197,16 @@ class UsageMetricsModelMetricUsage: """Total output tokens used for reasoning""" @staticmethod - def from_dict(obj: Any) -> 'UsageMetricsModelMetricUsage': + def from_dict(obj: Any) -> "UsageMetricsModelMetricUsage": assert isinstance(obj, dict) cache_read_tokens = from_int(obj.get("cacheReadTokens")) cache_write_tokens = from_int(obj.get("cacheWriteTokens")) input_tokens = from_int(obj.get("inputTokens")) output_tokens = from_int(obj.get("outputTokens")) reasoning_tokens = from_union([from_int, from_none], obj.get("reasoningTokens")) - return UsageMetricsModelMetricUsage(cache_read_tokens, cache_write_tokens, input_tokens, output_tokens, reasoning_tokens) + return UsageMetricsModelMetricUsage( + cache_read_tokens, cache_write_tokens, input_tokens, output_tokens, reasoning_tokens + ) def to_dict(self) -> dict: result: dict = {} @@ -2769,6 +3218,7 @@ def to_dict(self) -> dict: result["reasoningTokens"] = from_union([from_int, from_none], self.reasoning_tokens) return result + @dataclass class UsageMetricsModelMetric: requests: UsageMetricsModelMetricRequests @@ -2778,7 +3228,7 @@ class UsageMetricsModelMetric: """Token usage metrics for this model""" @staticmethod - def from_dict(obj: Any) -> 'UsageMetricsModelMetric': + def from_dict(obj: Any) -> "UsageMetricsModelMetric": assert isinstance(obj, dict) requests = UsageMetricsModelMetricRequests.from_dict(obj.get("requests")) usage = UsageMetricsModelMetricUsage.from_dict(obj.get("usage")) @@ -2790,6 +3240,7 @@ def to_dict(self) -> dict: result["usage"] = to_class(UsageMetricsModelMetricUsage, self.usage) return result + # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class UsageGetMetricsResult: @@ -2822,7 +3273,7 @@ class UsageGetMetricsResult: """Currently active model identifier""" @staticmethod - def from_dict(obj: Any) -> 'UsageGetMetricsResult': + def from_dict(obj: Any) -> "UsageGetMetricsResult": assert isinstance(obj, dict) code_changes = UsageMetricsCodeChanges.from_dict(obj.get("codeChanges")) last_call_input_tokens = from_int(obj.get("lastCallInputTokens")) @@ -2833,14 +3284,26 @@ def from_dict(obj: Any) -> 'UsageGetMetricsResult': total_premium_request_cost = from_float(obj.get("totalPremiumRequestCost")) total_user_requests = from_int(obj.get("totalUserRequests")) current_model = from_union([from_str, from_none], obj.get("currentModel")) - return UsageGetMetricsResult(code_changes, last_call_input_tokens, last_call_output_tokens, model_metrics, session_start_time, total_api_duration_ms, total_premium_request_cost, total_user_requests, current_model) + return UsageGetMetricsResult( + code_changes, + last_call_input_tokens, + last_call_output_tokens, + model_metrics, + session_start_time, + total_api_duration_ms, + total_premium_request_cost, + total_user_requests, + current_model, + ) def to_dict(self) -> dict: result: dict = {} result["codeChanges"] = to_class(UsageMetricsCodeChanges, self.code_changes) result["lastCallInputTokens"] = from_int(self.last_call_input_tokens) result["lastCallOutputTokens"] = from_int(self.last_call_output_tokens) - result["modelMetrics"] = from_dict(lambda x: to_class(UsageMetricsModelMetric, x), self.model_metrics) + result["modelMetrics"] = from_dict( + lambda x: to_class(UsageMetricsModelMetric, x), self.model_metrics + ) result["sessionStartTime"] = from_int(self.session_start_time) result["totalApiDurationMs"] = to_float(self.total_api_duration_ms) result["totalPremiumRequestCost"] = to_float(self.total_premium_request_cost) @@ -2849,13 +3312,14 @@ def to_dict(self) -> dict: result["currentModel"] = from_union([from_str, from_none], self.current_model) return result + @dataclass class SessionFSReadFileResult: content: str """File content as UTF-8 string""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReadFileResult': + def from_dict(obj: Any) -> "SessionFSReadFileResult": assert isinstance(obj, dict) content = from_str(obj.get("content")) return SessionFSReadFileResult(content) @@ -2865,6 +3329,7 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result + @dataclass class SessionFSReadFileRequest: path: str @@ -2874,7 +3339,7 @@ class SessionFSReadFileRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReadFileRequest': + def from_dict(obj: Any) -> "SessionFSReadFileRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -2886,6 +3351,7 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + @dataclass class SessionFSWriteFileRequest: content: str @@ -2901,7 +3367,7 @@ class SessionFSWriteFileRequest: """Optional POSIX-style mode for newly created files""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSWriteFileRequest': + def from_dict(obj: Any) -> "SessionFSWriteFileRequest": assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -2918,6 +3384,7 @@ def to_dict(self) -> dict: result["mode"] = from_union([from_int, from_none], self.mode) return result + @dataclass class SessionFSAppendFileRequest: content: str @@ -2933,7 +3400,7 @@ class SessionFSAppendFileRequest: """Optional POSIX-style mode for newly created files""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSAppendFileRequest': + def from_dict(obj: Any) -> "SessionFSAppendFileRequest": assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -2950,13 +3417,14 @@ def to_dict(self) -> dict: result["mode"] = from_union([from_int, from_none], self.mode) return result + @dataclass class SessionFSExistsResult: exists: bool """Whether the path exists""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSExistsResult': + def from_dict(obj: Any) -> "SessionFSExistsResult": assert isinstance(obj, dict) exists = from_bool(obj.get("exists")) return SessionFSExistsResult(exists) @@ -2966,6 +3434,7 @@ def to_dict(self) -> dict: result["exists"] = from_bool(self.exists) return result + @dataclass class SessionFSExistsRequest: path: str @@ -2975,7 +3444,7 @@ class SessionFSExistsRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSExistsRequest': + def from_dict(obj: Any) -> "SessionFSExistsRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -2987,6 +3456,7 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + @dataclass class SessionFSStatResult: birthtime: datetime @@ -3005,7 +3475,7 @@ class SessionFSStatResult: """File size in bytes""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSStatResult': + def from_dict(obj: Any) -> "SessionFSStatResult": assert isinstance(obj, dict) birthtime = from_datetime(obj.get("birthtime")) is_directory = from_bool(obj.get("isDirectory")) @@ -3023,6 +3493,7 @@ def to_dict(self) -> dict: result["size"] = from_int(self.size) return result + @dataclass class SessionFSStatRequest: path: str @@ -3032,7 +3503,7 @@ class SessionFSStatRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSStatRequest': + def from_dict(obj: Any) -> "SessionFSStatRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3044,6 +3515,7 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + @dataclass class SessionFSMkdirRequest: path: str @@ -3059,7 +3531,7 @@ class SessionFSMkdirRequest: """Create parent directories as needed""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSMkdirRequest': + def from_dict(obj: Any) -> "SessionFSMkdirRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3077,13 +3549,14 @@ def to_dict(self) -> dict: result["recursive"] = from_union([from_bool, from_none], self.recursive) return result + @dataclass class SessionFSReaddirResult: entries: list[str] """Entry names in the directory""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReaddirResult': + def from_dict(obj: Any) -> "SessionFSReaddirResult": assert isinstance(obj, dict) entries = from_list(from_str, obj.get("entries")) return SessionFSReaddirResult(entries) @@ -3093,6 +3566,7 @@ def to_dict(self) -> dict: result["entries"] = from_list(from_str, self.entries) return result + @dataclass class SessionFSReaddirRequest: path: str @@ -3102,7 +3576,7 @@ class SessionFSReaddirRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReaddirRequest': + def from_dict(obj: Any) -> "SessionFSReaddirRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3114,12 +3588,14 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + class SessionFSReaddirWithTypesEntryType(Enum): """Entry type""" DIRECTORY = "directory" FILE = "file" + @dataclass class SessionFSReaddirWithTypesEntry: name: str @@ -3129,7 +3605,7 @@ class SessionFSReaddirWithTypesEntry: """Entry type""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesEntry': + def from_dict(obj: Any) -> "SessionFSReaddirWithTypesEntry": assert isinstance(obj, dict) name = from_str(obj.get("name")) type = SessionFSReaddirWithTypesEntryType(obj.get("type")) @@ -3141,22 +3617,26 @@ def to_dict(self) -> dict: result["type"] = to_enum(SessionFSReaddirWithTypesEntryType, self.type) return result + @dataclass class SessionFSReaddirWithTypesResult: entries: list[SessionFSReaddirWithTypesEntry] """Directory entries with type information""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesResult': + def from_dict(obj: Any) -> "SessionFSReaddirWithTypesResult": assert isinstance(obj, dict) entries = from_list(SessionFSReaddirWithTypesEntry.from_dict, obj.get("entries")) return SessionFSReaddirWithTypesResult(entries) def to_dict(self) -> dict: result: dict = {} - result["entries"] = from_list(lambda x: to_class(SessionFSReaddirWithTypesEntry, x), self.entries) + result["entries"] = from_list( + lambda x: to_class(SessionFSReaddirWithTypesEntry, x), self.entries + ) return result + @dataclass class SessionFSReaddirWithTypesRequest: path: str @@ -3166,7 +3646,7 @@ class SessionFSReaddirWithTypesRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesRequest': + def from_dict(obj: Any) -> "SessionFSReaddirWithTypesRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3178,6 +3658,7 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result + @dataclass class SessionFSRmRequest: path: str @@ -3193,7 +3674,7 @@ class SessionFSRmRequest: """Remove directories and their contents recursively""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSRmRequest': + def from_dict(obj: Any) -> "SessionFSRmRequest": assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3211,6 +3692,7 @@ def to_dict(self) -> dict: result["recursive"] = from_union([from_bool, from_none], self.recursive) return result + @dataclass class SessionFSRenameRequest: dest: str @@ -3223,7 +3705,7 @@ class SessionFSRenameRequest: """Source path using SessionFs conventions""" @staticmethod - def from_dict(obj: Any) -> 'SessionFSRenameRequest': + def from_dict(obj: Any) -> "SessionFSRenameRequest": assert isinstance(obj, dict) dest = from_str(obj.get("dest")) session_id = from_str(obj.get("sessionId")) @@ -3237,495 +3719,661 @@ def to_dict(self) -> dict: result["src"] = from_str(self.src) return result + def ping_result_from_dict(s: Any) -> PingResult: return PingResult.from_dict(s) + def ping_result_to_dict(x: PingResult) -> Any: return to_class(PingResult, x) + def ping_request_from_dict(s: Any) -> PingRequest: return PingRequest.from_dict(s) + def ping_request_to_dict(x: PingRequest) -> Any: return to_class(PingRequest, x) + def model_list_from_dict(s: Any) -> ModelList: return ModelList.from_dict(s) + def model_list_to_dict(x: ModelList) -> Any: return to_class(ModelList, x) + def tool_list_from_dict(s: Any) -> ToolList: return ToolList.from_dict(s) + def tool_list_to_dict(x: ToolList) -> Any: return to_class(ToolList, x) + def tools_list_request_from_dict(s: Any) -> ToolsListRequest: return ToolsListRequest.from_dict(s) + def tools_list_request_to_dict(x: ToolsListRequest) -> Any: return to_class(ToolsListRequest, x) + def account_get_quota_result_from_dict(s: Any) -> AccountGetQuotaResult: return AccountGetQuotaResult.from_dict(s) + def account_get_quota_result_to_dict(x: AccountGetQuotaResult) -> Any: return to_class(AccountGetQuotaResult, x) + def mcp_config_list_from_dict(s: Any) -> MCPConfigList: return MCPConfigList.from_dict(s) + def mcp_config_list_to_dict(x: MCPConfigList) -> Any: return to_class(MCPConfigList, x) + def mcp_config_add_request_from_dict(s: Any) -> MCPConfigAddRequest: return MCPConfigAddRequest.from_dict(s) + def mcp_config_add_request_to_dict(x: MCPConfigAddRequest) -> Any: return to_class(MCPConfigAddRequest, x) + def mcp_config_update_request_from_dict(s: Any) -> MCPConfigUpdateRequest: return MCPConfigUpdateRequest.from_dict(s) + def mcp_config_update_request_to_dict(x: MCPConfigUpdateRequest) -> Any: return to_class(MCPConfigUpdateRequest, x) + def mcp_config_remove_request_from_dict(s: Any) -> MCPConfigRemoveRequest: return MCPConfigRemoveRequest.from_dict(s) + def mcp_config_remove_request_to_dict(x: MCPConfigRemoveRequest) -> Any: return to_class(MCPConfigRemoveRequest, x) + def mcp_discover_result_from_dict(s: Any) -> MCPDiscoverResult: return MCPDiscoverResult.from_dict(s) + def mcp_discover_result_to_dict(x: MCPDiscoverResult) -> Any: return to_class(MCPDiscoverResult, x) + def mcp_discover_request_from_dict(s: Any) -> MCPDiscoverRequest: return MCPDiscoverRequest.from_dict(s) + def mcp_discover_request_to_dict(x: MCPDiscoverRequest) -> Any: return to_class(MCPDiscoverRequest, x) + def session_fs_set_provider_result_from_dict(s: Any) -> SessionFSSetProviderResult: return SessionFSSetProviderResult.from_dict(s) + def session_fs_set_provider_result_to_dict(x: SessionFSSetProviderResult) -> Any: return to_class(SessionFSSetProviderResult, x) + def session_fs_set_provider_request_from_dict(s: Any) -> SessionFSSetProviderRequest: return SessionFSSetProviderRequest.from_dict(s) + def session_fs_set_provider_request_to_dict(x: SessionFSSetProviderRequest) -> Any: return to_class(SessionFSSetProviderRequest, x) + def sessions_fork_result_from_dict(s: Any) -> SessionsForkResult: return SessionsForkResult.from_dict(s) + def sessions_fork_result_to_dict(x: SessionsForkResult) -> Any: return to_class(SessionsForkResult, x) + def sessions_fork_request_from_dict(s: Any) -> SessionsForkRequest: return SessionsForkRequest.from_dict(s) + def sessions_fork_request_to_dict(x: SessionsForkRequest) -> Any: return to_class(SessionsForkRequest, x) + def current_model_from_dict(s: Any) -> CurrentModel: return CurrentModel.from_dict(s) + def current_model_to_dict(x: CurrentModel) -> Any: return to_class(CurrentModel, x) + def model_switch_to_result_from_dict(s: Any) -> ModelSwitchToResult: return ModelSwitchToResult.from_dict(s) + def model_switch_to_result_to_dict(x: ModelSwitchToResult) -> Any: return to_class(ModelSwitchToResult, x) + def model_switch_to_request_from_dict(s: Any) -> ModelSwitchToRequest: return ModelSwitchToRequest.from_dict(s) + def model_switch_to_request_to_dict(x: ModelSwitchToRequest) -> Any: return to_class(ModelSwitchToRequest, x) + def session_mode_from_dict(s: Any) -> SessionMode: return SessionMode(s) + def session_mode_to_dict(x: SessionMode) -> Any: return to_enum(SessionMode, x) + def mode_set_request_from_dict(s: Any) -> ModeSetRequest: return ModeSetRequest.from_dict(s) + def mode_set_request_to_dict(x: ModeSetRequest) -> Any: return to_class(ModeSetRequest, x) + def name_get_result_from_dict(s: Any) -> NameGetResult: return NameGetResult.from_dict(s) + def name_get_result_to_dict(x: NameGetResult) -> Any: return to_class(NameGetResult, x) + def name_set_request_from_dict(s: Any) -> NameSetRequest: return NameSetRequest.from_dict(s) + def name_set_request_to_dict(x: NameSetRequest) -> Any: return to_class(NameSetRequest, x) + def plan_read_result_from_dict(s: Any) -> PlanReadResult: return PlanReadResult.from_dict(s) + def plan_read_result_to_dict(x: PlanReadResult) -> Any: return to_class(PlanReadResult, x) + def plan_update_request_from_dict(s: Any) -> PlanUpdateRequest: return PlanUpdateRequest.from_dict(s) + def plan_update_request_to_dict(x: PlanUpdateRequest) -> Any: return to_class(PlanUpdateRequest, x) + def workspaces_get_workspace_result_from_dict(s: Any) -> WorkspacesGetWorkspaceResult: return WorkspacesGetWorkspaceResult.from_dict(s) + def workspaces_get_workspace_result_to_dict(x: WorkspacesGetWorkspaceResult) -> Any: return to_class(WorkspacesGetWorkspaceResult, x) + def workspaces_list_files_result_from_dict(s: Any) -> WorkspacesListFilesResult: return WorkspacesListFilesResult.from_dict(s) + def workspaces_list_files_result_to_dict(x: WorkspacesListFilesResult) -> Any: return to_class(WorkspacesListFilesResult, x) + def workspaces_read_file_result_from_dict(s: Any) -> WorkspacesReadFileResult: return WorkspacesReadFileResult.from_dict(s) + def workspaces_read_file_result_to_dict(x: WorkspacesReadFileResult) -> Any: return to_class(WorkspacesReadFileResult, x) + def workspaces_read_file_request_from_dict(s: Any) -> WorkspacesReadFileRequest: return WorkspacesReadFileRequest.from_dict(s) + def workspaces_read_file_request_to_dict(x: WorkspacesReadFileRequest) -> Any: return to_class(WorkspacesReadFileRequest, x) + def workspaces_create_file_request_from_dict(s: Any) -> WorkspacesCreateFileRequest: return WorkspacesCreateFileRequest.from_dict(s) + def workspaces_create_file_request_to_dict(x: WorkspacesCreateFileRequest) -> Any: return to_class(WorkspacesCreateFileRequest, x) + def fleet_start_result_from_dict(s: Any) -> FleetStartResult: return FleetStartResult.from_dict(s) + def fleet_start_result_to_dict(x: FleetStartResult) -> Any: return to_class(FleetStartResult, x) + def fleet_start_request_from_dict(s: Any) -> FleetStartRequest: return FleetStartRequest.from_dict(s) + def fleet_start_request_to_dict(x: FleetStartRequest) -> Any: return to_class(FleetStartRequest, x) + def agent_list_from_dict(s: Any) -> AgentList: return AgentList.from_dict(s) + def agent_list_to_dict(x: AgentList) -> Any: return to_class(AgentList, x) + def agent_get_current_result_from_dict(s: Any) -> AgentGetCurrentResult: return AgentGetCurrentResult.from_dict(s) + def agent_get_current_result_to_dict(x: AgentGetCurrentResult) -> Any: return to_class(AgentGetCurrentResult, x) + def agent_select_result_from_dict(s: Any) -> AgentSelectResult: return AgentSelectResult.from_dict(s) + def agent_select_result_to_dict(x: AgentSelectResult) -> Any: return to_class(AgentSelectResult, x) + def agent_select_request_from_dict(s: Any) -> AgentSelectRequest: return AgentSelectRequest.from_dict(s) + def agent_select_request_to_dict(x: AgentSelectRequest) -> Any: return to_class(AgentSelectRequest, x) + def agent_reload_result_from_dict(s: Any) -> AgentReloadResult: return AgentReloadResult.from_dict(s) + def agent_reload_result_to_dict(x: AgentReloadResult) -> Any: return to_class(AgentReloadResult, x) + def skill_list_from_dict(s: Any) -> SkillList: return SkillList.from_dict(s) + def skill_list_to_dict(x: SkillList) -> Any: return to_class(SkillList, x) + def skills_enable_request_from_dict(s: Any) -> SkillsEnableRequest: return SkillsEnableRequest.from_dict(s) + def skills_enable_request_to_dict(x: SkillsEnableRequest) -> Any: return to_class(SkillsEnableRequest, x) + def skills_disable_request_from_dict(s: Any) -> SkillsDisableRequest: return SkillsDisableRequest.from_dict(s) + def skills_disable_request_to_dict(x: SkillsDisableRequest) -> Any: return to_class(SkillsDisableRequest, x) + def mcp_server_list_from_dict(s: Any) -> MCPServerList: return MCPServerList.from_dict(s) + def mcp_server_list_to_dict(x: MCPServerList) -> Any: return to_class(MCPServerList, x) + def mcp_enable_request_from_dict(s: Any) -> MCPEnableRequest: return MCPEnableRequest.from_dict(s) + def mcp_enable_request_to_dict(x: MCPEnableRequest) -> Any: return to_class(MCPEnableRequest, x) + def mcp_disable_request_from_dict(s: Any) -> MCPDisableRequest: return MCPDisableRequest.from_dict(s) + def mcp_disable_request_to_dict(x: MCPDisableRequest) -> Any: return to_class(MCPDisableRequest, x) + def plugin_list_from_dict(s: Any) -> PluginList: return PluginList.from_dict(s) + def plugin_list_to_dict(x: PluginList) -> Any: return to_class(PluginList, x) + def extension_list_from_dict(s: Any) -> ExtensionList: return ExtensionList.from_dict(s) + def extension_list_to_dict(x: ExtensionList) -> Any: return to_class(ExtensionList, x) + def extensions_enable_request_from_dict(s: Any) -> ExtensionsEnableRequest: return ExtensionsEnableRequest.from_dict(s) + def extensions_enable_request_to_dict(x: ExtensionsEnableRequest) -> Any: return to_class(ExtensionsEnableRequest, x) + def extensions_disable_request_from_dict(s: Any) -> ExtensionsDisableRequest: return ExtensionsDisableRequest.from_dict(s) + def extensions_disable_request_to_dict(x: ExtensionsDisableRequest) -> Any: return to_class(ExtensionsDisableRequest, x) + def handle_tool_call_result_from_dict(s: Any) -> HandleToolCallResult: return HandleToolCallResult.from_dict(s) + def handle_tool_call_result_to_dict(x: HandleToolCallResult) -> Any: return to_class(HandleToolCallResult, x) + def tools_handle_pending_tool_call_request_from_dict(s: Any) -> ToolsHandlePendingToolCallRequest: return ToolsHandlePendingToolCallRequest.from_dict(s) + def tools_handle_pending_tool_call_request_to_dict(x: ToolsHandlePendingToolCallRequest) -> Any: return to_class(ToolsHandlePendingToolCallRequest, x) + def commands_handle_pending_command_result_from_dict(s: Any) -> CommandsHandlePendingCommandResult: return CommandsHandlePendingCommandResult.from_dict(s) + def commands_handle_pending_command_result_to_dict(x: CommandsHandlePendingCommandResult) -> Any: return to_class(CommandsHandlePendingCommandResult, x) -def commands_handle_pending_command_request_from_dict(s: Any) -> CommandsHandlePendingCommandRequest: + +def commands_handle_pending_command_request_from_dict( + s: Any, +) -> CommandsHandlePendingCommandRequest: return CommandsHandlePendingCommandRequest.from_dict(s) + def commands_handle_pending_command_request_to_dict(x: CommandsHandlePendingCommandRequest) -> Any: return to_class(CommandsHandlePendingCommandRequest, x) + def ui_elicitation_response_from_dict(s: Any) -> UIElicitationResponse: return UIElicitationResponse.from_dict(s) + def ui_elicitation_response_to_dict(x: UIElicitationResponse) -> Any: return to_class(UIElicitationResponse, x) + def ui_elicitation_request_from_dict(s: Any) -> UIElicitationRequest: return UIElicitationRequest.from_dict(s) + def ui_elicitation_request_to_dict(x: UIElicitationRequest) -> Any: return to_class(UIElicitationRequest, x) + def ui_elicitation_result_from_dict(s: Any) -> UIElicitationResult: return UIElicitationResult.from_dict(s) + def ui_elicitation_result_to_dict(x: UIElicitationResult) -> Any: return to_class(UIElicitationResult, x) + def ui_handle_pending_elicitation_request_from_dict(s: Any) -> UIHandlePendingElicitationRequest: return UIHandlePendingElicitationRequest.from_dict(s) + def ui_handle_pending_elicitation_request_to_dict(x: UIHandlePendingElicitationRequest) -> Any: return to_class(UIHandlePendingElicitationRequest, x) + def permission_request_result_from_dict(s: Any) -> PermissionRequestResult: return PermissionRequestResult.from_dict(s) + def permission_request_result_to_dict(x: PermissionRequestResult) -> Any: return to_class(PermissionRequestResult, x) + def permission_decision_request_from_dict(s: Any) -> PermissionDecisionRequest: return PermissionDecisionRequest.from_dict(s) + def permission_decision_request_to_dict(x: PermissionDecisionRequest) -> Any: return to_class(PermissionDecisionRequest, x) + def log_result_from_dict(s: Any) -> LogResult: return LogResult.from_dict(s) + def log_result_to_dict(x: LogResult) -> Any: return to_class(LogResult, x) + def log_request_from_dict(s: Any) -> LogRequest: return LogRequest.from_dict(s) + def log_request_to_dict(x: LogRequest) -> Any: return to_class(LogRequest, x) + def shell_exec_result_from_dict(s: Any) -> ShellExecResult: return ShellExecResult.from_dict(s) + def shell_exec_result_to_dict(x: ShellExecResult) -> Any: return to_class(ShellExecResult, x) + def shell_exec_request_from_dict(s: Any) -> ShellExecRequest: return ShellExecRequest.from_dict(s) + def shell_exec_request_to_dict(x: ShellExecRequest) -> Any: return to_class(ShellExecRequest, x) + def shell_kill_result_from_dict(s: Any) -> ShellKillResult: return ShellKillResult.from_dict(s) + def shell_kill_result_to_dict(x: ShellKillResult) -> Any: return to_class(ShellKillResult, x) + def shell_kill_request_from_dict(s: Any) -> ShellKillRequest: return ShellKillRequest.from_dict(s) + def shell_kill_request_to_dict(x: ShellKillRequest) -> Any: return to_class(ShellKillRequest, x) + def history_compact_result_from_dict(s: Any) -> HistoryCompactResult: return HistoryCompactResult.from_dict(s) + def history_compact_result_to_dict(x: HistoryCompactResult) -> Any: return to_class(HistoryCompactResult, x) + def history_truncate_result_from_dict(s: Any) -> HistoryTruncateResult: return HistoryTruncateResult.from_dict(s) + def history_truncate_result_to_dict(x: HistoryTruncateResult) -> Any: return to_class(HistoryTruncateResult, x) + def history_truncate_request_from_dict(s: Any) -> HistoryTruncateRequest: return HistoryTruncateRequest.from_dict(s) + def history_truncate_request_to_dict(x: HistoryTruncateRequest) -> Any: return to_class(HistoryTruncateRequest, x) + def usage_get_metrics_result_from_dict(s: Any) -> UsageGetMetricsResult: return UsageGetMetricsResult.from_dict(s) + def usage_get_metrics_result_to_dict(x: UsageGetMetricsResult) -> Any: return to_class(UsageGetMetricsResult, x) + def session_fs_read_file_result_from_dict(s: Any) -> SessionFSReadFileResult: return SessionFSReadFileResult.from_dict(s) + def session_fs_read_file_result_to_dict(x: SessionFSReadFileResult) -> Any: return to_class(SessionFSReadFileResult, x) + def session_fs_read_file_request_from_dict(s: Any) -> SessionFSReadFileRequest: return SessionFSReadFileRequest.from_dict(s) + def session_fs_read_file_request_to_dict(x: SessionFSReadFileRequest) -> Any: return to_class(SessionFSReadFileRequest, x) + def session_fs_write_file_request_from_dict(s: Any) -> SessionFSWriteFileRequest: return SessionFSWriteFileRequest.from_dict(s) + def session_fs_write_file_request_to_dict(x: SessionFSWriteFileRequest) -> Any: return to_class(SessionFSWriteFileRequest, x) + def session_fs_append_file_request_from_dict(s: Any) -> SessionFSAppendFileRequest: return SessionFSAppendFileRequest.from_dict(s) + def session_fs_append_file_request_to_dict(x: SessionFSAppendFileRequest) -> Any: return to_class(SessionFSAppendFileRequest, x) + def session_fs_exists_result_from_dict(s: Any) -> SessionFSExistsResult: return SessionFSExistsResult.from_dict(s) + def session_fs_exists_result_to_dict(x: SessionFSExistsResult) -> Any: return to_class(SessionFSExistsResult, x) + def session_fs_exists_request_from_dict(s: Any) -> SessionFSExistsRequest: return SessionFSExistsRequest.from_dict(s) + def session_fs_exists_request_to_dict(x: SessionFSExistsRequest) -> Any: return to_class(SessionFSExistsRequest, x) + def session_fs_stat_result_from_dict(s: Any) -> SessionFSStatResult: return SessionFSStatResult.from_dict(s) + def session_fs_stat_result_to_dict(x: SessionFSStatResult) -> Any: return to_class(SessionFSStatResult, x) + def session_fs_stat_request_from_dict(s: Any) -> SessionFSStatRequest: return SessionFSStatRequest.from_dict(s) + def session_fs_stat_request_to_dict(x: SessionFSStatRequest) -> Any: return to_class(SessionFSStatRequest, x) + def session_fs_mkdir_request_from_dict(s: Any) -> SessionFSMkdirRequest: return SessionFSMkdirRequest.from_dict(s) + def session_fs_mkdir_request_to_dict(x: SessionFSMkdirRequest) -> Any: return to_class(SessionFSMkdirRequest, x) + def session_fs_readdir_result_from_dict(s: Any) -> SessionFSReaddirResult: return SessionFSReaddirResult.from_dict(s) + def session_fs_readdir_result_to_dict(x: SessionFSReaddirResult) -> Any: return to_class(SessionFSReaddirResult, x) + def session_fs_readdir_request_from_dict(s: Any) -> SessionFSReaddirRequest: return SessionFSReaddirRequest.from_dict(s) + def session_fs_readdir_request_to_dict(x: SessionFSReaddirRequest) -> Any: return to_class(SessionFSReaddirRequest, x) + def session_fs_readdir_with_types_result_from_dict(s: Any) -> SessionFSReaddirWithTypesResult: return SessionFSReaddirWithTypesResult.from_dict(s) + def session_fs_readdir_with_types_result_to_dict(x: SessionFSReaddirWithTypesResult) -> Any: return to_class(SessionFSReaddirWithTypesResult, x) + def session_fs_readdir_with_types_request_from_dict(s: Any) -> SessionFSReaddirWithTypesRequest: return SessionFSReaddirWithTypesRequest.from_dict(s) + def session_fs_readdir_with_types_request_to_dict(x: SessionFSReaddirWithTypesRequest) -> Any: return to_class(SessionFSReaddirWithTypesRequest, x) + def session_fs_rm_request_from_dict(s: Any) -> SessionFSRmRequest: return SessionFSRmRequest.from_dict(s) + def session_fs_rm_request_to_dict(x: SessionFSRmRequest) -> Any: return to_class(SessionFSRmRequest, x) + def session_fs_rename_request_from_dict(s: Any) -> SessionFSRenameRequest: return SessionFSRenameRequest.from_dict(s) + def session_fs_rename_request_to_dict(x: SessionFSRenameRequest) -> Any: return to_class(SessionFSRenameRequest, x) @@ -3736,6 +4384,7 @@ def _timeout_kwargs(timeout: float | None) -> dict: return {"timeout": timeout} return {} + def _patch_model_capabilities(data: dict) -> dict: """Ensure model capabilities have required fields. @@ -3763,7 +4412,11 @@ def __init__(self, client: "JsonRpcClient"): self._client = client async def list(self, *, timeout: float | None = None) -> ModelList: - return ModelList.from_dict(_patch_model_capabilities(await self._client.request("models.list", {}, **_timeout_kwargs(timeout)))) + return ModelList.from_dict( + _patch_model_capabilities( + await self._client.request("models.list", {}, **_timeout_kwargs(timeout)) + ) + ) class ServerToolsApi: @@ -3772,7 +4425,9 @@ def __init__(self, client: "JsonRpcClient"): async def list(self, params: ToolsListRequest, *, timeout: float | None = None) -> ToolList: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return ToolList.from_dict(await self._client.request("tools.list", params_dict, **_timeout_kwargs(timeout))) + return ToolList.from_dict( + await self._client.request("tools.list", params_dict, **_timeout_kwargs(timeout)) + ) class ServerAccountApi: @@ -3780,25 +4435,37 @@ def __init__(self, client: "JsonRpcClient"): self._client = client async def get_quota(self, *, timeout: float | None = None) -> AccountGetQuotaResult: - return AccountGetQuotaResult.from_dict(await self._client.request("account.getQuota", {}, **_timeout_kwargs(timeout))) + return AccountGetQuotaResult.from_dict( + await self._client.request("account.getQuota", {}, **_timeout_kwargs(timeout)) + ) class ServerMcpApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def discover(self, params: MCPDiscoverRequest, *, timeout: float | None = None) -> MCPDiscoverResult: + async def discover( + self, params: MCPDiscoverRequest, *, timeout: float | None = None + ) -> MCPDiscoverResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return MCPDiscoverResult.from_dict(await self._client.request("mcp.discover", params_dict, **_timeout_kwargs(timeout))) + return MCPDiscoverResult.from_dict( + await self._client.request("mcp.discover", params_dict, **_timeout_kwargs(timeout)) + ) class ServerSessionFsApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def set_provider(self, params: SessionFSSetProviderRequest, *, timeout: float | None = None) -> SessionFSSetProviderResult: + async def set_provider( + self, params: SessionFSSetProviderRequest, *, timeout: float | None = None + ) -> SessionFSSetProviderResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return SessionFSSetProviderResult.from_dict(await self._client.request("sessionFs.setProvider", params_dict, **_timeout_kwargs(timeout))) + return SessionFSSetProviderResult.from_dict( + await self._client.request( + "sessionFs.setProvider", params_dict, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3806,13 +4473,18 @@ class ServerSessionsApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def fork(self, params: SessionsForkRequest, *, timeout: float | None = None) -> SessionsForkResult: + async def fork( + self, params: SessionsForkRequest, *, timeout: float | None = None + ) -> SessionsForkResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return SessionsForkResult.from_dict(await self._client.request("sessions.fork", params_dict, **_timeout_kwargs(timeout))) + return SessionsForkResult.from_dict( + await self._client.request("sessions.fork", params_dict, **_timeout_kwargs(timeout)) + ) class ServerRpc: """Typed server-scoped RPC methods.""" + def __init__(self, client: "JsonRpcClient"): self._client = client self.models = ServerModelsApi(client) @@ -3824,7 +4496,9 @@ def __init__(self, client: "JsonRpcClient"): async def ping(self, params: PingRequest, *, timeout: float | None = None) -> PingResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return PingResult.from_dict(await self._client.request("ping", params_dict, **_timeout_kwargs(timeout))) + return PingResult.from_dict( + await self._client.request("ping", params_dict, **_timeout_kwargs(timeout)) + ) class ModelApi: @@ -3833,12 +4507,24 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_current(self, *, timeout: float | None = None) -> CurrentModel: - return CurrentModel.from_dict(await self._client.request("session.model.getCurrent", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - - async def switch_to(self, params: ModelSwitchToRequest, *, timeout: float | None = None) -> ModelSwitchToResult: + return CurrentModel.from_dict( + await self._client.request( + "session.model.getCurrent", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) + + async def switch_to( + self, params: ModelSwitchToRequest, *, timeout: float | None = None + ) -> ModelSwitchToResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ModelSwitchToResult.from_dict(await self._client.request("session.model.switchTo", params_dict, **_timeout_kwargs(timeout))) + return ModelSwitchToResult.from_dict( + await self._client.request( + "session.model.switchTo", params_dict, **_timeout_kwargs(timeout) + ) + ) class ModeApi: @@ -3847,7 +4533,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get(self, *, timeout: float | None = None) -> SessionMode: - return SessionMode(await self._client.request("session.mode.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return SessionMode( + await self._client.request( + "session.mode.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def set(self, params: ModeSetRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -3861,7 +4551,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get(self, *, timeout: float | None = None) -> NameGetResult: - return NameGetResult.from_dict(await self._client.request("session.name.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return NameGetResult.from_dict( + await self._client.request( + "session.name.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def set(self, params: NameSetRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -3875,7 +4569,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def read(self, *, timeout: float | None = None) -> PlanReadResult: - return PlanReadResult.from_dict(await self._client.request("session.plan.read", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return PlanReadResult.from_dict( + await self._client.request( + "session.plan.read", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def update(self, params: PlanUpdateRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -3883,7 +4581,9 @@ async def update(self, params: PlanUpdateRequest, *, timeout: float | None = Non await self._client.request("session.plan.update", params_dict, **_timeout_kwargs(timeout)) async def delete(self, *, timeout: float | None = None) -> None: - await self._client.request("session.plan.delete", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) + await self._client.request( + "session.plan.delete", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) class WorkspacesApi: @@ -3892,20 +4592,42 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_workspace(self, *, timeout: float | None = None) -> WorkspacesGetWorkspaceResult: - return WorkspacesGetWorkspaceResult.from_dict(await self._client.request("session.workspaces.getWorkspace", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return WorkspacesGetWorkspaceResult.from_dict( + await self._client.request( + "session.workspaces.getWorkspace", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) async def list_files(self, *, timeout: float | None = None) -> WorkspacesListFilesResult: - return WorkspacesListFilesResult.from_dict(await self._client.request("session.workspaces.listFiles", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - - async def read_file(self, params: WorkspacesReadFileRequest, *, timeout: float | None = None) -> WorkspacesReadFileResult: + return WorkspacesListFilesResult.from_dict( + await self._client.request( + "session.workspaces.listFiles", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) + + async def read_file( + self, params: WorkspacesReadFileRequest, *, timeout: float | None = None + ) -> WorkspacesReadFileResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return WorkspacesReadFileResult.from_dict(await self._client.request("session.workspaces.readFile", params_dict, **_timeout_kwargs(timeout))) - - async def create_file(self, params: WorkspacesCreateFileRequest, *, timeout: float | None = None) -> None: + return WorkspacesReadFileResult.from_dict( + await self._client.request( + "session.workspaces.readFile", params_dict, **_timeout_kwargs(timeout) + ) + ) + + async def create_file( + self, params: WorkspacesCreateFileRequest, *, timeout: float | None = None + ) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request("session.workspaces.createFile", params_dict, **_timeout_kwargs(timeout)) + await self._client.request( + "session.workspaces.createFile", params_dict, **_timeout_kwargs(timeout) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3914,10 +4636,16 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def start(self, params: FleetStartRequest, *, timeout: float | None = None) -> FleetStartResult: + async def start( + self, params: FleetStartRequest, *, timeout: float | None = None + ) -> FleetStartResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return FleetStartResult.from_dict(await self._client.request("session.fleet.start", params_dict, **_timeout_kwargs(timeout))) + return FleetStartResult.from_dict( + await self._client.request( + "session.fleet.start", params_dict, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3927,21 +4655,43 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> AgentList: - return AgentList.from_dict(await self._client.request("session.agent.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return AgentList.from_dict( + await self._client.request( + "session.agent.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def get_current(self, *, timeout: float | None = None) -> AgentGetCurrentResult: - return AgentGetCurrentResult.from_dict(await self._client.request("session.agent.getCurrent", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - - async def select(self, params: AgentSelectRequest, *, timeout: float | None = None) -> AgentSelectResult: + return AgentGetCurrentResult.from_dict( + await self._client.request( + "session.agent.getCurrent", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) + + async def select( + self, params: AgentSelectRequest, *, timeout: float | None = None + ) -> AgentSelectResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return AgentSelectResult.from_dict(await self._client.request("session.agent.select", params_dict, **_timeout_kwargs(timeout))) + return AgentSelectResult.from_dict( + await self._client.request( + "session.agent.select", params_dict, **_timeout_kwargs(timeout) + ) + ) async def deselect(self, *, timeout: float | None = None) -> None: - await self._client.request("session.agent.deselect", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) + await self._client.request( + "session.agent.deselect", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) async def reload(self, *, timeout: float | None = None) -> AgentReloadResult: - return AgentReloadResult.from_dict(await self._client.request("session.agent.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return AgentReloadResult.from_dict( + await self._client.request( + "session.agent.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3951,7 +4701,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> SkillList: - return SkillList.from_dict(await self._client.request("session.skills.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return SkillList.from_dict( + await self._client.request( + "session.skills.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def enable(self, params: SkillsEnableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -3961,10 +4715,14 @@ async def enable(self, params: SkillsEnableRequest, *, timeout: float | None = N async def disable(self, params: SkillsDisableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request("session.skills.disable", params_dict, **_timeout_kwargs(timeout)) + await self._client.request( + "session.skills.disable", params_dict, **_timeout_kwargs(timeout) + ) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request("session.skills.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) + await self._client.request( + "session.skills.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3974,7 +4732,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> MCPServerList: - return MCPServerList.from_dict(await self._client.request("session.mcp.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return MCPServerList.from_dict( + await self._client.request( + "session.mcp.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) async def enable(self, params: MCPEnableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -3987,7 +4749,9 @@ async def disable(self, params: MCPDisableRequest, *, timeout: float | None = No await self._client.request("session.mcp.disable", params_dict, **_timeout_kwargs(timeout)) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request("session.mcp.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) + await self._client.request( + "session.mcp.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) # Experimental: this API group is experimental and may change or be removed. @@ -3997,7 +4761,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> PluginList: - return PluginList.from_dict(await self._client.request("session.plugins.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return PluginList.from_dict( + await self._client.request( + "session.plugins.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -4007,20 +4775,36 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> ExtensionList: - return ExtensionList.from_dict(await self._client.request("session.extensions.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - - async def enable(self, params: ExtensionsEnableRequest, *, timeout: float | None = None) -> None: + return ExtensionList.from_dict( + await self._client.request( + "session.extensions.list", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) + + async def enable( + self, params: ExtensionsEnableRequest, *, timeout: float | None = None + ) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request("session.extensions.enable", params_dict, **_timeout_kwargs(timeout)) + await self._client.request( + "session.extensions.enable", params_dict, **_timeout_kwargs(timeout) + ) - async def disable(self, params: ExtensionsDisableRequest, *, timeout: float | None = None) -> None: + async def disable( + self, params: ExtensionsDisableRequest, *, timeout: float | None = None + ) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request("session.extensions.disable", params_dict, **_timeout_kwargs(timeout)) + await self._client.request( + "session.extensions.disable", params_dict, **_timeout_kwargs(timeout) + ) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request("session.extensions.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) + await self._client.request( + "session.extensions.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) + ) class ToolsApi: @@ -4028,10 +4812,16 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_tool_call(self, params: ToolsHandlePendingToolCallRequest, *, timeout: float | None = None) -> HandleToolCallResult: + async def handle_pending_tool_call( + self, params: ToolsHandlePendingToolCallRequest, *, timeout: float | None = None + ) -> HandleToolCallResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return HandleToolCallResult.from_dict(await self._client.request("session.tools.handlePendingToolCall", params_dict, **_timeout_kwargs(timeout))) + return HandleToolCallResult.from_dict( + await self._client.request( + "session.tools.handlePendingToolCall", params_dict, **_timeout_kwargs(timeout) + ) + ) class CommandsApi: @@ -4039,10 +4829,16 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_command(self, params: CommandsHandlePendingCommandRequest, *, timeout: float | None = None) -> CommandsHandlePendingCommandResult: + async def handle_pending_command( + self, params: CommandsHandlePendingCommandRequest, *, timeout: float | None = None + ) -> CommandsHandlePendingCommandResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return CommandsHandlePendingCommandResult.from_dict(await self._client.request("session.commands.handlePendingCommand", params_dict, **_timeout_kwargs(timeout))) + return CommandsHandlePendingCommandResult.from_dict( + await self._client.request( + "session.commands.handlePendingCommand", params_dict, **_timeout_kwargs(timeout) + ) + ) class UiApi: @@ -4050,15 +4846,27 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def elicitation(self, params: UIElicitationRequest, *, timeout: float | None = None) -> UIElicitationResponse: + async def elicitation( + self, params: UIElicitationRequest, *, timeout: float | None = None + ) -> UIElicitationResponse: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return UIElicitationResponse.from_dict(await self._client.request("session.ui.elicitation", params_dict, **_timeout_kwargs(timeout))) - - async def handle_pending_elicitation(self, params: UIHandlePendingElicitationRequest, *, timeout: float | None = None) -> UIElicitationResult: + return UIElicitationResponse.from_dict( + await self._client.request( + "session.ui.elicitation", params_dict, **_timeout_kwargs(timeout) + ) + ) + + async def handle_pending_elicitation( + self, params: UIHandlePendingElicitationRequest, *, timeout: float | None = None + ) -> UIElicitationResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return UIElicitationResult.from_dict(await self._client.request("session.ui.handlePendingElicitation", params_dict, **_timeout_kwargs(timeout))) + return UIElicitationResult.from_dict( + await self._client.request( + "session.ui.handlePendingElicitation", params_dict, **_timeout_kwargs(timeout) + ) + ) class PermissionsApi: @@ -4066,10 +4874,18 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_permission_request(self, params: PermissionDecisionRequest, *, timeout: float | None = None) -> PermissionRequestResult: + async def handle_pending_permission_request( + self, params: PermissionDecisionRequest, *, timeout: float | None = None + ) -> PermissionRequestResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return PermissionRequestResult.from_dict(await self._client.request("session.permissions.handlePendingPermissionRequest", params_dict, **_timeout_kwargs(timeout))) + return PermissionRequestResult.from_dict( + await self._client.request( + "session.permissions.handlePendingPermissionRequest", + params_dict, + **_timeout_kwargs(timeout), + ) + ) class ShellApi: @@ -4077,15 +4893,27 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def exec(self, params: ShellExecRequest, *, timeout: float | None = None) -> ShellExecResult: + async def exec( + self, params: ShellExecRequest, *, timeout: float | None = None + ) -> ShellExecResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ShellExecResult.from_dict(await self._client.request("session.shell.exec", params_dict, **_timeout_kwargs(timeout))) - - async def kill(self, params: ShellKillRequest, *, timeout: float | None = None) -> ShellKillResult: + return ShellExecResult.from_dict( + await self._client.request( + "session.shell.exec", params_dict, **_timeout_kwargs(timeout) + ) + ) + + async def kill( + self, params: ShellKillRequest, *, timeout: float | None = None + ) -> ShellKillResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ShellKillResult.from_dict(await self._client.request("session.shell.kill", params_dict, **_timeout_kwargs(timeout))) + return ShellKillResult.from_dict( + await self._client.request( + "session.shell.kill", params_dict, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -4095,12 +4923,24 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def compact(self, *, timeout: float | None = None) -> HistoryCompactResult: - return HistoryCompactResult.from_dict(await self._client.request("session.history.compact", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) - - async def truncate(self, params: HistoryTruncateRequest, *, timeout: float | None = None) -> HistoryTruncateResult: + return HistoryCompactResult.from_dict( + await self._client.request( + "session.history.compact", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) + + async def truncate( + self, params: HistoryTruncateRequest, *, timeout: float | None = None + ) -> HistoryTruncateResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return HistoryTruncateResult.from_dict(await self._client.request("session.history.truncate", params_dict, **_timeout_kwargs(timeout))) + return HistoryTruncateResult.from_dict( + await self._client.request( + "session.history.truncate", params_dict, **_timeout_kwargs(timeout) + ) + ) # Experimental: this API group is experimental and may change or be removed. @@ -4110,11 +4950,18 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_metrics(self, *, timeout: float | None = None) -> UsageGetMetricsResult: - return UsageGetMetricsResult.from_dict(await self._client.request("session.usage.getMetrics", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + return UsageGetMetricsResult.from_dict( + await self._client.request( + "session.usage.getMetrics", + {"sessionId": self._session_id}, + **_timeout_kwargs(timeout), + ) + ) class SessionRpc: """Typed session-scoped RPC methods.""" + def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id @@ -4140,107 +4987,172 @@ def __init__(self, client: "JsonRpcClient", session_id: str): async def log(self, params: LogRequest, *, timeout: float | None = None) -> LogResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return LogResult.from_dict(await self._client.request("session.log", params_dict, **_timeout_kwargs(timeout))) + return LogResult.from_dict( + await self._client.request("session.log", params_dict, **_timeout_kwargs(timeout)) + ) class SessionFsHandler(Protocol): async def read_file(self, params: SessionFSReadFileRequest) -> SessionFSReadFileResult: pass + async def write_file(self, params: SessionFSWriteFileRequest) -> None: pass + async def append_file(self, params: SessionFSAppendFileRequest) -> None: pass + async def exists(self, params: SessionFSExistsRequest) -> SessionFSExistsResult: pass + async def stat(self, params: SessionFSStatRequest) -> SessionFSStatResult: pass + async def mkdir(self, params: SessionFSMkdirRequest) -> None: pass + async def readdir(self, params: SessionFSReaddirRequest) -> SessionFSReaddirResult: pass - async def readdir_with_types(self, params: SessionFSReaddirWithTypesRequest) -> SessionFSReaddirWithTypesResult: + + async def readdir_with_types( + self, params: SessionFSReaddirWithTypesRequest + ) -> SessionFSReaddirWithTypesResult: pass + async def rm(self, params: SessionFSRmRequest) -> None: pass + async def rename(self, params: SessionFSRenameRequest) -> None: pass + @dataclass class ClientSessionApiHandlers: session_fs: SessionFsHandler | None = None + def register_client_session_api_handlers( client: "JsonRpcClient", get_handlers: Callable[[str], ClientSessionApiHandlers], ) -> None: """Register client-session request handlers on a JSON-RPC connection.""" + async def handle_session_fs_read_file(params: dict) -> dict | None: request = SessionFSReadFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) result = await handler.read_file(request) return result.to_dict() + client.set_request_handler("sessionFs.readFile", handle_session_fs_read_file) + async def handle_session_fs_write_file(params: dict) -> dict | None: request = SessionFSWriteFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) await handler.write_file(request) return None + client.set_request_handler("sessionFs.writeFile", handle_session_fs_write_file) + async def handle_session_fs_append_file(params: dict) -> dict | None: request = SessionFSAppendFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) await handler.append_file(request) return None + client.set_request_handler("sessionFs.appendFile", handle_session_fs_append_file) + async def handle_session_fs_exists(params: dict) -> dict | None: request = SessionFSExistsRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) result = await handler.exists(request) return result.to_dict() + client.set_request_handler("sessionFs.exists", handle_session_fs_exists) + async def handle_session_fs_stat(params: dict) -> dict | None: request = SessionFSStatRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) result = await handler.stat(request) return result.to_dict() + client.set_request_handler("sessionFs.stat", handle_session_fs_stat) + async def handle_session_fs_mkdir(params: dict) -> dict | None: request = SessionFSMkdirRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) await handler.mkdir(request) return None + client.set_request_handler("sessionFs.mkdir", handle_session_fs_mkdir) + async def handle_session_fs_readdir(params: dict) -> dict | None: request = SessionFSReaddirRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) result = await handler.readdir(request) return result.to_dict() + client.set_request_handler("sessionFs.readdir", handle_session_fs_readdir) + async def handle_session_fs_readdir_with_types(params: dict) -> dict | None: request = SessionFSReaddirWithTypesRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) result = await handler.readdir_with_types(request) return result.to_dict() + client.set_request_handler("sessionFs.readdirWithTypes", handle_session_fs_readdir_with_types) + async def handle_session_fs_rm(params: dict) -> dict | None: request = SessionFSRmRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) await handler.rm(request) return None + client.set_request_handler("sessionFs.rm", handle_session_fs_rm) + async def handle_session_fs_rename(params: dict) -> dict | None: request = SessionFSRenameRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") + if handler is None: + raise RuntimeError( + f"No session_fs handler registered for session: {request.session_id}" + ) await handler.rename(request) return None + client.set_request_handler("sessionFs.rename", handle_session_fs_rename) From 9a214e6325441769d15354a59ab73848456742ea Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 14 Apr 2026 22:33:40 +0000 Subject: [PATCH 3/5] placeholder Agent-Logs-Url: https://github.com/github/copilot-sdk/sessions/a6ce684b-599e-45bd-956a-c351c5699f53 Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> --- python/copilot/generated/rpc.py | 1518 ++++++------------------------- 1 file changed, 303 insertions(+), 1215 deletions(-) diff --git a/python/copilot/generated/rpc.py b/python/copilot/generated/rpc.py index d1f4338ef..19a2660d5 100644 --- a/python/copilot/generated/rpc.py +++ b/python/copilot/generated/rpc.py @@ -10,32 +10,31 @@ from collections.abc import Callable from dataclasses import dataclass +from typing import Protocol + + +from dataclasses import dataclass +from typing import Any, TypeVar, Callable, cast from datetime import datetime from enum import Enum -from typing import Any, Protocol, TypeVar, cast from uuid import UUID - import dateutil.parser T = TypeVar("T") EnumT = TypeVar("EnumT", bound=Enum) - def from_str(x: Any) -> str: assert isinstance(x, str) return x - def from_int(x: Any) -> int: assert isinstance(x, int) and not isinstance(x, bool) return x - def from_none(x: Any) -> Any: assert x is None return x - def from_union(fs, x): for f in fs: try: @@ -44,46 +43,37 @@ def from_union(fs, x): pass assert False - def from_float(x: Any) -> float: assert isinstance(x, (float, int)) and not isinstance(x, bool) return float(x) - def to_float(x: Any) -> float: assert isinstance(x, (int, float)) return x - def from_list(f: Callable[[Any], T], x: Any) -> list[T]: assert isinstance(x, list) return [f(y) for y in x] - def to_class(c: type[T], x: Any) -> dict: assert isinstance(x, c) return cast(Any, x).to_dict() - def from_bool(x: Any) -> bool: assert isinstance(x, bool) return x - def from_dict(f: Callable[[Any], T], x: Any) -> dict[str, T]: assert isinstance(x, dict) - return {k: f(v) for (k, v) in x.items()} - + return { k: f(v) for (k, v) in x.items() } def from_datetime(x: Any) -> datetime: return dateutil.parser.parse(x) - def to_enum(c: type[EnumT], x: Any) -> EnumT: assert isinstance(x, c) return x.value - @dataclass class PingResult: message: str @@ -96,7 +86,7 @@ class PingResult: """Server timestamp in milliseconds""" @staticmethod - def from_dict(obj: Any) -> "PingResult": + def from_dict(obj: Any) -> 'PingResult': assert isinstance(obj, dict) message = from_str(obj.get("message")) protocol_version = from_int(obj.get("protocolVersion")) @@ -110,14 +100,13 @@ def to_dict(self) -> dict: result["timestamp"] = from_int(self.timestamp) return result - @dataclass class PingRequest: message: str | None = None """Optional message to echo back""" @staticmethod - def from_dict(obj: Any) -> "PingRequest": + def from_dict(obj: Any) -> 'PingRequest': assert isinstance(obj, dict) message = from_union([from_str, from_none], obj.get("message")) return PingRequest(message) @@ -128,7 +117,6 @@ def to_dict(self) -> dict: result["message"] = from_union([from_str, from_none], self.message) return result - @dataclass class ModelBilling: """Billing information""" @@ -137,7 +125,7 @@ class ModelBilling: """Billing cost multiplier relative to the base rate""" @staticmethod - def from_dict(obj: Any) -> "ModelBilling": + def from_dict(obj: Any) -> 'ModelBilling': assert isinstance(obj, dict) multiplier = from_float(obj.get("multiplier")) return ModelBilling(multiplier) @@ -147,7 +135,6 @@ def to_dict(self) -> dict: result["multiplier"] = to_float(self.multiplier) return result - @dataclass class ModelCapabilitiesLimitsVision: """Vision-specific limits""" @@ -162,14 +149,12 @@ class ModelCapabilitiesLimitsVision: """MIME types the model accepts""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesLimitsVision": + def from_dict(obj: Any) -> 'ModelCapabilitiesLimitsVision': assert isinstance(obj, dict) max_prompt_image_size = from_int(obj.get("max_prompt_image_size")) max_prompt_images = from_int(obj.get("max_prompt_images")) supported_media_types = from_list(from_str, obj.get("supported_media_types")) - return ModelCapabilitiesLimitsVision( - max_prompt_image_size, max_prompt_images, supported_media_types - ) + return ModelCapabilitiesLimitsVision(max_prompt_image_size, max_prompt_images, supported_media_types) def to_dict(self) -> dict: result: dict = {} @@ -178,7 +163,6 @@ def to_dict(self) -> dict: result["supported_media_types"] = from_list(from_str, self.supported_media_types) return result - @dataclass class ModelCapabilitiesLimits: """Token limits for prompts, outputs, and context window""" @@ -196,15 +180,13 @@ class ModelCapabilitiesLimits: """Vision-specific limits""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesLimits": + def from_dict(obj: Any) -> 'ModelCapabilitiesLimits': assert isinstance(obj, dict) max_context_window_tokens = from_int(obj.get("max_context_window_tokens")) max_output_tokens = from_union([from_int, from_none], obj.get("max_output_tokens")) max_prompt_tokens = from_union([from_int, from_none], obj.get("max_prompt_tokens")) vision = from_union([ModelCapabilitiesLimitsVision.from_dict, from_none], obj.get("vision")) - return ModelCapabilitiesLimits( - max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision - ) + return ModelCapabilitiesLimits(max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision) def to_dict(self) -> dict: result: dict = {} @@ -214,12 +196,9 @@ def to_dict(self) -> dict: if self.max_prompt_tokens is not None: result["max_prompt_tokens"] = from_union([from_int, from_none], self.max_prompt_tokens) if self.vision is not None: - result["vision"] = from_union( - [lambda x: to_class(ModelCapabilitiesLimitsVision, x), from_none], self.vision - ) + result["vision"] = from_union([lambda x: to_class(ModelCapabilitiesLimitsVision, x), from_none], self.vision) return result - @dataclass class ModelCapabilitiesSupports: """Feature flags indicating what the model supports""" @@ -231,7 +210,7 @@ class ModelCapabilitiesSupports: """Whether this model supports vision/image input""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesSupports": + def from_dict(obj: Any) -> 'ModelCapabilitiesSupports': assert isinstance(obj, dict) reasoning_effort = from_union([from_bool, from_none], obj.get("reasoningEffort")) vision = from_union([from_bool, from_none], obj.get("vision")) @@ -245,7 +224,6 @@ def to_dict(self) -> dict: result["vision"] = from_union([from_bool, from_none], self.vision) return result - @dataclass class ModelCapabilities: """Model capabilities and limits""" @@ -257,7 +235,7 @@ class ModelCapabilities: """Feature flags indicating what the model supports""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilities": + def from_dict(obj: Any) -> 'ModelCapabilities': assert isinstance(obj, dict) limits = ModelCapabilitiesLimits.from_dict(obj.get("limits")) supports = ModelCapabilitiesSupports.from_dict(obj.get("supports")) @@ -269,7 +247,6 @@ def to_dict(self) -> dict: result["supports"] = to_class(ModelCapabilitiesSupports, self.supports) return result - @dataclass class ModelPolicy: """Policy state (if applicable)""" @@ -281,7 +258,7 @@ class ModelPolicy: """Usage terms or conditions for this model""" @staticmethod - def from_dict(obj: Any) -> "ModelPolicy": + def from_dict(obj: Any) -> 'ModelPolicy': assert isinstance(obj, dict) state = from_str(obj.get("state")) terms = from_str(obj.get("terms")) @@ -293,7 +270,6 @@ def to_dict(self) -> dict: result["terms"] = from_str(self.terms) return result - @dataclass class Model: capabilities: ModelCapabilities @@ -318,28 +294,16 @@ class Model: """Supported reasoning effort levels (only present if model supports reasoning effort)""" @staticmethod - def from_dict(obj: Any) -> "Model": + def from_dict(obj: Any) -> 'Model': assert isinstance(obj, dict) capabilities = ModelCapabilities.from_dict(obj.get("capabilities")) id = from_str(obj.get("id")) name = from_str(obj.get("name")) billing = from_union([ModelBilling.from_dict, from_none], obj.get("billing")) - default_reasoning_effort = from_union( - [from_str, from_none], obj.get("defaultReasoningEffort") - ) + default_reasoning_effort = from_union([from_str, from_none], obj.get("defaultReasoningEffort")) policy = from_union([ModelPolicy.from_dict, from_none], obj.get("policy")) - supported_reasoning_efforts = from_union( - [lambda x: from_list(from_str, x), from_none], obj.get("supportedReasoningEfforts") - ) - return Model( - capabilities, - id, - name, - billing, - default_reasoning_effort, - policy, - supported_reasoning_efforts, - ) + supported_reasoning_efforts = from_union([lambda x: from_list(from_str, x), from_none], obj.get("supportedReasoningEfforts")) + return Model(capabilities, id, name, billing, default_reasoning_effort, policy, supported_reasoning_efforts) def to_dict(self) -> dict: result: dict = {} @@ -347,31 +311,22 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) result["name"] = from_str(self.name) if self.billing is not None: - result["billing"] = from_union( - [lambda x: to_class(ModelBilling, x), from_none], self.billing - ) + result["billing"] = from_union([lambda x: to_class(ModelBilling, x), from_none], self.billing) if self.default_reasoning_effort is not None: - result["defaultReasoningEffort"] = from_union( - [from_str, from_none], self.default_reasoning_effort - ) + result["defaultReasoningEffort"] = from_union([from_str, from_none], self.default_reasoning_effort) if self.policy is not None: - result["policy"] = from_union( - [lambda x: to_class(ModelPolicy, x), from_none], self.policy - ) + result["policy"] = from_union([lambda x: to_class(ModelPolicy, x), from_none], self.policy) if self.supported_reasoning_efforts is not None: - result["supportedReasoningEfforts"] = from_union( - [lambda x: from_list(from_str, x), from_none], self.supported_reasoning_efforts - ) + result["supportedReasoningEfforts"] = from_union([lambda x: from_list(from_str, x), from_none], self.supported_reasoning_efforts) return result - @dataclass class ModelList: models: list[Model] """List of available models with full metadata""" @staticmethod - def from_dict(obj: Any) -> "ModelList": + def from_dict(obj: Any) -> 'ModelList': assert isinstance(obj, dict) models = from_list(Model.from_dict, obj.get("models")) return ModelList(models) @@ -381,7 +336,6 @@ def to_dict(self) -> dict: result["models"] = from_list(lambda x: to_class(Model, x), self.models) return result - @dataclass class Tool: description: str @@ -401,15 +355,13 @@ class Tool: """JSON Schema for the tool's input parameters""" @staticmethod - def from_dict(obj: Any) -> "Tool": + def from_dict(obj: Any) -> 'Tool': assert isinstance(obj, dict) description = from_str(obj.get("description")) name = from_str(obj.get("name")) instructions = from_union([from_str, from_none], obj.get("instructions")) namespaced_name = from_union([from_str, from_none], obj.get("namespacedName")) - parameters = from_union( - [lambda x: from_dict(lambda x: x, x), from_none], obj.get("parameters") - ) + parameters = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("parameters")) return Tool(description, name, instructions, namespaced_name, parameters) def to_dict(self) -> dict: @@ -421,19 +373,16 @@ def to_dict(self) -> dict: if self.namespaced_name is not None: result["namespacedName"] = from_union([from_str, from_none], self.namespaced_name) if self.parameters is not None: - result["parameters"] = from_union( - [lambda x: from_dict(lambda x: x, x), from_none], self.parameters - ) + result["parameters"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.parameters) return result - @dataclass class ToolList: tools: list[Tool] """List of available built-in tools with metadata""" @staticmethod - def from_dict(obj: Any) -> "ToolList": + def from_dict(obj: Any) -> 'ToolList': assert isinstance(obj, dict) tools = from_list(Tool.from_dict, obj.get("tools")) return ToolList(tools) @@ -443,7 +392,6 @@ def to_dict(self) -> dict: result["tools"] = from_list(lambda x: to_class(Tool, x), self.tools) return result - @dataclass class ToolsListRequest: model: str | None = None @@ -452,7 +400,7 @@ class ToolsListRequest: """ @staticmethod - def from_dict(obj: Any) -> "ToolsListRequest": + def from_dict(obj: Any) -> 'ToolsListRequest': assert isinstance(obj, dict) model = from_union([from_str, from_none], obj.get("model")) return ToolsListRequest(model) @@ -463,7 +411,6 @@ def to_dict(self) -> dict: result["model"] = from_union([from_str, from_none], self.model) return result - @dataclass class AccountQuotaSnapshot: entitlement_requests: int @@ -485,71 +432,54 @@ class AccountQuotaSnapshot: """Date when the quota resets (ISO 8601)""" @staticmethod - def from_dict(obj: Any) -> "AccountQuotaSnapshot": + def from_dict(obj: Any) -> 'AccountQuotaSnapshot': assert isinstance(obj, dict) entitlement_requests = from_int(obj.get("entitlementRequests")) overage = from_int(obj.get("overage")) - overage_allowed_with_exhausted_quota = from_bool( - obj.get("overageAllowedWithExhaustedQuota") - ) + overage_allowed_with_exhausted_quota = from_bool(obj.get("overageAllowedWithExhaustedQuota")) remaining_percentage = from_float(obj.get("remainingPercentage")) used_requests = from_int(obj.get("usedRequests")) reset_date = from_union([from_datetime, from_none], obj.get("resetDate")) - return AccountQuotaSnapshot( - entitlement_requests, - overage, - overage_allowed_with_exhausted_quota, - remaining_percentage, - used_requests, - reset_date, - ) + return AccountQuotaSnapshot(entitlement_requests, overage, overage_allowed_with_exhausted_quota, remaining_percentage, used_requests, reset_date) def to_dict(self) -> dict: result: dict = {} result["entitlementRequests"] = from_int(self.entitlement_requests) result["overage"] = from_int(self.overage) - result["overageAllowedWithExhaustedQuota"] = from_bool( - self.overage_allowed_with_exhausted_quota - ) + result["overageAllowedWithExhaustedQuota"] = from_bool(self.overage_allowed_with_exhausted_quota) result["remainingPercentage"] = to_float(self.remaining_percentage) result["usedRequests"] = from_int(self.used_requests) if self.reset_date is not None: result["resetDate"] = from_union([lambda x: x.isoformat(), from_none], self.reset_date) return result - @dataclass class AccountGetQuotaResult: quota_snapshots: dict[str, AccountQuotaSnapshot] """Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)""" @staticmethod - def from_dict(obj: Any) -> "AccountGetQuotaResult": + def from_dict(obj: Any) -> 'AccountGetQuotaResult': assert isinstance(obj, dict) quota_snapshots = from_dict(AccountQuotaSnapshot.from_dict, obj.get("quotaSnapshots")) return AccountGetQuotaResult(quota_snapshots) def to_dict(self) -> dict: result: dict = {} - result["quotaSnapshots"] = from_dict( - lambda x: to_class(AccountQuotaSnapshot, x), self.quota_snapshots - ) + result["quotaSnapshots"] = from_dict(lambda x: to_class(AccountQuotaSnapshot, x), self.quota_snapshots) return result - class MCPConfigFilterMappingString(Enum): HIDDEN_CHARACTERS = "hidden_characters" MARKDOWN = "markdown" NONE = "none" - class MCPConfigType(Enum): HTTP = "http" LOCAL = "local" SSE = "sse" STDIO = "stdio" - @dataclass class MCPConfigServer: """MCP server configuration (local/stdio or remote/http)""" @@ -558,9 +488,7 @@ class MCPConfigServer: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: ( - dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None - ) = None + filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -575,20 +503,13 @@ class MCPConfigServer: url: str | None = None @staticmethod - def from_dict(obj: Any) -> "MCPConfigServer": + def from_dict(obj: Any) -> 'MCPConfigServer': assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union( - [ - lambda x: from_dict(MCPConfigFilterMappingString, x), - MCPConfigFilterMappingString, - from_none, - ], - obj.get("filterMapping"), - ) + filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -597,21 +518,7 @@ def from_dict(obj: Any) -> "MCPConfigServer": oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigServer( - args, - command, - cwd, - env, - filter_mapping, - is_default_server, - timeout, - tools, - type, - headers, - oauth_client_id, - oauth_public_client, - url, - ) + return MCPConfigServer(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) def to_dict(self) -> dict: result: dict = {} @@ -624,14 +531,7 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union( - [ - lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), - lambda x: to_enum(MCPConfigFilterMappingString, x), - from_none, - ], - self.filter_mapping, - ) + result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -641,27 +541,22 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union( - [lambda x: from_dict(from_str, x), from_none], self.headers - ) + result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union( - [from_bool, from_none], self.oauth_public_client - ) + result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result - @dataclass class MCPConfigList: servers: dict[str, MCPConfigServer] """All MCP servers from user config, keyed by name""" @staticmethod - def from_dict(obj: Any) -> "MCPConfigList": + def from_dict(obj: Any) -> 'MCPConfigList': assert isinstance(obj, dict) servers = from_dict(MCPConfigServer.from_dict, obj.get("servers")) return MCPConfigList(servers) @@ -671,7 +566,6 @@ def to_dict(self) -> dict: result["servers"] = from_dict(lambda x: to_class(MCPConfigServer, x), self.servers) return result - @dataclass class MCPConfigAddConfig: """MCP server configuration (local/stdio or remote/http)""" @@ -680,9 +574,7 @@ class MCPConfigAddConfig: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: ( - dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None - ) = None + filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -697,20 +589,13 @@ class MCPConfigAddConfig: url: str | None = None @staticmethod - def from_dict(obj: Any) -> "MCPConfigAddConfig": + def from_dict(obj: Any) -> 'MCPConfigAddConfig': assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union( - [ - lambda x: from_dict(MCPConfigFilterMappingString, x), - MCPConfigFilterMappingString, - from_none, - ], - obj.get("filterMapping"), - ) + filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -719,21 +604,7 @@ def from_dict(obj: Any) -> "MCPConfigAddConfig": oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigAddConfig( - args, - command, - cwd, - env, - filter_mapping, - is_default_server, - timeout, - tools, - type, - headers, - oauth_client_id, - oauth_public_client, - url, - ) + return MCPConfigAddConfig(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) def to_dict(self) -> dict: result: dict = {} @@ -746,14 +617,7 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union( - [ - lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), - lambda x: to_enum(MCPConfigFilterMappingString, x), - from_none, - ], - self.filter_mapping, - ) + result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -763,20 +627,15 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union( - [lambda x: from_dict(from_str, x), from_none], self.headers - ) + result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union( - [from_bool, from_none], self.oauth_public_client - ) + result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result - @dataclass class MCPConfigAddRequest: config: MCPConfigAddConfig @@ -786,7 +645,7 @@ class MCPConfigAddRequest: """Unique name for the MCP server""" @staticmethod - def from_dict(obj: Any) -> "MCPConfigAddRequest": + def from_dict(obj: Any) -> 'MCPConfigAddRequest': assert isinstance(obj, dict) config = MCPConfigAddConfig.from_dict(obj.get("config")) name = from_str(obj.get("name")) @@ -798,7 +657,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - @dataclass class MCPConfigUpdateConfig: """MCP server configuration (local/stdio or remote/http)""" @@ -807,9 +665,7 @@ class MCPConfigUpdateConfig: command: str | None = None cwd: str | None = None env: dict[str, str] | None = None - filter_mapping: ( - dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None - ) = None + filter_mapping: dict[str, MCPConfigFilterMappingString] | MCPConfigFilterMappingString | None = None is_default_server: bool | None = None timeout: int | None = None """Timeout in milliseconds for tool calls to this server.""" @@ -824,20 +680,13 @@ class MCPConfigUpdateConfig: url: str | None = None @staticmethod - def from_dict(obj: Any) -> "MCPConfigUpdateConfig": + def from_dict(obj: Any) -> 'MCPConfigUpdateConfig': assert isinstance(obj, dict) args = from_union([lambda x: from_list(from_str, x), from_none], obj.get("args")) command = from_union([from_str, from_none], obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) env = from_union([lambda x: from_dict(from_str, x), from_none], obj.get("env")) - filter_mapping = from_union( - [ - lambda x: from_dict(MCPConfigFilterMappingString, x), - MCPConfigFilterMappingString, - from_none, - ], - obj.get("filterMapping"), - ) + filter_mapping = from_union([lambda x: from_dict(MCPConfigFilterMappingString, x), MCPConfigFilterMappingString, from_none], obj.get("filterMapping")) is_default_server = from_union([from_bool, from_none], obj.get("isDefaultServer")) timeout = from_union([from_int, from_none], obj.get("timeout")) tools = from_union([lambda x: from_list(from_str, x), from_none], obj.get("tools")) @@ -846,21 +695,7 @@ def from_dict(obj: Any) -> "MCPConfigUpdateConfig": oauth_client_id = from_union([from_str, from_none], obj.get("oauthClientId")) oauth_public_client = from_union([from_bool, from_none], obj.get("oauthPublicClient")) url = from_union([from_str, from_none], obj.get("url")) - return MCPConfigUpdateConfig( - args, - command, - cwd, - env, - filter_mapping, - is_default_server, - timeout, - tools, - type, - headers, - oauth_client_id, - oauth_public_client, - url, - ) + return MCPConfigUpdateConfig(args, command, cwd, env, filter_mapping, is_default_server, timeout, tools, type, headers, oauth_client_id, oauth_public_client, url) def to_dict(self) -> dict: result: dict = {} @@ -873,14 +708,7 @@ def to_dict(self) -> dict: if self.env is not None: result["env"] = from_union([lambda x: from_dict(from_str, x), from_none], self.env) if self.filter_mapping is not None: - result["filterMapping"] = from_union( - [ - lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), - lambda x: to_enum(MCPConfigFilterMappingString, x), - from_none, - ], - self.filter_mapping, - ) + result["filterMapping"] = from_union([lambda x: from_dict(lambda x: to_enum(MCPConfigFilterMappingString, x), x), lambda x: to_enum(MCPConfigFilterMappingString, x), from_none], self.filter_mapping) if self.is_default_server is not None: result["isDefaultServer"] = from_union([from_bool, from_none], self.is_default_server) if self.timeout is not None: @@ -890,20 +718,15 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(MCPConfigType, x), from_none], self.type) if self.headers is not None: - result["headers"] = from_union( - [lambda x: from_dict(from_str, x), from_none], self.headers - ) + result["headers"] = from_union([lambda x: from_dict(from_str, x), from_none], self.headers) if self.oauth_client_id is not None: result["oauthClientId"] = from_union([from_str, from_none], self.oauth_client_id) if self.oauth_public_client is not None: - result["oauthPublicClient"] = from_union( - [from_bool, from_none], self.oauth_public_client - ) + result["oauthPublicClient"] = from_union([from_bool, from_none], self.oauth_public_client) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result - @dataclass class MCPConfigUpdateRequest: config: MCPConfigUpdateConfig @@ -913,7 +736,7 @@ class MCPConfigUpdateRequest: """Name of the MCP server to update""" @staticmethod - def from_dict(obj: Any) -> "MCPConfigUpdateRequest": + def from_dict(obj: Any) -> 'MCPConfigUpdateRequest': assert isinstance(obj, dict) config = MCPConfigUpdateConfig.from_dict(obj.get("config")) name = from_str(obj.get("name")) @@ -925,14 +748,13 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - @dataclass class MCPConfigRemoveRequest: name: str """Name of the MCP server to remove""" @staticmethod - def from_dict(obj: Any) -> "MCPConfigRemoveRequest": + def from_dict(obj: Any) -> 'MCPConfigRemoveRequest': assert isinstance(obj, dict) name = from_str(obj.get("name")) return MCPConfigRemoveRequest(name) @@ -942,19 +764,16 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - class MCPServerSource(Enum): """Configuration source - + Configuration source: user, workspace, plugin, or builtin """ - BUILTIN = "builtin" PLUGIN = "plugin" USER = "user" WORKSPACE = "workspace" - class DiscoveredMCPServerType(Enum): """Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)""" @@ -963,7 +782,6 @@ class DiscoveredMCPServerType(Enum): SSE = "sse" STDIO = "stdio" - @dataclass class DiscoveredMCPServer: enabled: bool @@ -979,7 +797,7 @@ class DiscoveredMCPServer: """Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)""" @staticmethod - def from_dict(obj: Any) -> "DiscoveredMCPServer": + def from_dict(obj: Any) -> 'DiscoveredMCPServer': assert isinstance(obj, dict) enabled = from_bool(obj.get("enabled")) name = from_str(obj.get("name")) @@ -993,19 +811,16 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) result["source"] = to_enum(MCPServerSource, self.source) if self.type is not None: - result["type"] = from_union( - [lambda x: to_enum(DiscoveredMCPServerType, x), from_none], self.type - ) + result["type"] = from_union([lambda x: to_enum(DiscoveredMCPServerType, x), from_none], self.type) return result - @dataclass class MCPDiscoverResult: servers: list[DiscoveredMCPServer] """MCP servers discovered from all sources""" @staticmethod - def from_dict(obj: Any) -> "MCPDiscoverResult": + def from_dict(obj: Any) -> 'MCPDiscoverResult': assert isinstance(obj, dict) servers = from_list(DiscoveredMCPServer.from_dict, obj.get("servers")) return MCPDiscoverResult(servers) @@ -1015,14 +830,13 @@ def to_dict(self) -> dict: result["servers"] = from_list(lambda x: to_class(DiscoveredMCPServer, x), self.servers) return result - @dataclass class MCPDiscoverRequest: working_directory: str | None = None """Working directory used as context for discovery (e.g., plugin resolution)""" @staticmethod - def from_dict(obj: Any) -> "MCPDiscoverRequest": + def from_dict(obj: Any) -> 'MCPDiscoverRequest': assert isinstance(obj, dict) working_directory = from_union([from_str, from_none], obj.get("workingDirectory")) return MCPDiscoverRequest(working_directory) @@ -1033,14 +847,13 @@ def to_dict(self) -> dict: result["workingDirectory"] = from_union([from_str, from_none], self.working_directory) return result - @dataclass class SessionFSSetProviderResult: success: bool """Whether the provider was set successfully""" @staticmethod - def from_dict(obj: Any) -> "SessionFSSetProviderResult": + def from_dict(obj: Any) -> 'SessionFSSetProviderResult': assert isinstance(obj, dict) success = from_bool(obj.get("success")) return SessionFSSetProviderResult(success) @@ -1050,14 +863,12 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result - class SessionFSSetProviderConventions(Enum): """Path conventions used by this filesystem""" POSIX = "posix" WINDOWS = "windows" - @dataclass class SessionFSSetProviderRequest: conventions: SessionFSSetProviderConventions @@ -1070,7 +881,7 @@ class SessionFSSetProviderRequest: """Path within each session's SessionFs where the runtime stores files for that session""" @staticmethod - def from_dict(obj: Any) -> "SessionFSSetProviderRequest": + def from_dict(obj: Any) -> 'SessionFSSetProviderRequest': assert isinstance(obj, dict) conventions = SessionFSSetProviderConventions(obj.get("conventions")) initial_cwd = from_str(obj.get("initialCwd")) @@ -1084,7 +895,6 @@ def to_dict(self) -> dict: result["sessionStatePath"] = from_str(self.session_state_path) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SessionsForkResult: @@ -1092,7 +902,7 @@ class SessionsForkResult: """The new forked session's ID""" @staticmethod - def from_dict(obj: Any) -> "SessionsForkResult": + def from_dict(obj: Any) -> 'SessionsForkResult': assert isinstance(obj, dict) session_id = from_str(obj.get("sessionId")) return SessionsForkResult(session_id) @@ -1102,7 +912,6 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SessionsForkRequest: @@ -1115,7 +924,7 @@ class SessionsForkRequest: """ @staticmethod - def from_dict(obj: Any) -> "SessionsForkRequest": + def from_dict(obj: Any) -> 'SessionsForkRequest': assert isinstance(obj, dict) session_id = from_str(obj.get("sessionId")) to_event_id = from_union([from_str, from_none], obj.get("toEventId")) @@ -1128,14 +937,13 @@ def to_dict(self) -> dict: result["toEventId"] = from_union([from_str, from_none], self.to_event_id) return result - @dataclass class CurrentModel: model_id: str | None = None """Currently active model identifier""" @staticmethod - def from_dict(obj: Any) -> "CurrentModel": + def from_dict(obj: Any) -> 'CurrentModel': assert isinstance(obj, dict) model_id = from_union([from_str, from_none], obj.get("modelId")) return CurrentModel(model_id) @@ -1146,14 +954,13 @@ def to_dict(self) -> dict: result["modelId"] = from_union([from_str, from_none], self.model_id) return result - @dataclass class ModelSwitchToResult: model_id: str | None = None """Currently active model identifier after the switch""" @staticmethod - def from_dict(obj: Any) -> "ModelSwitchToResult": + def from_dict(obj: Any) -> 'ModelSwitchToResult': assert isinstance(obj, dict) model_id = from_union([from_str, from_none], obj.get("modelId")) return ModelSwitchToResult(model_id) @@ -1164,7 +971,6 @@ def to_dict(self) -> dict: result["modelId"] = from_union([from_str, from_none], self.model_id) return result - @dataclass class ModelCapabilitiesOverrideLimitsVision: max_prompt_image_size: int | None = None @@ -1177,32 +983,23 @@ class ModelCapabilitiesOverrideLimitsVision: """MIME types the model accepts""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesOverrideLimitsVision": + def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideLimitsVision': assert isinstance(obj, dict) max_prompt_image_size = from_union([from_int, from_none], obj.get("max_prompt_image_size")) max_prompt_images = from_union([from_int, from_none], obj.get("max_prompt_images")) - supported_media_types = from_union( - [lambda x: from_list(from_str, x), from_none], obj.get("supported_media_types") - ) - return ModelCapabilitiesOverrideLimitsVision( - max_prompt_image_size, max_prompt_images, supported_media_types - ) + supported_media_types = from_union([lambda x: from_list(from_str, x), from_none], obj.get("supported_media_types")) + return ModelCapabilitiesOverrideLimitsVision(max_prompt_image_size, max_prompt_images, supported_media_types) def to_dict(self) -> dict: result: dict = {} if self.max_prompt_image_size is not None: - result["max_prompt_image_size"] = from_union( - [from_int, from_none], self.max_prompt_image_size - ) + result["max_prompt_image_size"] = from_union([from_int, from_none], self.max_prompt_image_size) if self.max_prompt_images is not None: result["max_prompt_images"] = from_union([from_int, from_none], self.max_prompt_images) if self.supported_media_types is not None: - result["supported_media_types"] = from_union( - [lambda x: from_list(from_str, x), from_none], self.supported_media_types - ) + result["supported_media_types"] = from_union([lambda x: from_list(from_str, x), from_none], self.supported_media_types) return result - @dataclass class ModelCapabilitiesOverrideLimits: """Token limits for prompts, outputs, and context window""" @@ -1215,38 +1012,26 @@ class ModelCapabilitiesOverrideLimits: vision: ModelCapabilitiesOverrideLimitsVision | None = None @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesOverrideLimits": + def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideLimits': assert isinstance(obj, dict) - max_context_window_tokens = from_union( - [from_int, from_none], obj.get("max_context_window_tokens") - ) + max_context_window_tokens = from_union([from_int, from_none], obj.get("max_context_window_tokens")) max_output_tokens = from_union([from_int, from_none], obj.get("max_output_tokens")) max_prompt_tokens = from_union([from_int, from_none], obj.get("max_prompt_tokens")) - vision = from_union( - [ModelCapabilitiesOverrideLimitsVision.from_dict, from_none], obj.get("vision") - ) - return ModelCapabilitiesOverrideLimits( - max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision - ) + vision = from_union([ModelCapabilitiesOverrideLimitsVision.from_dict, from_none], obj.get("vision")) + return ModelCapabilitiesOverrideLimits(max_context_window_tokens, max_output_tokens, max_prompt_tokens, vision) def to_dict(self) -> dict: result: dict = {} if self.max_context_window_tokens is not None: - result["max_context_window_tokens"] = from_union( - [from_int, from_none], self.max_context_window_tokens - ) + result["max_context_window_tokens"] = from_union([from_int, from_none], self.max_context_window_tokens) if self.max_output_tokens is not None: result["max_output_tokens"] = from_union([from_int, from_none], self.max_output_tokens) if self.max_prompt_tokens is not None: result["max_prompt_tokens"] = from_union([from_int, from_none], self.max_prompt_tokens) if self.vision is not None: - result["vision"] = from_union( - [lambda x: to_class(ModelCapabilitiesOverrideLimitsVision, x), from_none], - self.vision, - ) + result["vision"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideLimitsVision, x), from_none], self.vision) return result - @dataclass class ModelCapabilitiesOverrideSupports: """Feature flags indicating what the model supports""" @@ -1255,7 +1040,7 @@ class ModelCapabilitiesOverrideSupports: vision: bool | None = None @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesOverrideSupports": + def from_dict(obj: Any) -> 'ModelCapabilitiesOverrideSupports': assert isinstance(obj, dict) reasoning_effort = from_union([from_bool, from_none], obj.get("reasoningEffort")) vision = from_union([from_bool, from_none], obj.get("vision")) @@ -1269,7 +1054,6 @@ def to_dict(self) -> dict: result["vision"] = from_union([from_bool, from_none], self.vision) return result - @dataclass class ModelCapabilitiesOverride: """Override individual model capabilities resolved by the runtime""" @@ -1281,29 +1065,20 @@ class ModelCapabilitiesOverride: """Feature flags indicating what the model supports""" @staticmethod - def from_dict(obj: Any) -> "ModelCapabilitiesOverride": + def from_dict(obj: Any) -> 'ModelCapabilitiesOverride': assert isinstance(obj, dict) - limits = from_union( - [ModelCapabilitiesOverrideLimits.from_dict, from_none], obj.get("limits") - ) - supports = from_union( - [ModelCapabilitiesOverrideSupports.from_dict, from_none], obj.get("supports") - ) + limits = from_union([ModelCapabilitiesOverrideLimits.from_dict, from_none], obj.get("limits")) + supports = from_union([ModelCapabilitiesOverrideSupports.from_dict, from_none], obj.get("supports")) return ModelCapabilitiesOverride(limits, supports) def to_dict(self) -> dict: result: dict = {} if self.limits is not None: - result["limits"] = from_union( - [lambda x: to_class(ModelCapabilitiesOverrideLimits, x), from_none], self.limits - ) + result["limits"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideLimits, x), from_none], self.limits) if self.supports is not None: - result["supports"] = from_union( - [lambda x: to_class(ModelCapabilitiesOverrideSupports, x), from_none], self.supports - ) + result["supports"] = from_union([lambda x: to_class(ModelCapabilitiesOverrideSupports, x), from_none], self.supports) return result - @dataclass class ModelSwitchToRequest: model_id: str @@ -1316,12 +1091,10 @@ class ModelSwitchToRequest: """Reasoning effort level to use for the model""" @staticmethod - def from_dict(obj: Any) -> "ModelSwitchToRequest": + def from_dict(obj: Any) -> 'ModelSwitchToRequest': assert isinstance(obj, dict) model_id = from_str(obj.get("modelId")) - model_capabilities = from_union( - [ModelCapabilitiesOverride.from_dict, from_none], obj.get("modelCapabilities") - ) + model_capabilities = from_union([ModelCapabilitiesOverride.from_dict, from_none], obj.get("modelCapabilities")) reasoning_effort = from_union([from_str, from_none], obj.get("reasoningEffort")) return ModelSwitchToRequest(model_id, model_capabilities, reasoning_effort) @@ -1329,15 +1102,11 @@ def to_dict(self) -> dict: result: dict = {} result["modelId"] = from_str(self.model_id) if self.model_capabilities is not None: - result["modelCapabilities"] = from_union( - [lambda x: to_class(ModelCapabilitiesOverride, x), from_none], - self.model_capabilities, - ) + result["modelCapabilities"] = from_union([lambda x: to_class(ModelCapabilitiesOverride, x), from_none], self.model_capabilities) if self.reasoning_effort is not None: result["reasoningEffort"] = from_union([from_str, from_none], self.reasoning_effort) return result - class SessionMode(Enum): """The agent mode. Valid values: "interactive", "plan", "autopilot".""" @@ -1345,14 +1114,13 @@ class SessionMode(Enum): INTERACTIVE = "interactive" PLAN = "plan" - @dataclass class ModeSetRequest: mode: SessionMode """The agent mode. Valid values: "interactive", "plan", "autopilot".""" @staticmethod - def from_dict(obj: Any) -> "ModeSetRequest": + def from_dict(obj: Any) -> 'ModeSetRequest': assert isinstance(obj, dict) mode = SessionMode(obj.get("mode")) return ModeSetRequest(mode) @@ -1362,14 +1130,13 @@ def to_dict(self) -> dict: result["mode"] = to_enum(SessionMode, self.mode) return result - @dataclass class NameGetResult: name: str | None = None """The session name, falling back to the auto-generated summary, or null if neither exists""" @staticmethod - def from_dict(obj: Any) -> "NameGetResult": + def from_dict(obj: Any) -> 'NameGetResult': assert isinstance(obj, dict) name = from_union([from_none, from_str], obj.get("name")) return NameGetResult(name) @@ -1379,14 +1146,13 @@ def to_dict(self) -> dict: result["name"] = from_union([from_none, from_str], self.name) return result - @dataclass class NameSetRequest: name: str """New session name (1–100 characters, trimmed of leading/trailing whitespace)""" @staticmethod - def from_dict(obj: Any) -> "NameSetRequest": + def from_dict(obj: Any) -> 'NameSetRequest': assert isinstance(obj, dict) name = from_str(obj.get("name")) return NameSetRequest(name) @@ -1396,7 +1162,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - @dataclass class PlanReadResult: exists: bool @@ -1409,7 +1174,7 @@ class PlanReadResult: """Absolute file path of the plan file, or null if workspace is not enabled""" @staticmethod - def from_dict(obj: Any) -> "PlanReadResult": + def from_dict(obj: Any) -> 'PlanReadResult': assert isinstance(obj, dict) exists = from_bool(obj.get("exists")) content = from_union([from_none, from_str], obj.get("content")) @@ -1423,14 +1188,13 @@ def to_dict(self) -> dict: result["path"] = from_union([from_none, from_str], self.path) return result - @dataclass class PlanUpdateRequest: content: str """The new content for the plan file""" @staticmethod - def from_dict(obj: Any) -> "PlanUpdateRequest": + def from_dict(obj: Any) -> 'PlanUpdateRequest': assert isinstance(obj, dict) content = from_str(obj.get("content")) return PlanUpdateRequest(content) @@ -1440,18 +1204,15 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result - class HostType(Enum): ADO = "ado" GITHUB = "github" - class SessionSyncLevel(Enum): LOCAL = "local" REPO_AND_USER = "repo_and_user" USER = "user" - @dataclass class Workspace: id: UUID @@ -1471,7 +1232,7 @@ class Workspace: updated_at: datetime | None = None @staticmethod - def from_dict(obj: Any) -> "Workspace": + def from_dict(obj: Any) -> 'Workspace': assert isinstance(obj, dict) id = UUID(obj.get("id")) branch = from_union([from_str, from_none], obj.get("branch")) @@ -1484,29 +1245,11 @@ def from_dict(obj: Any) -> "Workspace": mc_task_id = from_union([from_str, from_none], obj.get("mc_task_id")) name = from_union([from_str, from_none], obj.get("name")) repository = from_union([from_str, from_none], obj.get("repository")) - session_sync_level = from_union( - [SessionSyncLevel, from_none], obj.get("session_sync_level") - ) + session_sync_level = from_union([SessionSyncLevel, from_none], obj.get("session_sync_level")) summary = from_union([from_str, from_none], obj.get("summary")) summary_count = from_union([from_int, from_none], obj.get("summary_count")) updated_at = from_union([from_datetime, from_none], obj.get("updated_at")) - return Workspace( - id, - branch, - created_at, - cwd, - git_root, - host_type, - mc_last_event_id, - mc_session_id, - mc_task_id, - name, - repository, - session_sync_level, - summary, - summary_count, - updated_at, - ) + return Workspace(id, branch, created_at, cwd, git_root, host_type, mc_last_event_id, mc_session_id, mc_task_id, name, repository, session_sync_level, summary, summary_count, updated_at) def to_dict(self) -> dict: result: dict = {} @@ -1520,9 +1263,7 @@ def to_dict(self) -> dict: if self.git_root is not None: result["git_root"] = from_union([from_str, from_none], self.git_root) if self.host_type is not None: - result["host_type"] = from_union( - [lambda x: to_enum(HostType, x), from_none], self.host_type - ) + result["host_type"] = from_union([lambda x: to_enum(HostType, x), from_none], self.host_type) if self.mc_last_event_id is not None: result["mc_last_event_id"] = from_union([from_str, from_none], self.mc_last_event_id) if self.mc_session_id is not None: @@ -1534,9 +1275,7 @@ def to_dict(self) -> dict: if self.repository is not None: result["repository"] = from_union([from_str, from_none], self.repository) if self.session_sync_level is not None: - result["session_sync_level"] = from_union( - [lambda x: to_enum(SessionSyncLevel, x), from_none], self.session_sync_level - ) + result["session_sync_level"] = from_union([lambda x: to_enum(SessionSyncLevel, x), from_none], self.session_sync_level) if self.summary is not None: result["summary"] = from_union([from_str, from_none], self.summary) if self.summary_count is not None: @@ -1545,33 +1284,29 @@ def to_dict(self) -> dict: result["updated_at"] = from_union([lambda x: x.isoformat(), from_none], self.updated_at) return result - @dataclass class WorkspacesGetWorkspaceResult: workspace: Workspace | None = None """Current workspace metadata, or null if not available""" @staticmethod - def from_dict(obj: Any) -> "WorkspacesGetWorkspaceResult": + def from_dict(obj: Any) -> 'WorkspacesGetWorkspaceResult': assert isinstance(obj, dict) workspace = from_union([Workspace.from_dict, from_none], obj.get("workspace")) return WorkspacesGetWorkspaceResult(workspace) def to_dict(self) -> dict: result: dict = {} - result["workspace"] = from_union( - [lambda x: to_class(Workspace, x), from_none], self.workspace - ) + result["workspace"] = from_union([lambda x: to_class(Workspace, x), from_none], self.workspace) return result - @dataclass class WorkspacesListFilesResult: files: list[str] """Relative file paths in the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> "WorkspacesListFilesResult": + def from_dict(obj: Any) -> 'WorkspacesListFilesResult': assert isinstance(obj, dict) files = from_list(from_str, obj.get("files")) return WorkspacesListFilesResult(files) @@ -1581,14 +1316,13 @@ def to_dict(self) -> dict: result["files"] = from_list(from_str, self.files) return result - @dataclass class WorkspacesReadFileResult: content: str """File content as a UTF-8 string""" @staticmethod - def from_dict(obj: Any) -> "WorkspacesReadFileResult": + def from_dict(obj: Any) -> 'WorkspacesReadFileResult': assert isinstance(obj, dict) content = from_str(obj.get("content")) return WorkspacesReadFileResult(content) @@ -1598,14 +1332,13 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result - @dataclass class WorkspacesReadFileRequest: path: str """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> "WorkspacesReadFileRequest": + def from_dict(obj: Any) -> 'WorkspacesReadFileRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) return WorkspacesReadFileRequest(path) @@ -1615,7 +1348,6 @@ def to_dict(self) -> dict: result["path"] = from_str(self.path) return result - @dataclass class WorkspacesCreateFileRequest: content: str @@ -1625,7 +1357,7 @@ class WorkspacesCreateFileRequest: """Relative path within the workspace files directory""" @staticmethod - def from_dict(obj: Any) -> "WorkspacesCreateFileRequest": + def from_dict(obj: Any) -> 'WorkspacesCreateFileRequest': assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -1637,7 +1369,6 @@ def to_dict(self) -> dict: result["path"] = from_str(self.path) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class FleetStartResult: @@ -1645,7 +1376,7 @@ class FleetStartResult: """Whether fleet mode was successfully activated""" @staticmethod - def from_dict(obj: Any) -> "FleetStartResult": + def from_dict(obj: Any) -> 'FleetStartResult': assert isinstance(obj, dict) started = from_bool(obj.get("started")) return FleetStartResult(started) @@ -1655,7 +1386,6 @@ def to_dict(self) -> dict: result["started"] = from_bool(self.started) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class FleetStartRequest: @@ -1663,7 +1393,7 @@ class FleetStartRequest: """Optional user prompt to combine with fleet instructions""" @staticmethod - def from_dict(obj: Any) -> "FleetStartRequest": + def from_dict(obj: Any) -> 'FleetStartRequest': assert isinstance(obj, dict) prompt = from_union([from_str, from_none], obj.get("prompt")) return FleetStartRequest(prompt) @@ -1674,7 +1404,6 @@ def to_dict(self) -> dict: result["prompt"] = from_union([from_str, from_none], self.prompt) return result - @dataclass class Agent: description: str @@ -1687,7 +1416,7 @@ class Agent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> "Agent": + def from_dict(obj: Any) -> 'Agent': assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1701,7 +1430,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentList: @@ -1709,7 +1437,7 @@ class AgentList: """Available custom agents""" @staticmethod - def from_dict(obj: Any) -> "AgentList": + def from_dict(obj: Any) -> 'AgentList': assert isinstance(obj, dict) agents = from_list(Agent.from_dict, obj.get("agents")) return AgentList(agents) @@ -1719,7 +1447,6 @@ def to_dict(self) -> dict: result["agents"] = from_list(lambda x: to_class(Agent, x), self.agents) return result - @dataclass class AgentGetCurrentResultAgent: description: str @@ -1732,7 +1459,7 @@ class AgentGetCurrentResultAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> "AgentGetCurrentResultAgent": + def from_dict(obj: Any) -> 'AgentGetCurrentResultAgent': assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1746,7 +1473,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentGetCurrentResult: @@ -1754,19 +1480,16 @@ class AgentGetCurrentResult: """Currently selected custom agent, or null if using the default agent""" @staticmethod - def from_dict(obj: Any) -> "AgentGetCurrentResult": + def from_dict(obj: Any) -> 'AgentGetCurrentResult': assert isinstance(obj, dict) agent = from_union([AgentGetCurrentResultAgent.from_dict, from_none], obj.get("agent")) return AgentGetCurrentResult(agent) def to_dict(self) -> dict: result: dict = {} - result["agent"] = from_union( - [lambda x: to_class(AgentGetCurrentResultAgent, x), from_none], self.agent - ) + result["agent"] = from_union([lambda x: to_class(AgentGetCurrentResultAgent, x), from_none], self.agent) return result - @dataclass class AgentSelectAgent: """The newly selected custom agent""" @@ -1781,7 +1504,7 @@ class AgentSelectAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> "AgentSelectAgent": + def from_dict(obj: Any) -> 'AgentSelectAgent': assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1795,7 +1518,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentSelectResult: @@ -1803,7 +1525,7 @@ class AgentSelectResult: """The newly selected custom agent""" @staticmethod - def from_dict(obj: Any) -> "AgentSelectResult": + def from_dict(obj: Any) -> 'AgentSelectResult': assert isinstance(obj, dict) agent = AgentSelectAgent.from_dict(obj.get("agent")) return AgentSelectResult(agent) @@ -1813,7 +1535,6 @@ def to_dict(self) -> dict: result["agent"] = to_class(AgentSelectAgent, self.agent) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentSelectRequest: @@ -1821,7 +1542,7 @@ class AgentSelectRequest: """Name of the custom agent to select""" @staticmethod - def from_dict(obj: Any) -> "AgentSelectRequest": + def from_dict(obj: Any) -> 'AgentSelectRequest': assert isinstance(obj, dict) name = from_str(obj.get("name")) return AgentSelectRequest(name) @@ -1831,7 +1552,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - @dataclass class AgentReloadAgent: description: str @@ -1844,7 +1564,7 @@ class AgentReloadAgent: """Unique identifier of the custom agent""" @staticmethod - def from_dict(obj: Any) -> "AgentReloadAgent": + def from_dict(obj: Any) -> 'AgentReloadAgent': assert isinstance(obj, dict) description = from_str(obj.get("description")) display_name = from_str(obj.get("displayName")) @@ -1858,7 +1578,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class AgentReloadResult: @@ -1866,7 +1585,7 @@ class AgentReloadResult: """Reloaded custom agents""" @staticmethod - def from_dict(obj: Any) -> "AgentReloadResult": + def from_dict(obj: Any) -> 'AgentReloadResult': assert isinstance(obj, dict) agents = from_list(AgentReloadAgent.from_dict, obj.get("agents")) return AgentReloadResult(agents) @@ -1876,7 +1595,6 @@ def to_dict(self) -> dict: result["agents"] = from_list(lambda x: to_class(AgentReloadAgent, x), self.agents) return result - @dataclass class Skill: description: str @@ -1898,7 +1616,7 @@ class Skill: """Absolute path to the skill file""" @staticmethod - def from_dict(obj: Any) -> "Skill": + def from_dict(obj: Any) -> 'Skill': assert isinstance(obj, dict) description = from_str(obj.get("description")) enabled = from_bool(obj.get("enabled")) @@ -1919,7 +1637,6 @@ def to_dict(self) -> dict: result["path"] = from_union([from_str, from_none], self.path) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillList: @@ -1927,7 +1644,7 @@ class SkillList: """Available skills""" @staticmethod - def from_dict(obj: Any) -> "SkillList": + def from_dict(obj: Any) -> 'SkillList': assert isinstance(obj, dict) skills = from_list(Skill.from_dict, obj.get("skills")) return SkillList(skills) @@ -1937,7 +1654,6 @@ def to_dict(self) -> dict: result["skills"] = from_list(lambda x: to_class(Skill, x), self.skills) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillsEnableRequest: @@ -1945,7 +1661,7 @@ class SkillsEnableRequest: """Name of the skill to enable""" @staticmethod - def from_dict(obj: Any) -> "SkillsEnableRequest": + def from_dict(obj: Any) -> 'SkillsEnableRequest': assert isinstance(obj, dict) name = from_str(obj.get("name")) return SkillsEnableRequest(name) @@ -1955,7 +1671,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class SkillsDisableRequest: @@ -1963,7 +1678,7 @@ class SkillsDisableRequest: """Name of the skill to disable""" @staticmethod - def from_dict(obj: Any) -> "SkillsDisableRequest": + def from_dict(obj: Any) -> 'SkillsDisableRequest': assert isinstance(obj, dict) name = from_str(obj.get("name")) return SkillsDisableRequest(name) @@ -1973,7 +1688,6 @@ def to_dict(self) -> dict: result["name"] = from_str(self.name) return result - class MCPServerStatus(Enum): """Connection status: connected, failed, needs-auth, pending, disabled, or not_configured""" @@ -1984,7 +1698,6 @@ class MCPServerStatus(Enum): NOT_CONFIGURED = "not_configured" PENDING = "pending" - @dataclass class MCPServer: name: str @@ -2000,7 +1713,7 @@ class MCPServer: """Configuration source: user, workspace, plugin, or builtin""" @staticmethod - def from_dict(obj: Any) -> "MCPServer": + def from_dict(obj: Any) -> 'MCPServer': assert isinstance(obj, dict) name = from_str(obj.get("name")) status = MCPServerStatus(obj.get("status")) @@ -2015,19 +1728,16 @@ def to_dict(self) -> dict: if self.error is not None: result["error"] = from_union([from_str, from_none], self.error) if self.source is not None: - result["source"] = from_union( - [lambda x: to_enum(MCPServerSource, x), from_none], self.source - ) + result["source"] = from_union([lambda x: to_enum(MCPServerSource, x), from_none], self.source) return result - @dataclass class MCPServerList: servers: list[MCPServer] """Configured MCP servers""" @staticmethod - def from_dict(obj: Any) -> "MCPServerList": + def from_dict(obj: Any) -> 'MCPServerList': assert isinstance(obj, dict) servers = from_list(MCPServer.from_dict, obj.get("servers")) return MCPServerList(servers) @@ -2037,14 +1747,13 @@ def to_dict(self) -> dict: result["servers"] = from_list(lambda x: to_class(MCPServer, x), self.servers) return result - @dataclass class MCPEnableRequest: server_name: str """Name of the MCP server to enable""" @staticmethod - def from_dict(obj: Any) -> "MCPEnableRequest": + def from_dict(obj: Any) -> 'MCPEnableRequest': assert isinstance(obj, dict) server_name = from_str(obj.get("serverName")) return MCPEnableRequest(server_name) @@ -2054,14 +1763,13 @@ def to_dict(self) -> dict: result["serverName"] = from_str(self.server_name) return result - @dataclass class MCPDisableRequest: server_name: str """Name of the MCP server to disable""" @staticmethod - def from_dict(obj: Any) -> "MCPDisableRequest": + def from_dict(obj: Any) -> 'MCPDisableRequest': assert isinstance(obj, dict) server_name = from_str(obj.get("serverName")) return MCPDisableRequest(server_name) @@ -2071,7 +1779,6 @@ def to_dict(self) -> dict: result["serverName"] = from_str(self.server_name) return result - @dataclass class Plugin: enabled: bool @@ -2087,7 +1794,7 @@ class Plugin: """Installed version""" @staticmethod - def from_dict(obj: Any) -> "Plugin": + def from_dict(obj: Any) -> 'Plugin': assert isinstance(obj, dict) enabled = from_bool(obj.get("enabled")) marketplace = from_str(obj.get("marketplace")) @@ -2104,7 +1811,6 @@ def to_dict(self) -> dict: result["version"] = from_union([from_str, from_none], self.version) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class PluginList: @@ -2112,7 +1818,7 @@ class PluginList: """Installed plugins""" @staticmethod - def from_dict(obj: Any) -> "PluginList": + def from_dict(obj: Any) -> 'PluginList': assert isinstance(obj, dict) plugins = from_list(Plugin.from_dict, obj.get("plugins")) return PluginList(plugins) @@ -2122,14 +1828,12 @@ def to_dict(self) -> dict: result["plugins"] = from_list(lambda x: to_class(Plugin, x), self.plugins) return result - class ExtensionSource(Enum): """Discovery source: project (.github/extensions/) or user (~/.copilot/extensions/)""" PROJECT = "project" USER = "user" - class ExtensionStatus(Enum): """Current status: running, disabled, failed, or starting""" @@ -2138,7 +1842,6 @@ class ExtensionStatus(Enum): RUNNING = "running" STARTING = "starting" - @dataclass class Extension: id: str @@ -2157,7 +1860,7 @@ class Extension: """Process ID if the extension is running""" @staticmethod - def from_dict(obj: Any) -> "Extension": + def from_dict(obj: Any) -> 'Extension': assert isinstance(obj, dict) id = from_str(obj.get("id")) name = from_str(obj.get("name")) @@ -2176,7 +1879,6 @@ def to_dict(self) -> dict: result["pid"] = from_union([from_int, from_none], self.pid) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionList: @@ -2184,7 +1886,7 @@ class ExtensionList: """Discovered extensions and their current status""" @staticmethod - def from_dict(obj: Any) -> "ExtensionList": + def from_dict(obj: Any) -> 'ExtensionList': assert isinstance(obj, dict) extensions = from_list(Extension.from_dict, obj.get("extensions")) return ExtensionList(extensions) @@ -2194,7 +1896,6 @@ def to_dict(self) -> dict: result["extensions"] = from_list(lambda x: to_class(Extension, x), self.extensions) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionsEnableRequest: @@ -2202,7 +1903,7 @@ class ExtensionsEnableRequest: """Source-qualified extension ID to enable""" @staticmethod - def from_dict(obj: Any) -> "ExtensionsEnableRequest": + def from_dict(obj: Any) -> 'ExtensionsEnableRequest': assert isinstance(obj, dict) id = from_str(obj.get("id")) return ExtensionsEnableRequest(id) @@ -2212,7 +1913,6 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class ExtensionsDisableRequest: @@ -2220,7 +1920,7 @@ class ExtensionsDisableRequest: """Source-qualified extension ID to disable""" @staticmethod - def from_dict(obj: Any) -> "ExtensionsDisableRequest": + def from_dict(obj: Any) -> 'ExtensionsDisableRequest': assert isinstance(obj, dict) id = from_str(obj.get("id")) return ExtensionsDisableRequest(id) @@ -2230,14 +1930,13 @@ def to_dict(self) -> dict: result["id"] = from_str(self.id) return result - @dataclass class HandleToolCallResult: success: bool """Whether the tool call result was handled successfully""" @staticmethod - def from_dict(obj: Any) -> "HandleToolCallResult": + def from_dict(obj: Any) -> 'HandleToolCallResult': assert isinstance(obj, dict) success = from_bool(obj.get("success")) return HandleToolCallResult(success) @@ -2247,7 +1946,6 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result - @dataclass class ToolCallResult: text_result_for_llm: str @@ -2263,14 +1961,12 @@ class ToolCallResult: """Telemetry data from tool execution""" @staticmethod - def from_dict(obj: Any) -> "ToolCallResult": + def from_dict(obj: Any) -> 'ToolCallResult': assert isinstance(obj, dict) text_result_for_llm = from_str(obj.get("textResultForLlm")) error = from_union([from_str, from_none], obj.get("error")) result_type = from_union([from_str, from_none], obj.get("resultType")) - tool_telemetry = from_union( - [lambda x: from_dict(lambda x: x, x), from_none], obj.get("toolTelemetry") - ) + tool_telemetry = from_union([lambda x: from_dict(lambda x: x, x), from_none], obj.get("toolTelemetry")) return ToolCallResult(text_result_for_llm, error, result_type, tool_telemetry) def to_dict(self) -> dict: @@ -2281,12 +1977,9 @@ def to_dict(self) -> dict: if self.result_type is not None: result["resultType"] = from_union([from_str, from_none], self.result_type) if self.tool_telemetry is not None: - result["toolTelemetry"] = from_union( - [lambda x: from_dict(lambda x: x, x), from_none], self.tool_telemetry - ) + result["toolTelemetry"] = from_union([lambda x: from_dict(lambda x: x, x), from_none], self.tool_telemetry) return result - @dataclass class ToolsHandlePendingToolCallRequest: request_id: str @@ -2299,7 +1992,7 @@ class ToolsHandlePendingToolCallRequest: """Tool call result (string or expanded result object)""" @staticmethod - def from_dict(obj: Any) -> "ToolsHandlePendingToolCallRequest": + def from_dict(obj: Any) -> 'ToolsHandlePendingToolCallRequest': assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) error = from_union([from_str, from_none], obj.get("error")) @@ -2312,19 +2005,16 @@ def to_dict(self) -> dict: if self.error is not None: result["error"] = from_union([from_str, from_none], self.error) if self.result is not None: - result["result"] = from_union( - [lambda x: to_class(ToolCallResult, x), from_str, from_none], self.result - ) + result["result"] = from_union([lambda x: to_class(ToolCallResult, x), from_str, from_none], self.result) return result - @dataclass class CommandsHandlePendingCommandResult: success: bool """Whether the command was handled successfully""" @staticmethod - def from_dict(obj: Any) -> "CommandsHandlePendingCommandResult": + def from_dict(obj: Any) -> 'CommandsHandlePendingCommandResult': assert isinstance(obj, dict) success = from_bool(obj.get("success")) return CommandsHandlePendingCommandResult(success) @@ -2334,7 +2024,6 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result - @dataclass class CommandsHandlePendingCommandRequest: request_id: str @@ -2344,7 +2033,7 @@ class CommandsHandlePendingCommandRequest: """Error message if the command handler failed""" @staticmethod - def from_dict(obj: Any) -> "CommandsHandlePendingCommandRequest": + def from_dict(obj: Any) -> 'CommandsHandlePendingCommandRequest': assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) error = from_union([from_str, from_none], obj.get("error")) @@ -2357,7 +2046,6 @@ def to_dict(self) -> dict: result["error"] = from_union([from_str, from_none], self.error) return result - class UIElicitationResponseAction(Enum): """The user's response: accept (submitted), decline (rejected), or cancel (dismissed)""" @@ -2365,7 +2053,6 @@ class UIElicitationResponseAction(Enum): CANCEL = "cancel" DECLINE = "decline" - @dataclass class UIElicitationResponse: """The elicitation response (accept with form values, decline, or cancel)""" @@ -2377,56 +2064,32 @@ class UIElicitationResponse: """The form values submitted by the user (present when action is 'accept')""" @staticmethod - def from_dict(obj: Any) -> "UIElicitationResponse": + def from_dict(obj: Any) -> 'UIElicitationResponse': assert isinstance(obj, dict) action = UIElicitationResponseAction(obj.get("action")) - content = from_union( - [ - lambda x: from_dict( - lambda x: from_union( - [from_float, from_bool, lambda x: from_list(from_str, x), from_str], x - ), - x, - ), - from_none, - ], - obj.get("content"), - ) + content = from_union([lambda x: from_dict(lambda x: from_union([from_float, from_bool, lambda x: from_list(from_str, x), from_str], x), x), from_none], obj.get("content")) return UIElicitationResponse(action, content) def to_dict(self) -> dict: result: dict = {} result["action"] = to_enum(UIElicitationResponseAction, self.action) if self.content is not None: - result["content"] = from_union( - [ - lambda x: from_dict( - lambda x: from_union( - [to_float, from_bool, lambda x: from_list(from_str, x), from_str], x - ), - x, - ), - from_none, - ], - self.content, - ) + result["content"] = from_union([lambda x: from_dict(lambda x: from_union([to_float, from_bool, lambda x: from_list(from_str, x), from_str], x), x), from_none], self.content) return result - class UIElicitationSchemaPropertyStringFormat(Enum): DATE = "date" DATE_TIME = "date-time" EMAIL = "email" URI = "uri" - @dataclass class UIElicitationArrayAnyOfFieldItemsAnyOf: const: str title: str @staticmethod - def from_dict(obj: Any) -> "UIElicitationArrayAnyOfFieldItemsAnyOf": + def from_dict(obj: Any) -> 'UIElicitationArrayAnyOfFieldItemsAnyOf': assert isinstance(obj, dict) const = from_str(obj.get("const")) title = from_str(obj.get("title")) @@ -2438,11 +2101,9 @@ def to_dict(self) -> dict: result["title"] = from_str(self.title) return result - class ItemsType(Enum): STRING = "string" - @dataclass class UIElicitationArrayFieldItems: enum: list[str] | None = None @@ -2450,14 +2111,11 @@ class UIElicitationArrayFieldItems: any_of: list[UIElicitationArrayAnyOfFieldItemsAnyOf] | None = None @staticmethod - def from_dict(obj: Any) -> "UIElicitationArrayFieldItems": + def from_dict(obj: Any) -> 'UIElicitationArrayFieldItems': assert isinstance(obj, dict) enum = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enum")) type = from_union([ItemsType, from_none], obj.get("type")) - any_of = from_union( - [lambda x: from_list(UIElicitationArrayAnyOfFieldItemsAnyOf.from_dict, x), from_none], - obj.get("anyOf"), - ) + any_of = from_union([lambda x: from_list(UIElicitationArrayAnyOfFieldItemsAnyOf.from_dict, x), from_none], obj.get("anyOf")) return UIElicitationArrayFieldItems(enum, type, any_of) def to_dict(self) -> dict: @@ -2467,25 +2125,16 @@ def to_dict(self) -> dict: if self.type is not None: result["type"] = from_union([lambda x: to_enum(ItemsType, x), from_none], self.type) if self.any_of is not None: - result["anyOf"] = from_union( - [ - lambda x: from_list( - lambda x: to_class(UIElicitationArrayAnyOfFieldItemsAnyOf, x), x - ), - from_none, - ], - self.any_of, - ) + result["anyOf"] = from_union([lambda x: from_list(lambda x: to_class(UIElicitationArrayAnyOfFieldItemsAnyOf, x), x), from_none], self.any_of) return result - @dataclass class UIElicitationStringOneOfFieldOneOf: const: str title: str @staticmethod - def from_dict(obj: Any) -> "UIElicitationStringOneOfFieldOneOf": + def from_dict(obj: Any) -> 'UIElicitationStringOneOfFieldOneOf': assert isinstance(obj, dict) const = from_str(obj.get("const")) title = from_str(obj.get("title")) @@ -2497,7 +2146,6 @@ def to_dict(self) -> dict: result["title"] = from_str(self.title) return result - class UIElicitationSchemaPropertyNumberType(Enum): ARRAY = "array" BOOLEAN = "boolean" @@ -2505,7 +2153,6 @@ class UIElicitationSchemaPropertyNumberType(Enum): NUMBER = "number" STRING = "string" - @dataclass class UIElicitationSchemaProperty: type: UIElicitationSchemaPropertyNumberType @@ -2525,21 +2172,15 @@ class UIElicitationSchemaProperty: minimum: float | None = None @staticmethod - def from_dict(obj: Any) -> "UIElicitationSchemaProperty": + def from_dict(obj: Any) -> 'UIElicitationSchemaProperty': assert isinstance(obj, dict) type = UIElicitationSchemaPropertyNumberType(obj.get("type")) - default = from_union( - [from_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], - obj.get("default"), - ) + default = from_union([from_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], obj.get("default")) description = from_union([from_str, from_none], obj.get("description")) enum = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enum")) enum_names = from_union([lambda x: from_list(from_str, x), from_none], obj.get("enumNames")) title = from_union([from_str, from_none], obj.get("title")) - one_of = from_union( - [lambda x: from_list(UIElicitationStringOneOfFieldOneOf.from_dict, x), from_none], - obj.get("oneOf"), - ) + one_of = from_union([lambda x: from_list(UIElicitationStringOneOfFieldOneOf.from_dict, x), from_none], obj.get("oneOf")) items = from_union([UIElicitationArrayFieldItems.from_dict, from_none], obj.get("items")) max_items = from_union([from_float, from_none], obj.get("maxItems")) min_items = from_union([from_float, from_none], obj.get("minItems")) @@ -2548,65 +2189,31 @@ def from_dict(obj: Any) -> "UIElicitationSchemaProperty": min_length = from_union([from_float, from_none], obj.get("minLength")) maximum = from_union([from_float, from_none], obj.get("maximum")) minimum = from_union([from_float, from_none], obj.get("minimum")) - return UIElicitationSchemaProperty( - type, - default, - description, - enum, - enum_names, - title, - one_of, - items, - max_items, - min_items, - format, - max_length, - min_length, - maximum, - minimum, - ) + return UIElicitationSchemaProperty(type, default, description, enum, enum_names, title, one_of, items, max_items, min_items, format, max_length, min_length, maximum, minimum) def to_dict(self) -> dict: result: dict = {} result["type"] = to_enum(UIElicitationSchemaPropertyNumberType, self.type) if self.default is not None: - result["default"] = from_union( - [to_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], - self.default, - ) + result["default"] = from_union([to_float, from_bool, lambda x: from_list(from_str, x), from_str, from_none], self.default) if self.description is not None: result["description"] = from_union([from_str, from_none], self.description) if self.enum is not None: result["enum"] = from_union([lambda x: from_list(from_str, x), from_none], self.enum) if self.enum_names is not None: - result["enumNames"] = from_union( - [lambda x: from_list(from_str, x), from_none], self.enum_names - ) + result["enumNames"] = from_union([lambda x: from_list(from_str, x), from_none], self.enum_names) if self.title is not None: result["title"] = from_union([from_str, from_none], self.title) if self.one_of is not None: - result["oneOf"] = from_union( - [ - lambda x: from_list( - lambda x: to_class(UIElicitationStringOneOfFieldOneOf, x), x - ), - from_none, - ], - self.one_of, - ) + result["oneOf"] = from_union([lambda x: from_list(lambda x: to_class(UIElicitationStringOneOfFieldOneOf, x), x), from_none], self.one_of) if self.items is not None: - result["items"] = from_union( - [lambda x: to_class(UIElicitationArrayFieldItems, x), from_none], self.items - ) + result["items"] = from_union([lambda x: to_class(UIElicitationArrayFieldItems, x), from_none], self.items) if self.max_items is not None: result["maxItems"] = from_union([to_float, from_none], self.max_items) if self.min_items is not None: result["minItems"] = from_union([to_float, from_none], self.min_items) if self.format is not None: - result["format"] = from_union( - [lambda x: to_enum(UIElicitationSchemaPropertyStringFormat, x), from_none], - self.format, - ) + result["format"] = from_union([lambda x: to_enum(UIElicitationSchemaPropertyStringFormat, x), from_none], self.format) if self.max_length is not None: result["maxLength"] = from_union([to_float, from_none], self.max_length) if self.min_length is not None: @@ -2617,11 +2224,9 @@ def to_dict(self) -> dict: result["minimum"] = from_union([to_float, from_none], self.minimum) return result - class RequestedSchemaType(Enum): OBJECT = "object" - @dataclass class UIElicitationSchema: """JSON Schema describing the form fields to present to the user""" @@ -2636,7 +2241,7 @@ class UIElicitationSchema: """List of required field names""" @staticmethod - def from_dict(obj: Any) -> "UIElicitationSchema": + def from_dict(obj: Any) -> 'UIElicitationSchema': assert isinstance(obj, dict) properties = from_dict(UIElicitationSchemaProperty.from_dict, obj.get("properties")) type = RequestedSchemaType(obj.get("type")) @@ -2645,17 +2250,12 @@ def from_dict(obj: Any) -> "UIElicitationSchema": def to_dict(self) -> dict: result: dict = {} - result["properties"] = from_dict( - lambda x: to_class(UIElicitationSchemaProperty, x), self.properties - ) + result["properties"] = from_dict(lambda x: to_class(UIElicitationSchemaProperty, x), self.properties) result["type"] = to_enum(RequestedSchemaType, self.type) if self.required is not None: - result["required"] = from_union( - [lambda x: from_list(from_str, x), from_none], self.required - ) + result["required"] = from_union([lambda x: from_list(from_str, x), from_none], self.required) return result - @dataclass class UIElicitationRequest: message: str @@ -2665,7 +2265,7 @@ class UIElicitationRequest: """JSON Schema describing the form fields to present to the user""" @staticmethod - def from_dict(obj: Any) -> "UIElicitationRequest": + def from_dict(obj: Any) -> 'UIElicitationRequest': assert isinstance(obj, dict) message = from_str(obj.get("message")) requested_schema = UIElicitationSchema.from_dict(obj.get("requestedSchema")) @@ -2677,7 +2277,6 @@ def to_dict(self) -> dict: result["requestedSchema"] = to_class(UIElicitationSchema, self.requested_schema) return result - @dataclass class UIElicitationResult: success: bool @@ -2686,7 +2285,7 @@ class UIElicitationResult: """ @staticmethod - def from_dict(obj: Any) -> "UIElicitationResult": + def from_dict(obj: Any) -> 'UIElicitationResult': assert isinstance(obj, dict) success = from_bool(obj.get("success")) return UIElicitationResult(success) @@ -2696,7 +2295,6 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result - @dataclass class UIHandlePendingElicitationRequest: request_id: str @@ -2706,7 +2304,7 @@ class UIHandlePendingElicitationRequest: """The elicitation response (accept with form values, decline, or cancel)""" @staticmethod - def from_dict(obj: Any) -> "UIHandlePendingElicitationRequest": + def from_dict(obj: Any) -> 'UIHandlePendingElicitationRequest': assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) result = UIElicitationResponse.from_dict(obj.get("result")) @@ -2718,14 +2316,13 @@ def to_dict(self) -> dict: result["result"] = to_class(UIElicitationResponse, self.result) return result - @dataclass class PermissionRequestResult: success: bool """Whether the permission request was handled successfully""" @staticmethod - def from_dict(obj: Any) -> "PermissionRequestResult": + def from_dict(obj: Any) -> 'PermissionRequestResult': assert isinstance(obj, dict) success = from_bool(obj.get("success")) return PermissionRequestResult(success) @@ -2735,31 +2332,27 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) return result - class Kind(Enum): APPROVED = "approved" DENIED_BY_CONTENT_EXCLUSION_POLICY = "denied-by-content-exclusion-policy" DENIED_BY_PERMISSION_REQUEST_HOOK = "denied-by-permission-request-hook" DENIED_BY_RULES = "denied-by-rules" DENIED_INTERACTIVELY_BY_USER = "denied-interactively-by-user" - DENIED_NO_APPROVAL_RULE_AND_COULD_NOT_REQUEST_FROM_USER = ( - "denied-no-approval-rule-and-could-not-request-from-user" - ) - + DENIED_NO_APPROVAL_RULE_AND_COULD_NOT_REQUEST_FROM_USER = "denied-no-approval-rule-and-could-not-request-from-user" @dataclass class PermissionDecision: kind: Kind """The permission request was approved - + Denied because approval rules explicitly blocked it - + Denied because no approval rule matched and user confirmation was unavailable - + Denied by the user during an interactive prompt - + Denied by the organization's content exclusion policy - + Denied by a permission request hook registered by an extension or plugin """ rules: list[Any] | None = None @@ -2770,7 +2363,7 @@ class PermissionDecision: message: str | None = None """Human-readable explanation of why the path was excluded - + Optional message from the hook explaining the denial """ path: str | None = None @@ -2780,7 +2373,7 @@ class PermissionDecision: """Whether to interrupt the current agent turn""" @staticmethod - def from_dict(obj: Any) -> "PermissionDecision": + def from_dict(obj: Any) -> 'PermissionDecision': assert isinstance(obj, dict) kind = Kind(obj.get("kind")) rules = from_union([lambda x: from_list(lambda x: x, x), from_none], obj.get("rules")) @@ -2794,9 +2387,7 @@ def to_dict(self) -> dict: result: dict = {} result["kind"] = to_enum(Kind, self.kind) if self.rules is not None: - result["rules"] = from_union( - [lambda x: from_list(lambda x: x, x), from_none], self.rules - ) + result["rules"] = from_union([lambda x: from_list(lambda x: x, x), from_none], self.rules) if self.feedback is not None: result["feedback"] = from_union([from_str, from_none], self.feedback) if self.message is not None: @@ -2807,7 +2398,6 @@ def to_dict(self) -> dict: result["interrupt"] = from_union([from_bool, from_none], self.interrupt) return result - @dataclass class PermissionDecisionRequest: request_id: str @@ -2816,7 +2406,7 @@ class PermissionDecisionRequest: result: PermissionDecision @staticmethod - def from_dict(obj: Any) -> "PermissionDecisionRequest": + def from_dict(obj: Any) -> 'PermissionDecisionRequest': assert isinstance(obj, dict) request_id = from_str(obj.get("requestId")) result = PermissionDecision.from_dict(obj.get("result")) @@ -2828,14 +2418,13 @@ def to_dict(self) -> dict: result["result"] = to_class(PermissionDecision, self.result) return result - @dataclass class LogResult: event_id: UUID """The unique identifier of the emitted session event""" @staticmethod - def from_dict(obj: Any) -> "LogResult": + def from_dict(obj: Any) -> 'LogResult': assert isinstance(obj, dict) event_id = UUID(obj.get("eventId")) return LogResult(event_id) @@ -2845,17 +2434,14 @@ def to_dict(self) -> dict: result["eventId"] = str(self.event_id) return result - class SessionLogLevel(Enum): """Log severity level. Determines how the message is displayed in the timeline. Defaults to "info". """ - ERROR = "error" INFO = "info" WARNING = "warning" - @dataclass class LogRequest: message: str @@ -2872,7 +2458,7 @@ class LogRequest: """Optional URL the user can open in their browser for more details""" @staticmethod - def from_dict(obj: Any) -> "LogRequest": + def from_dict(obj: Any) -> 'LogRequest': assert isinstance(obj, dict) message = from_str(obj.get("message")) ephemeral = from_union([from_bool, from_none], obj.get("ephemeral")) @@ -2886,21 +2472,18 @@ def to_dict(self) -> dict: if self.ephemeral is not None: result["ephemeral"] = from_union([from_bool, from_none], self.ephemeral) if self.level is not None: - result["level"] = from_union( - [lambda x: to_enum(SessionLogLevel, x), from_none], self.level - ) + result["level"] = from_union([lambda x: to_enum(SessionLogLevel, x), from_none], self.level) if self.url is not None: result["url"] = from_union([from_str, from_none], self.url) return result - @dataclass class ShellExecResult: process_id: str """Unique identifier for tracking streamed output""" @staticmethod - def from_dict(obj: Any) -> "ShellExecResult": + def from_dict(obj: Any) -> 'ShellExecResult': assert isinstance(obj, dict) process_id = from_str(obj.get("processId")) return ShellExecResult(process_id) @@ -2910,7 +2493,6 @@ def to_dict(self) -> dict: result["processId"] = from_str(self.process_id) return result - @dataclass class ShellExecRequest: command: str @@ -2923,7 +2505,7 @@ class ShellExecRequest: """Timeout in milliseconds (default: 30000)""" @staticmethod - def from_dict(obj: Any) -> "ShellExecRequest": + def from_dict(obj: Any) -> 'ShellExecRequest': assert isinstance(obj, dict) command = from_str(obj.get("command")) cwd = from_union([from_str, from_none], obj.get("cwd")) @@ -2939,14 +2521,13 @@ def to_dict(self) -> dict: result["timeout"] = from_union([from_int, from_none], self.timeout) return result - @dataclass class ShellKillResult: killed: bool """Whether the signal was sent successfully""" @staticmethod - def from_dict(obj: Any) -> "ShellKillResult": + def from_dict(obj: Any) -> 'ShellKillResult': assert isinstance(obj, dict) killed = from_bool(obj.get("killed")) return ShellKillResult(killed) @@ -2956,7 +2537,6 @@ def to_dict(self) -> dict: result["killed"] = from_bool(self.killed) return result - class ShellKillSignal(Enum): """Signal to send (default: SIGTERM)""" @@ -2964,7 +2544,6 @@ class ShellKillSignal(Enum): SIGKILL = "SIGKILL" SIGTERM = "SIGTERM" - @dataclass class ShellKillRequest: process_id: str @@ -2974,7 +2553,7 @@ class ShellKillRequest: """Signal to send (default: SIGTERM)""" @staticmethod - def from_dict(obj: Any) -> "ShellKillRequest": + def from_dict(obj: Any) -> 'ShellKillRequest': assert isinstance(obj, dict) process_id = from_str(obj.get("processId")) signal = from_union([ShellKillSignal, from_none], obj.get("signal")) @@ -2984,12 +2563,9 @@ def to_dict(self) -> dict: result: dict = {} result["processId"] = from_str(self.process_id) if self.signal is not None: - result["signal"] = from_union( - [lambda x: to_enum(ShellKillSignal, x), from_none], self.signal - ) + result["signal"] = from_union([lambda x: to_enum(ShellKillSignal, x), from_none], self.signal) return result - @dataclass class HistoryCompactContextWindow: """Post-compaction context window usage breakdown""" @@ -3013,24 +2589,15 @@ class HistoryCompactContextWindow: """Token count from tool definitions""" @staticmethod - def from_dict(obj: Any) -> "HistoryCompactContextWindow": + def from_dict(obj: Any) -> 'HistoryCompactContextWindow': assert isinstance(obj, dict) current_tokens = from_int(obj.get("currentTokens")) messages_length = from_int(obj.get("messagesLength")) token_limit = from_int(obj.get("tokenLimit")) conversation_tokens = from_union([from_int, from_none], obj.get("conversationTokens")) system_tokens = from_union([from_int, from_none], obj.get("systemTokens")) - tool_definitions_tokens = from_union( - [from_int, from_none], obj.get("toolDefinitionsTokens") - ) - return HistoryCompactContextWindow( - current_tokens, - messages_length, - token_limit, - conversation_tokens, - system_tokens, - tool_definitions_tokens, - ) + tool_definitions_tokens = from_union([from_int, from_none], obj.get("toolDefinitionsTokens")) + return HistoryCompactContextWindow(current_tokens, messages_length, token_limit, conversation_tokens, system_tokens, tool_definitions_tokens) def to_dict(self) -> dict: result: dict = {} @@ -3038,18 +2605,13 @@ def to_dict(self) -> dict: result["messagesLength"] = from_int(self.messages_length) result["tokenLimit"] = from_int(self.token_limit) if self.conversation_tokens is not None: - result["conversationTokens"] = from_union( - [from_int, from_none], self.conversation_tokens - ) + result["conversationTokens"] = from_union([from_int, from_none], self.conversation_tokens) if self.system_tokens is not None: result["systemTokens"] = from_union([from_int, from_none], self.system_tokens) if self.tool_definitions_tokens is not None: - result["toolDefinitionsTokens"] = from_union( - [from_int, from_none], self.tool_definitions_tokens - ) + result["toolDefinitionsTokens"] = from_union([from_int, from_none], self.tool_definitions_tokens) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryCompactResult: @@ -3066,14 +2628,12 @@ class HistoryCompactResult: """Post-compaction context window usage breakdown""" @staticmethod - def from_dict(obj: Any) -> "HistoryCompactResult": + def from_dict(obj: Any) -> 'HistoryCompactResult': assert isinstance(obj, dict) messages_removed = from_int(obj.get("messagesRemoved")) success = from_bool(obj.get("success")) tokens_removed = from_int(obj.get("tokensRemoved")) - context_window = from_union( - [HistoryCompactContextWindow.from_dict, from_none], obj.get("contextWindow") - ) + context_window = from_union([HistoryCompactContextWindow.from_dict, from_none], obj.get("contextWindow")) return HistoryCompactResult(messages_removed, success, tokens_removed, context_window) def to_dict(self) -> dict: @@ -3082,12 +2642,9 @@ def to_dict(self) -> dict: result["success"] = from_bool(self.success) result["tokensRemoved"] = from_int(self.tokens_removed) if self.context_window is not None: - result["contextWindow"] = from_union( - [lambda x: to_class(HistoryCompactContextWindow, x), from_none], self.context_window - ) + result["contextWindow"] = from_union([lambda x: to_class(HistoryCompactContextWindow, x), from_none], self.context_window) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryTruncateResult: @@ -3095,7 +2652,7 @@ class HistoryTruncateResult: """Number of events that were removed""" @staticmethod - def from_dict(obj: Any) -> "HistoryTruncateResult": + def from_dict(obj: Any) -> 'HistoryTruncateResult': assert isinstance(obj, dict) events_removed = from_int(obj.get("eventsRemoved")) return HistoryTruncateResult(events_removed) @@ -3105,7 +2662,6 @@ def to_dict(self) -> dict: result["eventsRemoved"] = from_int(self.events_removed) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class HistoryTruncateRequest: @@ -3113,7 +2669,7 @@ class HistoryTruncateRequest: """Event ID to truncate to. This event and all events after it are removed from the session.""" @staticmethod - def from_dict(obj: Any) -> "HistoryTruncateRequest": + def from_dict(obj: Any) -> 'HistoryTruncateRequest': assert isinstance(obj, dict) event_id = from_str(obj.get("eventId")) return HistoryTruncateRequest(event_id) @@ -3123,7 +2679,6 @@ def to_dict(self) -> dict: result["eventId"] = from_str(self.event_id) return result - @dataclass class UsageMetricsCodeChanges: """Aggregated code change metrics""" @@ -3138,7 +2693,7 @@ class UsageMetricsCodeChanges: """Total lines of code removed""" @staticmethod - def from_dict(obj: Any) -> "UsageMetricsCodeChanges": + def from_dict(obj: Any) -> 'UsageMetricsCodeChanges': assert isinstance(obj, dict) files_modified_count = from_int(obj.get("filesModifiedCount")) lines_added = from_int(obj.get("linesAdded")) @@ -3152,7 +2707,6 @@ def to_dict(self) -> dict: result["linesRemoved"] = from_int(self.lines_removed) return result - @dataclass class UsageMetricsModelMetricRequests: """Request count and cost metrics for this model""" @@ -3164,7 +2718,7 @@ class UsageMetricsModelMetricRequests: """Number of API requests made with this model""" @staticmethod - def from_dict(obj: Any) -> "UsageMetricsModelMetricRequests": + def from_dict(obj: Any) -> 'UsageMetricsModelMetricRequests': assert isinstance(obj, dict) cost = from_float(obj.get("cost")) count = from_int(obj.get("count")) @@ -3176,7 +2730,6 @@ def to_dict(self) -> dict: result["count"] = from_int(self.count) return result - @dataclass class UsageMetricsModelMetricUsage: """Token usage metrics for this model""" @@ -3197,16 +2750,14 @@ class UsageMetricsModelMetricUsage: """Total output tokens used for reasoning""" @staticmethod - def from_dict(obj: Any) -> "UsageMetricsModelMetricUsage": + def from_dict(obj: Any) -> 'UsageMetricsModelMetricUsage': assert isinstance(obj, dict) cache_read_tokens = from_int(obj.get("cacheReadTokens")) cache_write_tokens = from_int(obj.get("cacheWriteTokens")) input_tokens = from_int(obj.get("inputTokens")) output_tokens = from_int(obj.get("outputTokens")) reasoning_tokens = from_union([from_int, from_none], obj.get("reasoningTokens")) - return UsageMetricsModelMetricUsage( - cache_read_tokens, cache_write_tokens, input_tokens, output_tokens, reasoning_tokens - ) + return UsageMetricsModelMetricUsage(cache_read_tokens, cache_write_tokens, input_tokens, output_tokens, reasoning_tokens) def to_dict(self) -> dict: result: dict = {} @@ -3218,7 +2769,6 @@ def to_dict(self) -> dict: result["reasoningTokens"] = from_union([from_int, from_none], self.reasoning_tokens) return result - @dataclass class UsageMetricsModelMetric: requests: UsageMetricsModelMetricRequests @@ -3228,7 +2778,7 @@ class UsageMetricsModelMetric: """Token usage metrics for this model""" @staticmethod - def from_dict(obj: Any) -> "UsageMetricsModelMetric": + def from_dict(obj: Any) -> 'UsageMetricsModelMetric': assert isinstance(obj, dict) requests = UsageMetricsModelMetricRequests.from_dict(obj.get("requests")) usage = UsageMetricsModelMetricUsage.from_dict(obj.get("usage")) @@ -3240,7 +2790,6 @@ def to_dict(self) -> dict: result["usage"] = to_class(UsageMetricsModelMetricUsage, self.usage) return result - # Experimental: this type is part of an experimental API and may change or be removed. @dataclass class UsageGetMetricsResult: @@ -3273,7 +2822,7 @@ class UsageGetMetricsResult: """Currently active model identifier""" @staticmethod - def from_dict(obj: Any) -> "UsageGetMetricsResult": + def from_dict(obj: Any) -> 'UsageGetMetricsResult': assert isinstance(obj, dict) code_changes = UsageMetricsCodeChanges.from_dict(obj.get("codeChanges")) last_call_input_tokens = from_int(obj.get("lastCallInputTokens")) @@ -3284,26 +2833,14 @@ def from_dict(obj: Any) -> "UsageGetMetricsResult": total_premium_request_cost = from_float(obj.get("totalPremiumRequestCost")) total_user_requests = from_int(obj.get("totalUserRequests")) current_model = from_union([from_str, from_none], obj.get("currentModel")) - return UsageGetMetricsResult( - code_changes, - last_call_input_tokens, - last_call_output_tokens, - model_metrics, - session_start_time, - total_api_duration_ms, - total_premium_request_cost, - total_user_requests, - current_model, - ) + return UsageGetMetricsResult(code_changes, last_call_input_tokens, last_call_output_tokens, model_metrics, session_start_time, total_api_duration_ms, total_premium_request_cost, total_user_requests, current_model) def to_dict(self) -> dict: result: dict = {} result["codeChanges"] = to_class(UsageMetricsCodeChanges, self.code_changes) result["lastCallInputTokens"] = from_int(self.last_call_input_tokens) result["lastCallOutputTokens"] = from_int(self.last_call_output_tokens) - result["modelMetrics"] = from_dict( - lambda x: to_class(UsageMetricsModelMetric, x), self.model_metrics - ) + result["modelMetrics"] = from_dict(lambda x: to_class(UsageMetricsModelMetric, x), self.model_metrics) result["sessionStartTime"] = from_int(self.session_start_time) result["totalApiDurationMs"] = to_float(self.total_api_duration_ms) result["totalPremiumRequestCost"] = to_float(self.total_premium_request_cost) @@ -3312,14 +2849,13 @@ def to_dict(self) -> dict: result["currentModel"] = from_union([from_str, from_none], self.current_model) return result - @dataclass class SessionFSReadFileResult: content: str """File content as UTF-8 string""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReadFileResult": + def from_dict(obj: Any) -> 'SessionFSReadFileResult': assert isinstance(obj, dict) content = from_str(obj.get("content")) return SessionFSReadFileResult(content) @@ -3329,7 +2865,6 @@ def to_dict(self) -> dict: result["content"] = from_str(self.content) return result - @dataclass class SessionFSReadFileRequest: path: str @@ -3339,7 +2874,7 @@ class SessionFSReadFileRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReadFileRequest": + def from_dict(obj: Any) -> 'SessionFSReadFileRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3351,7 +2886,6 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - @dataclass class SessionFSWriteFileRequest: content: str @@ -3367,7 +2901,7 @@ class SessionFSWriteFileRequest: """Optional POSIX-style mode for newly created files""" @staticmethod - def from_dict(obj: Any) -> "SessionFSWriteFileRequest": + def from_dict(obj: Any) -> 'SessionFSWriteFileRequest': assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -3384,7 +2918,6 @@ def to_dict(self) -> dict: result["mode"] = from_union([from_int, from_none], self.mode) return result - @dataclass class SessionFSAppendFileRequest: content: str @@ -3400,7 +2933,7 @@ class SessionFSAppendFileRequest: """Optional POSIX-style mode for newly created files""" @staticmethod - def from_dict(obj: Any) -> "SessionFSAppendFileRequest": + def from_dict(obj: Any) -> 'SessionFSAppendFileRequest': assert isinstance(obj, dict) content = from_str(obj.get("content")) path = from_str(obj.get("path")) @@ -3417,14 +2950,13 @@ def to_dict(self) -> dict: result["mode"] = from_union([from_int, from_none], self.mode) return result - @dataclass class SessionFSExistsResult: exists: bool """Whether the path exists""" @staticmethod - def from_dict(obj: Any) -> "SessionFSExistsResult": + def from_dict(obj: Any) -> 'SessionFSExistsResult': assert isinstance(obj, dict) exists = from_bool(obj.get("exists")) return SessionFSExistsResult(exists) @@ -3434,7 +2966,6 @@ def to_dict(self) -> dict: result["exists"] = from_bool(self.exists) return result - @dataclass class SessionFSExistsRequest: path: str @@ -3444,7 +2975,7 @@ class SessionFSExistsRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> "SessionFSExistsRequest": + def from_dict(obj: Any) -> 'SessionFSExistsRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3456,7 +2987,6 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - @dataclass class SessionFSStatResult: birthtime: datetime @@ -3475,7 +3005,7 @@ class SessionFSStatResult: """File size in bytes""" @staticmethod - def from_dict(obj: Any) -> "SessionFSStatResult": + def from_dict(obj: Any) -> 'SessionFSStatResult': assert isinstance(obj, dict) birthtime = from_datetime(obj.get("birthtime")) is_directory = from_bool(obj.get("isDirectory")) @@ -3493,7 +3023,6 @@ def to_dict(self) -> dict: result["size"] = from_int(self.size) return result - @dataclass class SessionFSStatRequest: path: str @@ -3503,7 +3032,7 @@ class SessionFSStatRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> "SessionFSStatRequest": + def from_dict(obj: Any) -> 'SessionFSStatRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3515,7 +3044,6 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - @dataclass class SessionFSMkdirRequest: path: str @@ -3531,7 +3059,7 @@ class SessionFSMkdirRequest: """Create parent directories as needed""" @staticmethod - def from_dict(obj: Any) -> "SessionFSMkdirRequest": + def from_dict(obj: Any) -> 'SessionFSMkdirRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3549,14 +3077,13 @@ def to_dict(self) -> dict: result["recursive"] = from_union([from_bool, from_none], self.recursive) return result - @dataclass class SessionFSReaddirResult: entries: list[str] """Entry names in the directory""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReaddirResult": + def from_dict(obj: Any) -> 'SessionFSReaddirResult': assert isinstance(obj, dict) entries = from_list(from_str, obj.get("entries")) return SessionFSReaddirResult(entries) @@ -3566,7 +3093,6 @@ def to_dict(self) -> dict: result["entries"] = from_list(from_str, self.entries) return result - @dataclass class SessionFSReaddirRequest: path: str @@ -3576,7 +3102,7 @@ class SessionFSReaddirRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReaddirRequest": + def from_dict(obj: Any) -> 'SessionFSReaddirRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3588,14 +3114,12 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - class SessionFSReaddirWithTypesEntryType(Enum): """Entry type""" DIRECTORY = "directory" FILE = "file" - @dataclass class SessionFSReaddirWithTypesEntry: name: str @@ -3605,7 +3129,7 @@ class SessionFSReaddirWithTypesEntry: """Entry type""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReaddirWithTypesEntry": + def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesEntry': assert isinstance(obj, dict) name = from_str(obj.get("name")) type = SessionFSReaddirWithTypesEntryType(obj.get("type")) @@ -3617,26 +3141,22 @@ def to_dict(self) -> dict: result["type"] = to_enum(SessionFSReaddirWithTypesEntryType, self.type) return result - @dataclass class SessionFSReaddirWithTypesResult: entries: list[SessionFSReaddirWithTypesEntry] """Directory entries with type information""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReaddirWithTypesResult": + def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesResult': assert isinstance(obj, dict) entries = from_list(SessionFSReaddirWithTypesEntry.from_dict, obj.get("entries")) return SessionFSReaddirWithTypesResult(entries) def to_dict(self) -> dict: result: dict = {} - result["entries"] = from_list( - lambda x: to_class(SessionFSReaddirWithTypesEntry, x), self.entries - ) + result["entries"] = from_list(lambda x: to_class(SessionFSReaddirWithTypesEntry, x), self.entries) return result - @dataclass class SessionFSReaddirWithTypesRequest: path: str @@ -3646,7 +3166,7 @@ class SessionFSReaddirWithTypesRequest: """Target session identifier""" @staticmethod - def from_dict(obj: Any) -> "SessionFSReaddirWithTypesRequest": + def from_dict(obj: Any) -> 'SessionFSReaddirWithTypesRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3658,7 +3178,6 @@ def to_dict(self) -> dict: result["sessionId"] = from_str(self.session_id) return result - @dataclass class SessionFSRmRequest: path: str @@ -3674,7 +3193,7 @@ class SessionFSRmRequest: """Remove directories and their contents recursively""" @staticmethod - def from_dict(obj: Any) -> "SessionFSRmRequest": + def from_dict(obj: Any) -> 'SessionFSRmRequest': assert isinstance(obj, dict) path = from_str(obj.get("path")) session_id = from_str(obj.get("sessionId")) @@ -3692,7 +3211,6 @@ def to_dict(self) -> dict: result["recursive"] = from_union([from_bool, from_none], self.recursive) return result - @dataclass class SessionFSRenameRequest: dest: str @@ -3705,7 +3223,7 @@ class SessionFSRenameRequest: """Source path using SessionFs conventions""" @staticmethod - def from_dict(obj: Any) -> "SessionFSRenameRequest": + def from_dict(obj: Any) -> 'SessionFSRenameRequest': assert isinstance(obj, dict) dest = from_str(obj.get("dest")) session_id = from_str(obj.get("sessionId")) @@ -3719,661 +3237,495 @@ def to_dict(self) -> dict: result["src"] = from_str(self.src) return result - def ping_result_from_dict(s: Any) -> PingResult: return PingResult.from_dict(s) - def ping_result_to_dict(x: PingResult) -> Any: return to_class(PingResult, x) - def ping_request_from_dict(s: Any) -> PingRequest: return PingRequest.from_dict(s) - def ping_request_to_dict(x: PingRequest) -> Any: return to_class(PingRequest, x) - def model_list_from_dict(s: Any) -> ModelList: return ModelList.from_dict(s) - def model_list_to_dict(x: ModelList) -> Any: return to_class(ModelList, x) - def tool_list_from_dict(s: Any) -> ToolList: return ToolList.from_dict(s) - def tool_list_to_dict(x: ToolList) -> Any: return to_class(ToolList, x) - def tools_list_request_from_dict(s: Any) -> ToolsListRequest: return ToolsListRequest.from_dict(s) - def tools_list_request_to_dict(x: ToolsListRequest) -> Any: return to_class(ToolsListRequest, x) - def account_get_quota_result_from_dict(s: Any) -> AccountGetQuotaResult: return AccountGetQuotaResult.from_dict(s) - def account_get_quota_result_to_dict(x: AccountGetQuotaResult) -> Any: return to_class(AccountGetQuotaResult, x) - def mcp_config_list_from_dict(s: Any) -> MCPConfigList: return MCPConfigList.from_dict(s) - def mcp_config_list_to_dict(x: MCPConfigList) -> Any: return to_class(MCPConfigList, x) - def mcp_config_add_request_from_dict(s: Any) -> MCPConfigAddRequest: return MCPConfigAddRequest.from_dict(s) - def mcp_config_add_request_to_dict(x: MCPConfigAddRequest) -> Any: return to_class(MCPConfigAddRequest, x) - def mcp_config_update_request_from_dict(s: Any) -> MCPConfigUpdateRequest: return MCPConfigUpdateRequest.from_dict(s) - def mcp_config_update_request_to_dict(x: MCPConfigUpdateRequest) -> Any: return to_class(MCPConfigUpdateRequest, x) - def mcp_config_remove_request_from_dict(s: Any) -> MCPConfigRemoveRequest: return MCPConfigRemoveRequest.from_dict(s) - def mcp_config_remove_request_to_dict(x: MCPConfigRemoveRequest) -> Any: return to_class(MCPConfigRemoveRequest, x) - def mcp_discover_result_from_dict(s: Any) -> MCPDiscoverResult: return MCPDiscoverResult.from_dict(s) - def mcp_discover_result_to_dict(x: MCPDiscoverResult) -> Any: return to_class(MCPDiscoverResult, x) - def mcp_discover_request_from_dict(s: Any) -> MCPDiscoverRequest: return MCPDiscoverRequest.from_dict(s) - def mcp_discover_request_to_dict(x: MCPDiscoverRequest) -> Any: return to_class(MCPDiscoverRequest, x) - def session_fs_set_provider_result_from_dict(s: Any) -> SessionFSSetProviderResult: return SessionFSSetProviderResult.from_dict(s) - def session_fs_set_provider_result_to_dict(x: SessionFSSetProviderResult) -> Any: return to_class(SessionFSSetProviderResult, x) - def session_fs_set_provider_request_from_dict(s: Any) -> SessionFSSetProviderRequest: return SessionFSSetProviderRequest.from_dict(s) - def session_fs_set_provider_request_to_dict(x: SessionFSSetProviderRequest) -> Any: return to_class(SessionFSSetProviderRequest, x) - def sessions_fork_result_from_dict(s: Any) -> SessionsForkResult: return SessionsForkResult.from_dict(s) - def sessions_fork_result_to_dict(x: SessionsForkResult) -> Any: return to_class(SessionsForkResult, x) - def sessions_fork_request_from_dict(s: Any) -> SessionsForkRequest: return SessionsForkRequest.from_dict(s) - def sessions_fork_request_to_dict(x: SessionsForkRequest) -> Any: return to_class(SessionsForkRequest, x) - def current_model_from_dict(s: Any) -> CurrentModel: return CurrentModel.from_dict(s) - def current_model_to_dict(x: CurrentModel) -> Any: return to_class(CurrentModel, x) - def model_switch_to_result_from_dict(s: Any) -> ModelSwitchToResult: return ModelSwitchToResult.from_dict(s) - def model_switch_to_result_to_dict(x: ModelSwitchToResult) -> Any: return to_class(ModelSwitchToResult, x) - def model_switch_to_request_from_dict(s: Any) -> ModelSwitchToRequest: return ModelSwitchToRequest.from_dict(s) - def model_switch_to_request_to_dict(x: ModelSwitchToRequest) -> Any: return to_class(ModelSwitchToRequest, x) - def session_mode_from_dict(s: Any) -> SessionMode: return SessionMode(s) - def session_mode_to_dict(x: SessionMode) -> Any: return to_enum(SessionMode, x) - def mode_set_request_from_dict(s: Any) -> ModeSetRequest: return ModeSetRequest.from_dict(s) - def mode_set_request_to_dict(x: ModeSetRequest) -> Any: return to_class(ModeSetRequest, x) - def name_get_result_from_dict(s: Any) -> NameGetResult: return NameGetResult.from_dict(s) - def name_get_result_to_dict(x: NameGetResult) -> Any: return to_class(NameGetResult, x) - def name_set_request_from_dict(s: Any) -> NameSetRequest: return NameSetRequest.from_dict(s) - def name_set_request_to_dict(x: NameSetRequest) -> Any: return to_class(NameSetRequest, x) - def plan_read_result_from_dict(s: Any) -> PlanReadResult: return PlanReadResult.from_dict(s) - def plan_read_result_to_dict(x: PlanReadResult) -> Any: return to_class(PlanReadResult, x) - def plan_update_request_from_dict(s: Any) -> PlanUpdateRequest: return PlanUpdateRequest.from_dict(s) - def plan_update_request_to_dict(x: PlanUpdateRequest) -> Any: return to_class(PlanUpdateRequest, x) - def workspaces_get_workspace_result_from_dict(s: Any) -> WorkspacesGetWorkspaceResult: return WorkspacesGetWorkspaceResult.from_dict(s) - def workspaces_get_workspace_result_to_dict(x: WorkspacesGetWorkspaceResult) -> Any: return to_class(WorkspacesGetWorkspaceResult, x) - def workspaces_list_files_result_from_dict(s: Any) -> WorkspacesListFilesResult: return WorkspacesListFilesResult.from_dict(s) - def workspaces_list_files_result_to_dict(x: WorkspacesListFilesResult) -> Any: return to_class(WorkspacesListFilesResult, x) - def workspaces_read_file_result_from_dict(s: Any) -> WorkspacesReadFileResult: return WorkspacesReadFileResult.from_dict(s) - def workspaces_read_file_result_to_dict(x: WorkspacesReadFileResult) -> Any: return to_class(WorkspacesReadFileResult, x) - def workspaces_read_file_request_from_dict(s: Any) -> WorkspacesReadFileRequest: return WorkspacesReadFileRequest.from_dict(s) - def workspaces_read_file_request_to_dict(x: WorkspacesReadFileRequest) -> Any: return to_class(WorkspacesReadFileRequest, x) - def workspaces_create_file_request_from_dict(s: Any) -> WorkspacesCreateFileRequest: return WorkspacesCreateFileRequest.from_dict(s) - def workspaces_create_file_request_to_dict(x: WorkspacesCreateFileRequest) -> Any: return to_class(WorkspacesCreateFileRequest, x) - def fleet_start_result_from_dict(s: Any) -> FleetStartResult: return FleetStartResult.from_dict(s) - def fleet_start_result_to_dict(x: FleetStartResult) -> Any: return to_class(FleetStartResult, x) - def fleet_start_request_from_dict(s: Any) -> FleetStartRequest: return FleetStartRequest.from_dict(s) - def fleet_start_request_to_dict(x: FleetStartRequest) -> Any: return to_class(FleetStartRequest, x) - def agent_list_from_dict(s: Any) -> AgentList: return AgentList.from_dict(s) - def agent_list_to_dict(x: AgentList) -> Any: return to_class(AgentList, x) - def agent_get_current_result_from_dict(s: Any) -> AgentGetCurrentResult: return AgentGetCurrentResult.from_dict(s) - def agent_get_current_result_to_dict(x: AgentGetCurrentResult) -> Any: return to_class(AgentGetCurrentResult, x) - def agent_select_result_from_dict(s: Any) -> AgentSelectResult: return AgentSelectResult.from_dict(s) - def agent_select_result_to_dict(x: AgentSelectResult) -> Any: return to_class(AgentSelectResult, x) - def agent_select_request_from_dict(s: Any) -> AgentSelectRequest: return AgentSelectRequest.from_dict(s) - def agent_select_request_to_dict(x: AgentSelectRequest) -> Any: return to_class(AgentSelectRequest, x) - def agent_reload_result_from_dict(s: Any) -> AgentReloadResult: return AgentReloadResult.from_dict(s) - def agent_reload_result_to_dict(x: AgentReloadResult) -> Any: return to_class(AgentReloadResult, x) - def skill_list_from_dict(s: Any) -> SkillList: return SkillList.from_dict(s) - def skill_list_to_dict(x: SkillList) -> Any: return to_class(SkillList, x) - def skills_enable_request_from_dict(s: Any) -> SkillsEnableRequest: return SkillsEnableRequest.from_dict(s) - def skills_enable_request_to_dict(x: SkillsEnableRequest) -> Any: return to_class(SkillsEnableRequest, x) - def skills_disable_request_from_dict(s: Any) -> SkillsDisableRequest: return SkillsDisableRequest.from_dict(s) - def skills_disable_request_to_dict(x: SkillsDisableRequest) -> Any: return to_class(SkillsDisableRequest, x) - def mcp_server_list_from_dict(s: Any) -> MCPServerList: return MCPServerList.from_dict(s) - def mcp_server_list_to_dict(x: MCPServerList) -> Any: return to_class(MCPServerList, x) - def mcp_enable_request_from_dict(s: Any) -> MCPEnableRequest: return MCPEnableRequest.from_dict(s) - def mcp_enable_request_to_dict(x: MCPEnableRequest) -> Any: return to_class(MCPEnableRequest, x) - def mcp_disable_request_from_dict(s: Any) -> MCPDisableRequest: return MCPDisableRequest.from_dict(s) - def mcp_disable_request_to_dict(x: MCPDisableRequest) -> Any: return to_class(MCPDisableRequest, x) - def plugin_list_from_dict(s: Any) -> PluginList: return PluginList.from_dict(s) - def plugin_list_to_dict(x: PluginList) -> Any: return to_class(PluginList, x) - def extension_list_from_dict(s: Any) -> ExtensionList: return ExtensionList.from_dict(s) - def extension_list_to_dict(x: ExtensionList) -> Any: return to_class(ExtensionList, x) - def extensions_enable_request_from_dict(s: Any) -> ExtensionsEnableRequest: return ExtensionsEnableRequest.from_dict(s) - def extensions_enable_request_to_dict(x: ExtensionsEnableRequest) -> Any: return to_class(ExtensionsEnableRequest, x) - def extensions_disable_request_from_dict(s: Any) -> ExtensionsDisableRequest: return ExtensionsDisableRequest.from_dict(s) - def extensions_disable_request_to_dict(x: ExtensionsDisableRequest) -> Any: return to_class(ExtensionsDisableRequest, x) - def handle_tool_call_result_from_dict(s: Any) -> HandleToolCallResult: return HandleToolCallResult.from_dict(s) - def handle_tool_call_result_to_dict(x: HandleToolCallResult) -> Any: return to_class(HandleToolCallResult, x) - def tools_handle_pending_tool_call_request_from_dict(s: Any) -> ToolsHandlePendingToolCallRequest: return ToolsHandlePendingToolCallRequest.from_dict(s) - def tools_handle_pending_tool_call_request_to_dict(x: ToolsHandlePendingToolCallRequest) -> Any: return to_class(ToolsHandlePendingToolCallRequest, x) - def commands_handle_pending_command_result_from_dict(s: Any) -> CommandsHandlePendingCommandResult: return CommandsHandlePendingCommandResult.from_dict(s) - def commands_handle_pending_command_result_to_dict(x: CommandsHandlePendingCommandResult) -> Any: return to_class(CommandsHandlePendingCommandResult, x) - -def commands_handle_pending_command_request_from_dict( - s: Any, -) -> CommandsHandlePendingCommandRequest: +def commands_handle_pending_command_request_from_dict(s: Any) -> CommandsHandlePendingCommandRequest: return CommandsHandlePendingCommandRequest.from_dict(s) - def commands_handle_pending_command_request_to_dict(x: CommandsHandlePendingCommandRequest) -> Any: return to_class(CommandsHandlePendingCommandRequest, x) - def ui_elicitation_response_from_dict(s: Any) -> UIElicitationResponse: return UIElicitationResponse.from_dict(s) - def ui_elicitation_response_to_dict(x: UIElicitationResponse) -> Any: return to_class(UIElicitationResponse, x) - def ui_elicitation_request_from_dict(s: Any) -> UIElicitationRequest: return UIElicitationRequest.from_dict(s) - def ui_elicitation_request_to_dict(x: UIElicitationRequest) -> Any: return to_class(UIElicitationRequest, x) - def ui_elicitation_result_from_dict(s: Any) -> UIElicitationResult: return UIElicitationResult.from_dict(s) - def ui_elicitation_result_to_dict(x: UIElicitationResult) -> Any: return to_class(UIElicitationResult, x) - def ui_handle_pending_elicitation_request_from_dict(s: Any) -> UIHandlePendingElicitationRequest: return UIHandlePendingElicitationRequest.from_dict(s) - def ui_handle_pending_elicitation_request_to_dict(x: UIHandlePendingElicitationRequest) -> Any: return to_class(UIHandlePendingElicitationRequest, x) - def permission_request_result_from_dict(s: Any) -> PermissionRequestResult: return PermissionRequestResult.from_dict(s) - def permission_request_result_to_dict(x: PermissionRequestResult) -> Any: return to_class(PermissionRequestResult, x) - def permission_decision_request_from_dict(s: Any) -> PermissionDecisionRequest: return PermissionDecisionRequest.from_dict(s) - def permission_decision_request_to_dict(x: PermissionDecisionRequest) -> Any: return to_class(PermissionDecisionRequest, x) - def log_result_from_dict(s: Any) -> LogResult: return LogResult.from_dict(s) - def log_result_to_dict(x: LogResult) -> Any: return to_class(LogResult, x) - def log_request_from_dict(s: Any) -> LogRequest: return LogRequest.from_dict(s) - def log_request_to_dict(x: LogRequest) -> Any: return to_class(LogRequest, x) - def shell_exec_result_from_dict(s: Any) -> ShellExecResult: return ShellExecResult.from_dict(s) - def shell_exec_result_to_dict(x: ShellExecResult) -> Any: return to_class(ShellExecResult, x) - def shell_exec_request_from_dict(s: Any) -> ShellExecRequest: return ShellExecRequest.from_dict(s) - def shell_exec_request_to_dict(x: ShellExecRequest) -> Any: return to_class(ShellExecRequest, x) - def shell_kill_result_from_dict(s: Any) -> ShellKillResult: return ShellKillResult.from_dict(s) - def shell_kill_result_to_dict(x: ShellKillResult) -> Any: return to_class(ShellKillResult, x) - def shell_kill_request_from_dict(s: Any) -> ShellKillRequest: return ShellKillRequest.from_dict(s) - def shell_kill_request_to_dict(x: ShellKillRequest) -> Any: return to_class(ShellKillRequest, x) - def history_compact_result_from_dict(s: Any) -> HistoryCompactResult: return HistoryCompactResult.from_dict(s) - def history_compact_result_to_dict(x: HistoryCompactResult) -> Any: return to_class(HistoryCompactResult, x) - def history_truncate_result_from_dict(s: Any) -> HistoryTruncateResult: return HistoryTruncateResult.from_dict(s) - def history_truncate_result_to_dict(x: HistoryTruncateResult) -> Any: return to_class(HistoryTruncateResult, x) - def history_truncate_request_from_dict(s: Any) -> HistoryTruncateRequest: return HistoryTruncateRequest.from_dict(s) - def history_truncate_request_to_dict(x: HistoryTruncateRequest) -> Any: return to_class(HistoryTruncateRequest, x) - def usage_get_metrics_result_from_dict(s: Any) -> UsageGetMetricsResult: return UsageGetMetricsResult.from_dict(s) - def usage_get_metrics_result_to_dict(x: UsageGetMetricsResult) -> Any: return to_class(UsageGetMetricsResult, x) - def session_fs_read_file_result_from_dict(s: Any) -> SessionFSReadFileResult: return SessionFSReadFileResult.from_dict(s) - def session_fs_read_file_result_to_dict(x: SessionFSReadFileResult) -> Any: return to_class(SessionFSReadFileResult, x) - def session_fs_read_file_request_from_dict(s: Any) -> SessionFSReadFileRequest: return SessionFSReadFileRequest.from_dict(s) - def session_fs_read_file_request_to_dict(x: SessionFSReadFileRequest) -> Any: return to_class(SessionFSReadFileRequest, x) - def session_fs_write_file_request_from_dict(s: Any) -> SessionFSWriteFileRequest: return SessionFSWriteFileRequest.from_dict(s) - def session_fs_write_file_request_to_dict(x: SessionFSWriteFileRequest) -> Any: return to_class(SessionFSWriteFileRequest, x) - def session_fs_append_file_request_from_dict(s: Any) -> SessionFSAppendFileRequest: return SessionFSAppendFileRequest.from_dict(s) - def session_fs_append_file_request_to_dict(x: SessionFSAppendFileRequest) -> Any: return to_class(SessionFSAppendFileRequest, x) - def session_fs_exists_result_from_dict(s: Any) -> SessionFSExistsResult: return SessionFSExistsResult.from_dict(s) - def session_fs_exists_result_to_dict(x: SessionFSExistsResult) -> Any: return to_class(SessionFSExistsResult, x) - def session_fs_exists_request_from_dict(s: Any) -> SessionFSExistsRequest: return SessionFSExistsRequest.from_dict(s) - def session_fs_exists_request_to_dict(x: SessionFSExistsRequest) -> Any: return to_class(SessionFSExistsRequest, x) - def session_fs_stat_result_from_dict(s: Any) -> SessionFSStatResult: return SessionFSStatResult.from_dict(s) - def session_fs_stat_result_to_dict(x: SessionFSStatResult) -> Any: return to_class(SessionFSStatResult, x) - def session_fs_stat_request_from_dict(s: Any) -> SessionFSStatRequest: return SessionFSStatRequest.from_dict(s) - def session_fs_stat_request_to_dict(x: SessionFSStatRequest) -> Any: return to_class(SessionFSStatRequest, x) - def session_fs_mkdir_request_from_dict(s: Any) -> SessionFSMkdirRequest: return SessionFSMkdirRequest.from_dict(s) - def session_fs_mkdir_request_to_dict(x: SessionFSMkdirRequest) -> Any: return to_class(SessionFSMkdirRequest, x) - def session_fs_readdir_result_from_dict(s: Any) -> SessionFSReaddirResult: return SessionFSReaddirResult.from_dict(s) - def session_fs_readdir_result_to_dict(x: SessionFSReaddirResult) -> Any: return to_class(SessionFSReaddirResult, x) - def session_fs_readdir_request_from_dict(s: Any) -> SessionFSReaddirRequest: return SessionFSReaddirRequest.from_dict(s) - def session_fs_readdir_request_to_dict(x: SessionFSReaddirRequest) -> Any: return to_class(SessionFSReaddirRequest, x) - def session_fs_readdir_with_types_result_from_dict(s: Any) -> SessionFSReaddirWithTypesResult: return SessionFSReaddirWithTypesResult.from_dict(s) - def session_fs_readdir_with_types_result_to_dict(x: SessionFSReaddirWithTypesResult) -> Any: return to_class(SessionFSReaddirWithTypesResult, x) - def session_fs_readdir_with_types_request_from_dict(s: Any) -> SessionFSReaddirWithTypesRequest: return SessionFSReaddirWithTypesRequest.from_dict(s) - def session_fs_readdir_with_types_request_to_dict(x: SessionFSReaddirWithTypesRequest) -> Any: return to_class(SessionFSReaddirWithTypesRequest, x) - def session_fs_rm_request_from_dict(s: Any) -> SessionFSRmRequest: return SessionFSRmRequest.from_dict(s) - def session_fs_rm_request_to_dict(x: SessionFSRmRequest) -> Any: return to_class(SessionFSRmRequest, x) - def session_fs_rename_request_from_dict(s: Any) -> SessionFSRenameRequest: return SessionFSRenameRequest.from_dict(s) - def session_fs_rename_request_to_dict(x: SessionFSRenameRequest) -> Any: return to_class(SessionFSRenameRequest, x) @@ -4384,7 +3736,6 @@ def _timeout_kwargs(timeout: float | None) -> dict: return {"timeout": timeout} return {} - def _patch_model_capabilities(data: dict) -> dict: """Ensure model capabilities have required fields. @@ -4412,11 +3763,7 @@ def __init__(self, client: "JsonRpcClient"): self._client = client async def list(self, *, timeout: float | None = None) -> ModelList: - return ModelList.from_dict( - _patch_model_capabilities( - await self._client.request("models.list", {}, **_timeout_kwargs(timeout)) - ) - ) + return ModelList.from_dict(_patch_model_capabilities(await self._client.request("models.list", {}, **_timeout_kwargs(timeout)))) class ServerToolsApi: @@ -4425,9 +3772,7 @@ def __init__(self, client: "JsonRpcClient"): async def list(self, params: ToolsListRequest, *, timeout: float | None = None) -> ToolList: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return ToolList.from_dict( - await self._client.request("tools.list", params_dict, **_timeout_kwargs(timeout)) - ) + return ToolList.from_dict(await self._client.request("tools.list", params_dict, **_timeout_kwargs(timeout))) class ServerAccountApi: @@ -4435,37 +3780,25 @@ def __init__(self, client: "JsonRpcClient"): self._client = client async def get_quota(self, *, timeout: float | None = None) -> AccountGetQuotaResult: - return AccountGetQuotaResult.from_dict( - await self._client.request("account.getQuota", {}, **_timeout_kwargs(timeout)) - ) + return AccountGetQuotaResult.from_dict(await self._client.request("account.getQuota", {}, **_timeout_kwargs(timeout))) class ServerMcpApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def discover( - self, params: MCPDiscoverRequest, *, timeout: float | None = None - ) -> MCPDiscoverResult: + async def discover(self, params: MCPDiscoverRequest, *, timeout: float | None = None) -> MCPDiscoverResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return MCPDiscoverResult.from_dict( - await self._client.request("mcp.discover", params_dict, **_timeout_kwargs(timeout)) - ) + return MCPDiscoverResult.from_dict(await self._client.request("mcp.discover", params_dict, **_timeout_kwargs(timeout))) class ServerSessionFsApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def set_provider( - self, params: SessionFSSetProviderRequest, *, timeout: float | None = None - ) -> SessionFSSetProviderResult: + async def set_provider(self, params: SessionFSSetProviderRequest, *, timeout: float | None = None) -> SessionFSSetProviderResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return SessionFSSetProviderResult.from_dict( - await self._client.request( - "sessionFs.setProvider", params_dict, **_timeout_kwargs(timeout) - ) - ) + return SessionFSSetProviderResult.from_dict(await self._client.request("sessionFs.setProvider", params_dict, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4473,18 +3806,13 @@ class ServerSessionsApi: def __init__(self, client: "JsonRpcClient"): self._client = client - async def fork( - self, params: SessionsForkRequest, *, timeout: float | None = None - ) -> SessionsForkResult: + async def fork(self, params: SessionsForkRequest, *, timeout: float | None = None) -> SessionsForkResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return SessionsForkResult.from_dict( - await self._client.request("sessions.fork", params_dict, **_timeout_kwargs(timeout)) - ) + return SessionsForkResult.from_dict(await self._client.request("sessions.fork", params_dict, **_timeout_kwargs(timeout))) class ServerRpc: """Typed server-scoped RPC methods.""" - def __init__(self, client: "JsonRpcClient"): self._client = client self.models = ServerModelsApi(client) @@ -4496,9 +3824,7 @@ def __init__(self, client: "JsonRpcClient"): async def ping(self, params: PingRequest, *, timeout: float | None = None) -> PingResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} - return PingResult.from_dict( - await self._client.request("ping", params_dict, **_timeout_kwargs(timeout)) - ) + return PingResult.from_dict(await self._client.request("ping", params_dict, **_timeout_kwargs(timeout))) class ModelApi: @@ -4507,24 +3833,12 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_current(self, *, timeout: float | None = None) -> CurrentModel: - return CurrentModel.from_dict( - await self._client.request( - "session.model.getCurrent", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) - - async def switch_to( - self, params: ModelSwitchToRequest, *, timeout: float | None = None - ) -> ModelSwitchToResult: + return CurrentModel.from_dict(await self._client.request("session.model.getCurrent", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def switch_to(self, params: ModelSwitchToRequest, *, timeout: float | None = None) -> ModelSwitchToResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ModelSwitchToResult.from_dict( - await self._client.request( - "session.model.switchTo", params_dict, **_timeout_kwargs(timeout) - ) - ) + return ModelSwitchToResult.from_dict(await self._client.request("session.model.switchTo", params_dict, **_timeout_kwargs(timeout))) class ModeApi: @@ -4533,11 +3847,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get(self, *, timeout: float | None = None) -> SessionMode: - return SessionMode( - await self._client.request( - "session.mode.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return SessionMode(await self._client.request("session.mode.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def set(self, params: ModeSetRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -4551,11 +3861,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get(self, *, timeout: float | None = None) -> NameGetResult: - return NameGetResult.from_dict( - await self._client.request( - "session.name.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return NameGetResult.from_dict(await self._client.request("session.name.get", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def set(self, params: NameSetRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -4569,11 +3875,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def read(self, *, timeout: float | None = None) -> PlanReadResult: - return PlanReadResult.from_dict( - await self._client.request( - "session.plan.read", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return PlanReadResult.from_dict(await self._client.request("session.plan.read", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def update(self, params: PlanUpdateRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -4581,9 +3883,7 @@ async def update(self, params: PlanUpdateRequest, *, timeout: float | None = Non await self._client.request("session.plan.update", params_dict, **_timeout_kwargs(timeout)) async def delete(self, *, timeout: float | None = None) -> None: - await self._client.request( - "session.plan.delete", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) + await self._client.request("session.plan.delete", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) class WorkspacesApi: @@ -4592,42 +3892,20 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_workspace(self, *, timeout: float | None = None) -> WorkspacesGetWorkspaceResult: - return WorkspacesGetWorkspaceResult.from_dict( - await self._client.request( - "session.workspaces.getWorkspace", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) + return WorkspacesGetWorkspaceResult.from_dict(await self._client.request("session.workspaces.getWorkspace", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def list_files(self, *, timeout: float | None = None) -> WorkspacesListFilesResult: - return WorkspacesListFilesResult.from_dict( - await self._client.request( - "session.workspaces.listFiles", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) - - async def read_file( - self, params: WorkspacesReadFileRequest, *, timeout: float | None = None - ) -> WorkspacesReadFileResult: + return WorkspacesListFilesResult.from_dict(await self._client.request("session.workspaces.listFiles", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def read_file(self, params: WorkspacesReadFileRequest, *, timeout: float | None = None) -> WorkspacesReadFileResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return WorkspacesReadFileResult.from_dict( - await self._client.request( - "session.workspaces.readFile", params_dict, **_timeout_kwargs(timeout) - ) - ) - - async def create_file( - self, params: WorkspacesCreateFileRequest, *, timeout: float | None = None - ) -> None: + return WorkspacesReadFileResult.from_dict(await self._client.request("session.workspaces.readFile", params_dict, **_timeout_kwargs(timeout))) + + async def create_file(self, params: WorkspacesCreateFileRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request( - "session.workspaces.createFile", params_dict, **_timeout_kwargs(timeout) - ) + await self._client.request("session.workspaces.createFile", params_dict, **_timeout_kwargs(timeout)) # Experimental: this API group is experimental and may change or be removed. @@ -4636,16 +3914,10 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def start( - self, params: FleetStartRequest, *, timeout: float | None = None - ) -> FleetStartResult: + async def start(self, params: FleetStartRequest, *, timeout: float | None = None) -> FleetStartResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return FleetStartResult.from_dict( - await self._client.request( - "session.fleet.start", params_dict, **_timeout_kwargs(timeout) - ) - ) + return FleetStartResult.from_dict(await self._client.request("session.fleet.start", params_dict, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4655,43 +3927,21 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> AgentList: - return AgentList.from_dict( - await self._client.request( - "session.agent.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return AgentList.from_dict(await self._client.request("session.agent.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def get_current(self, *, timeout: float | None = None) -> AgentGetCurrentResult: - return AgentGetCurrentResult.from_dict( - await self._client.request( - "session.agent.getCurrent", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) - - async def select( - self, params: AgentSelectRequest, *, timeout: float | None = None - ) -> AgentSelectResult: + return AgentGetCurrentResult.from_dict(await self._client.request("session.agent.getCurrent", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def select(self, params: AgentSelectRequest, *, timeout: float | None = None) -> AgentSelectResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return AgentSelectResult.from_dict( - await self._client.request( - "session.agent.select", params_dict, **_timeout_kwargs(timeout) - ) - ) + return AgentSelectResult.from_dict(await self._client.request("session.agent.select", params_dict, **_timeout_kwargs(timeout))) async def deselect(self, *, timeout: float | None = None) -> None: - await self._client.request( - "session.agent.deselect", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) + await self._client.request("session.agent.deselect", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) async def reload(self, *, timeout: float | None = None) -> AgentReloadResult: - return AgentReloadResult.from_dict( - await self._client.request( - "session.agent.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return AgentReloadResult.from_dict(await self._client.request("session.agent.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4701,11 +3951,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> SkillList: - return SkillList.from_dict( - await self._client.request( - "session.skills.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return SkillList.from_dict(await self._client.request("session.skills.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def enable(self, params: SkillsEnableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -4715,14 +3961,10 @@ async def enable(self, params: SkillsEnableRequest, *, timeout: float | None = N async def disable(self, params: SkillsDisableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request( - "session.skills.disable", params_dict, **_timeout_kwargs(timeout) - ) + await self._client.request("session.skills.disable", params_dict, **_timeout_kwargs(timeout)) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request( - "session.skills.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) + await self._client.request("session.skills.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) # Experimental: this API group is experimental and may change or be removed. @@ -4732,11 +3974,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> MCPServerList: - return MCPServerList.from_dict( - await self._client.request( - "session.mcp.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return MCPServerList.from_dict(await self._client.request("session.mcp.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) async def enable(self, params: MCPEnableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} @@ -4749,9 +3987,7 @@ async def disable(self, params: MCPDisableRequest, *, timeout: float | None = No await self._client.request("session.mcp.disable", params_dict, **_timeout_kwargs(timeout)) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request( - "session.mcp.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) + await self._client.request("session.mcp.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) # Experimental: this API group is experimental and may change or be removed. @@ -4761,11 +3997,7 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> PluginList: - return PluginList.from_dict( - await self._client.request( - "session.plugins.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) - ) + return PluginList.from_dict(await self._client.request("session.plugins.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4775,36 +4007,20 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def list(self, *, timeout: float | None = None) -> ExtensionList: - return ExtensionList.from_dict( - await self._client.request( - "session.extensions.list", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) - - async def enable( - self, params: ExtensionsEnableRequest, *, timeout: float | None = None - ) -> None: + return ExtensionList.from_dict(await self._client.request("session.extensions.list", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def enable(self, params: ExtensionsEnableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request( - "session.extensions.enable", params_dict, **_timeout_kwargs(timeout) - ) + await self._client.request("session.extensions.enable", params_dict, **_timeout_kwargs(timeout)) - async def disable( - self, params: ExtensionsDisableRequest, *, timeout: float | None = None - ) -> None: + async def disable(self, params: ExtensionsDisableRequest, *, timeout: float | None = None) -> None: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - await self._client.request( - "session.extensions.disable", params_dict, **_timeout_kwargs(timeout) - ) + await self._client.request("session.extensions.disable", params_dict, **_timeout_kwargs(timeout)) async def reload(self, *, timeout: float | None = None) -> None: - await self._client.request( - "session.extensions.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout) - ) + await self._client.request("session.extensions.reload", {"sessionId": self._session_id}, **_timeout_kwargs(timeout)) class ToolsApi: @@ -4812,16 +4028,10 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_tool_call( - self, params: ToolsHandlePendingToolCallRequest, *, timeout: float | None = None - ) -> HandleToolCallResult: + async def handle_pending_tool_call(self, params: ToolsHandlePendingToolCallRequest, *, timeout: float | None = None) -> HandleToolCallResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return HandleToolCallResult.from_dict( - await self._client.request( - "session.tools.handlePendingToolCall", params_dict, **_timeout_kwargs(timeout) - ) - ) + return HandleToolCallResult.from_dict(await self._client.request("session.tools.handlePendingToolCall", params_dict, **_timeout_kwargs(timeout))) class CommandsApi: @@ -4829,16 +4039,10 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_command( - self, params: CommandsHandlePendingCommandRequest, *, timeout: float | None = None - ) -> CommandsHandlePendingCommandResult: + async def handle_pending_command(self, params: CommandsHandlePendingCommandRequest, *, timeout: float | None = None) -> CommandsHandlePendingCommandResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return CommandsHandlePendingCommandResult.from_dict( - await self._client.request( - "session.commands.handlePendingCommand", params_dict, **_timeout_kwargs(timeout) - ) - ) + return CommandsHandlePendingCommandResult.from_dict(await self._client.request("session.commands.handlePendingCommand", params_dict, **_timeout_kwargs(timeout))) class UiApi: @@ -4846,27 +4050,15 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def elicitation( - self, params: UIElicitationRequest, *, timeout: float | None = None - ) -> UIElicitationResponse: + async def elicitation(self, params: UIElicitationRequest, *, timeout: float | None = None) -> UIElicitationResponse: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return UIElicitationResponse.from_dict( - await self._client.request( - "session.ui.elicitation", params_dict, **_timeout_kwargs(timeout) - ) - ) - - async def handle_pending_elicitation( - self, params: UIHandlePendingElicitationRequest, *, timeout: float | None = None - ) -> UIElicitationResult: + return UIElicitationResponse.from_dict(await self._client.request("session.ui.elicitation", params_dict, **_timeout_kwargs(timeout))) + + async def handle_pending_elicitation(self, params: UIHandlePendingElicitationRequest, *, timeout: float | None = None) -> UIElicitationResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return UIElicitationResult.from_dict( - await self._client.request( - "session.ui.handlePendingElicitation", params_dict, **_timeout_kwargs(timeout) - ) - ) + return UIElicitationResult.from_dict(await self._client.request("session.ui.handlePendingElicitation", params_dict, **_timeout_kwargs(timeout))) class PermissionsApi: @@ -4874,18 +4066,10 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def handle_pending_permission_request( - self, params: PermissionDecisionRequest, *, timeout: float | None = None - ) -> PermissionRequestResult: + async def handle_pending_permission_request(self, params: PermissionDecisionRequest, *, timeout: float | None = None) -> PermissionRequestResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return PermissionRequestResult.from_dict( - await self._client.request( - "session.permissions.handlePendingPermissionRequest", - params_dict, - **_timeout_kwargs(timeout), - ) - ) + return PermissionRequestResult.from_dict(await self._client.request("session.permissions.handlePendingPermissionRequest", params_dict, **_timeout_kwargs(timeout))) class ShellApi: @@ -4893,27 +4077,15 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id - async def exec( - self, params: ShellExecRequest, *, timeout: float | None = None - ) -> ShellExecResult: + async def exec(self, params: ShellExecRequest, *, timeout: float | None = None) -> ShellExecResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ShellExecResult.from_dict( - await self._client.request( - "session.shell.exec", params_dict, **_timeout_kwargs(timeout) - ) - ) - - async def kill( - self, params: ShellKillRequest, *, timeout: float | None = None - ) -> ShellKillResult: + return ShellExecResult.from_dict(await self._client.request("session.shell.exec", params_dict, **_timeout_kwargs(timeout))) + + async def kill(self, params: ShellKillRequest, *, timeout: float | None = None) -> ShellKillResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return ShellKillResult.from_dict( - await self._client.request( - "session.shell.kill", params_dict, **_timeout_kwargs(timeout) - ) - ) + return ShellKillResult.from_dict(await self._client.request("session.shell.kill", params_dict, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4923,24 +4095,12 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def compact(self, *, timeout: float | None = None) -> HistoryCompactResult: - return HistoryCompactResult.from_dict( - await self._client.request( - "session.history.compact", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) - - async def truncate( - self, params: HistoryTruncateRequest, *, timeout: float | None = None - ) -> HistoryTruncateResult: + return HistoryCompactResult.from_dict(await self._client.request("session.history.compact", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) + + async def truncate(self, params: HistoryTruncateRequest, *, timeout: float | None = None) -> HistoryTruncateResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return HistoryTruncateResult.from_dict( - await self._client.request( - "session.history.truncate", params_dict, **_timeout_kwargs(timeout) - ) - ) + return HistoryTruncateResult.from_dict(await self._client.request("session.history.truncate", params_dict, **_timeout_kwargs(timeout))) # Experimental: this API group is experimental and may change or be removed. @@ -4950,18 +4110,11 @@ def __init__(self, client: "JsonRpcClient", session_id: str): self._session_id = session_id async def get_metrics(self, *, timeout: float | None = None) -> UsageGetMetricsResult: - return UsageGetMetricsResult.from_dict( - await self._client.request( - "session.usage.getMetrics", - {"sessionId": self._session_id}, - **_timeout_kwargs(timeout), - ) - ) + return UsageGetMetricsResult.from_dict(await self._client.request("session.usage.getMetrics", {"sessionId": self._session_id}, **_timeout_kwargs(timeout))) class SessionRpc: """Typed session-scoped RPC methods.""" - def __init__(self, client: "JsonRpcClient", session_id: str): self._client = client self._session_id = session_id @@ -4987,172 +4140,107 @@ def __init__(self, client: "JsonRpcClient", session_id: str): async def log(self, params: LogRequest, *, timeout: float | None = None) -> LogResult: params_dict = {k: v for k, v in params.to_dict().items() if v is not None} params_dict["sessionId"] = self._session_id - return LogResult.from_dict( - await self._client.request("session.log", params_dict, **_timeout_kwargs(timeout)) - ) + return LogResult.from_dict(await self._client.request("session.log", params_dict, **_timeout_kwargs(timeout))) class SessionFsHandler(Protocol): async def read_file(self, params: SessionFSReadFileRequest) -> SessionFSReadFileResult: pass - async def write_file(self, params: SessionFSWriteFileRequest) -> None: pass - async def append_file(self, params: SessionFSAppendFileRequest) -> None: pass - async def exists(self, params: SessionFSExistsRequest) -> SessionFSExistsResult: pass - async def stat(self, params: SessionFSStatRequest) -> SessionFSStatResult: pass - async def mkdir(self, params: SessionFSMkdirRequest) -> None: pass - async def readdir(self, params: SessionFSReaddirRequest) -> SessionFSReaddirResult: pass - - async def readdir_with_types( - self, params: SessionFSReaddirWithTypesRequest - ) -> SessionFSReaddirWithTypesResult: + async def readdir_with_types(self, params: SessionFSReaddirWithTypesRequest) -> SessionFSReaddirWithTypesResult: pass - async def rm(self, params: SessionFSRmRequest) -> None: pass - async def rename(self, params: SessionFSRenameRequest) -> None: pass - @dataclass class ClientSessionApiHandlers: session_fs: SessionFsHandler | None = None - def register_client_session_api_handlers( client: "JsonRpcClient", get_handlers: Callable[[str], ClientSessionApiHandlers], ) -> None: """Register client-session request handlers on a JSON-RPC connection.""" - async def handle_session_fs_read_file(params: dict) -> dict | None: request = SessionFSReadFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") result = await handler.read_file(request) return result.to_dict() - client.set_request_handler("sessionFs.readFile", handle_session_fs_read_file) - async def handle_session_fs_write_file(params: dict) -> dict | None: request = SessionFSWriteFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") await handler.write_file(request) return None - client.set_request_handler("sessionFs.writeFile", handle_session_fs_write_file) - async def handle_session_fs_append_file(params: dict) -> dict | None: request = SessionFSAppendFileRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") await handler.append_file(request) return None - client.set_request_handler("sessionFs.appendFile", handle_session_fs_append_file) - async def handle_session_fs_exists(params: dict) -> dict | None: request = SessionFSExistsRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") result = await handler.exists(request) return result.to_dict() - client.set_request_handler("sessionFs.exists", handle_session_fs_exists) - async def handle_session_fs_stat(params: dict) -> dict | None: request = SessionFSStatRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") result = await handler.stat(request) return result.to_dict() - client.set_request_handler("sessionFs.stat", handle_session_fs_stat) - async def handle_session_fs_mkdir(params: dict) -> dict | None: request = SessionFSMkdirRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") await handler.mkdir(request) return None - client.set_request_handler("sessionFs.mkdir", handle_session_fs_mkdir) - async def handle_session_fs_readdir(params: dict) -> dict | None: request = SessionFSReaddirRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") result = await handler.readdir(request) return result.to_dict() - client.set_request_handler("sessionFs.readdir", handle_session_fs_readdir) - async def handle_session_fs_readdir_with_types(params: dict) -> dict | None: request = SessionFSReaddirWithTypesRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") result = await handler.readdir_with_types(request) return result.to_dict() - client.set_request_handler("sessionFs.readdirWithTypes", handle_session_fs_readdir_with_types) - async def handle_session_fs_rm(params: dict) -> dict | None: request = SessionFSRmRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") await handler.rm(request) return None - client.set_request_handler("sessionFs.rm", handle_session_fs_rm) - async def handle_session_fs_rename(params: dict) -> dict | None: request = SessionFSRenameRequest.from_dict(params) handler = get_handlers(request.session_id).session_fs - if handler is None: - raise RuntimeError( - f"No session_fs handler registered for session: {request.session_id}" - ) + if handler is None: raise RuntimeError(f"No session_fs handler registered for session: {request.session_id}") await handler.rename(request) return None - client.set_request_handler("sessionFs.rename", handle_session_fs_rename) From 2b09d4ff0813460570b17eb5430f730c243170f1 Mon Sep 17 00:00:00 2001 From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com> Date: Tue, 14 Apr 2026 22:37:40 +0000 Subject: [PATCH 4/5] Fix Python codegen: strip quicktype duplicate imports and trailing whitespace Agent-Logs-Url: https://github.com/github/copilot-sdk/sessions/a6ce684b-599e-45bd-956a-c351c5699f53 Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com> --- python/copilot/generated/rpc.py | 22 ++++++++++------------ scripts/codegen/python.ts | 18 +++++++++++++++++- 2 files changed, 27 insertions(+), 13 deletions(-) diff --git a/python/copilot/generated/rpc.py b/python/copilot/generated/rpc.py index 19a2660d5..a4f15d9e2 100644 --- a/python/copilot/generated/rpc.py +++ b/python/copilot/generated/rpc.py @@ -10,19 +10,17 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Protocol - - -from dataclasses import dataclass -from typing import Any, TypeVar, Callable, cast from datetime import datetime from enum import Enum +from typing import Any, Protocol, TypeVar, cast from uuid import UUID + import dateutil.parser T = TypeVar("T") EnumT = TypeVar("EnumT", bound=Enum) + def from_str(x: Any) -> str: assert isinstance(x, str) return x @@ -766,7 +764,7 @@ def to_dict(self) -> dict: class MCPServerSource(Enum): """Configuration source - + Configuration source: user, workspace, plugin, or builtin """ BUILTIN = "builtin" @@ -2344,15 +2342,15 @@ class Kind(Enum): class PermissionDecision: kind: Kind """The permission request was approved - + Denied because approval rules explicitly blocked it - + Denied because no approval rule matched and user confirmation was unavailable - + Denied by the user during an interactive prompt - + Denied by the organization's content exclusion policy - + Denied by a permission request hook registered by an extension or plugin """ rules: list[Any] | None = None @@ -2363,7 +2361,7 @@ class PermissionDecision: message: str | None = None """Human-readable explanation of why the path was excluded - + Optional message from the hook explaining the denial """ path: str | None = None diff --git a/scripts/codegen/python.ts b/scripts/codegen/python.ts index 62b53e1e6..46d11de83 100644 --- a/scripts/codegen/python.ts +++ b/scripts/codegen/python.ts @@ -1454,6 +1454,14 @@ async function generateRpc(schemaPath?: string): Promise { typesCode = modernizePython(typesCode); typesCode = collapsePlaceholderPythonDataclasses(typesCode); + // Strip quicktype's import block and preamble — we provide our own unified header. + // The preamble ends just before the first helper function (e.g. "def from_str") + // or class definition. + typesCode = typesCode.replace(/^[\s\S]*?(?=^(?:def |@dataclass|class )\w)/m, ""); + + // Strip trailing whitespace from blank lines (e.g. inside multi-line docstrings) + typesCode = typesCode.replace(/^\s+$/gm, ""); + // Annotate experimental data types const experimentalTypeNames = new Set(); for (const method of allMethods) { @@ -1494,7 +1502,15 @@ if TYPE_CHECKING: from collections.abc import Callable from dataclasses import dataclass -from typing import Protocol +from datetime import datetime +from enum import Enum +from typing import Any, Protocol, TypeVar, cast +from uuid import UUID + +import dateutil.parser + +T = TypeVar("T") +EnumT = TypeVar("EnumT", bound=Enum) `); lines.push(typesCode); From 210fa16894027e72e26f760afc110e16263a5d0b Mon Sep 17 00:00:00 2001 From: Stephen Toub Date: Tue, 14 Apr 2026 22:00:35 -0400 Subject: [PATCH 5/5] Fix build for workspaces RPC update Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com> --- dotnet/src/Generated/Rpc.cs | 2 +- go/internal/e2e/rpc_test.go | 12 ++++++------ nodejs/test/e2e/rpc.test.ts | 12 ++++++------ python/e2e/test_rpc.py | 22 +++++++++++----------- scripts/codegen/csharp.ts | 5 +++++ 5 files changed, 29 insertions(+), 24 deletions(-) diff --git a/dotnet/src/Generated/Rpc.cs b/dotnet/src/Generated/Rpc.cs index 5b7db655f..342d35c25 100644 --- a/dotnet/src/Generated/Rpc.cs +++ b/dotnet/src/Generated/Rpc.cs @@ -517,10 +517,10 @@ internal sealed class NameSetRequest public string SessionId { get; set; } = string.Empty; /// New session name (1–100 characters, trimmed of leading/trailing whitespace). + [UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")] [MinLength(1)] [MaxLength(100)] [JsonPropertyName("name")] - [UnconditionalSuppressMessage("Trimming", "IL2026:Members annotated with 'RequiresUnreferencedCodeAttribute' require dynamic access otherwise can break functionality when trimming application code", Justification = "")] public string Name { get; set; } = string.Empty; } diff --git a/go/internal/e2e/rpc_test.go b/go/internal/e2e/rpc_test.go index 5a79a7509..819e8ccca 100644 --- a/go/internal/e2e/rpc_test.go +++ b/go/internal/e2e/rpc_test.go @@ -307,7 +307,7 @@ func TestSessionRpc(t *testing.T) { } // Initially no files - initialFiles, err := session.RPC.Workspace.ListFiles(t.Context()) + initialFiles, err := session.RPC.Workspaces.ListFiles(t.Context()) if err != nil { t.Fatalf("Failed to list files: %v", err) } @@ -317,7 +317,7 @@ func TestSessionRpc(t *testing.T) { // Create a file fileContent := "Hello, workspace!" - _, err = session.RPC.Workspace.CreateFile(t.Context(), &rpc.WorkspaceCreateFileRequest{ + _, err = session.RPC.Workspaces.CreateFile(t.Context(), &rpc.WorkspacesCreateFileRequest{ Path: "test.txt", Content: fileContent, }) @@ -326,7 +326,7 @@ func TestSessionRpc(t *testing.T) { } // List files - afterCreate, err := session.RPC.Workspace.ListFiles(t.Context()) + afterCreate, err := session.RPC.Workspaces.ListFiles(t.Context()) if err != nil { t.Fatalf("Failed to list files after create: %v", err) } @@ -335,7 +335,7 @@ func TestSessionRpc(t *testing.T) { } // Read file - readResult, err := session.RPC.Workspace.ReadFile(t.Context(), &rpc.WorkspaceReadFileRequest{ + readResult, err := session.RPC.Workspaces.ReadFile(t.Context(), &rpc.WorkspacesReadFileRequest{ Path: "test.txt", }) if err != nil { @@ -346,7 +346,7 @@ func TestSessionRpc(t *testing.T) { } // Create nested file - _, err = session.RPC.Workspace.CreateFile(t.Context(), &rpc.WorkspaceCreateFileRequest{ + _, err = session.RPC.Workspaces.CreateFile(t.Context(), &rpc.WorkspacesCreateFileRequest{ Path: "subdir/nested.txt", Content: "Nested content", }) @@ -354,7 +354,7 @@ func TestSessionRpc(t *testing.T) { t.Fatalf("Failed to create nested file: %v", err) } - afterNested, err := session.RPC.Workspace.ListFiles(t.Context()) + afterNested, err := session.RPC.Workspaces.ListFiles(t.Context()) if err != nil { t.Fatalf("Failed to list files after nested: %v", err) } diff --git a/nodejs/test/e2e/rpc.test.ts b/nodejs/test/e2e/rpc.test.ts index bca4e8cd7..a4c333139 100644 --- a/nodejs/test/e2e/rpc.test.ts +++ b/nodejs/test/e2e/rpc.test.ts @@ -156,28 +156,28 @@ describe("Session RPC", async () => { const session = await client.createSession({ onPermissionRequest: approveAll }); // Initially no files - const initialFiles = await session.rpc.workspace.listFiles(); + const initialFiles = await session.rpc.workspaces.listFiles(); expect(initialFiles.files).toEqual([]); // Create a file const fileContent = "Hello, workspace!"; - await session.rpc.workspace.createFile({ path: "test.txt", content: fileContent }); + await session.rpc.workspaces.createFile({ path: "test.txt", content: fileContent }); // List files - const afterCreate = await session.rpc.workspace.listFiles(); + const afterCreate = await session.rpc.workspaces.listFiles(); expect(afterCreate.files).toContain("test.txt"); // Read file - const readResult = await session.rpc.workspace.readFile({ path: "test.txt" }); + const readResult = await session.rpc.workspaces.readFile({ path: "test.txt" }); expect(readResult.content).toBe(fileContent); // Create nested file - await session.rpc.workspace.createFile({ + await session.rpc.workspaces.createFile({ path: "subdir/nested.txt", content: "Nested content", }); - const afterNested = await session.rpc.workspace.listFiles(); + const afterNested = await session.rpc.workspaces.listFiles(); expect(afterNested.files).toContain("test.txt"); expect(afterNested.files.some((f) => f.includes("nested.txt"))).toBe(true); }); diff --git a/python/e2e/test_rpc.py b/python/e2e/test_rpc.py index 0d9f9a4eb..c5e9a7b79 100644 --- a/python/e2e/test_rpc.py +++ b/python/e2e/test_rpc.py @@ -187,8 +187,8 @@ async def test_read_update_and_delete_plan(self): async def test_create_list_and_read_workspace_files(self): """Test creating, listing, and reading workspace files""" from copilot.generated.rpc import ( - WorkspaceCreateFileRequest, - WorkspaceReadFileRequest, + WorkspacesCreateFileRequest, + WorkspacesReadFileRequest, ) client = CopilotClient(SubprocessConfig(cli_path=CLI_PATH, use_stdio=True)) @@ -200,31 +200,31 @@ async def test_create_list_and_read_workspace_files(self): ) # Initially no files - initial_files = await session.rpc.workspace.list_files() + initial_files = await session.rpc.workspaces.list_files() assert initial_files.files == [] # Create a file file_content = "Hello, workspace!" - await session.rpc.workspace.create_file( - WorkspaceCreateFileRequest(content=file_content, path="test.txt") + await session.rpc.workspaces.create_file( + WorkspacesCreateFileRequest(content=file_content, path="test.txt") ) # List files - after_create = await session.rpc.workspace.list_files() + after_create = await session.rpc.workspaces.list_files() assert "test.txt" in after_create.files # Read file - read_result = await session.rpc.workspace.read_file( - WorkspaceReadFileRequest(path="test.txt") + read_result = await session.rpc.workspaces.read_file( + WorkspacesReadFileRequest(path="test.txt") ) assert read_result.content == file_content # Create nested file - await session.rpc.workspace.create_file( - WorkspaceCreateFileRequest(content="Nested content", path="subdir/nested.txt") + await session.rpc.workspaces.create_file( + WorkspacesCreateFileRequest(content="Nested content", path="subdir/nested.txt") ) - after_nested = await session.rpc.workspace.list_files() + after_nested = await session.rpc.workspaces.list_files() assert "test.txt" in after_nested.files assert any("nested.txt" in f for f in after_nested.files) diff --git a/scripts/codegen/csharp.ts b/scripts/codegen/csharp.ts index 9e63b68ea..243047fb6 100644 --- a/scripts/codegen/csharp.ts +++ b/scripts/codegen/csharp.ts @@ -258,6 +258,11 @@ function emitDataAnnotations(schema: JSONSchema7, indent: string): string[] { } // [MinLength] / [MaxLength] for string constraints + if (typeof schema.minLength === "number" || typeof schema.maxLength === "number") { + attrs.push( + `${indent}[UnconditionalSuppressMessage("Trimming", "IL2026", Justification = "Safe for generated string properties: JSON Schema minLength/maxLength map to string length validation, not reflection over trimmed Count members")]` + ); + } if (typeof schema.minLength === "number") { attrs.push(`${indent}[MinLength(${schema.minLength})]`); }