Remove Rust-only Session convenience methods for cross-SDK parity

Same audit shape as the send_telemetry removal: a sweep of public
methods that exist as Rust convenience wrappers on top of a typed
RPC, with no equivalent surface in the Node, Python, Go, or .NET
SDKs (zero matches across all four SDK source trees).

The methods are reachable cross-SDK through the typed `rpc()`
namespace — Rust callers simply switch from
`session.method()` to `session.rpc().<namespace>().<method>()`,
mirroring how Node/Python/Go/.NET consumers already drive these.

Removed from `Session`:
- get_model
- set_mode / get_mode
- set_name / get_name
- read_plan / update_plan / delete_plan
- list_workspace_files / read_workspace_file / create_workspace_file
- start_fleet
- set_approve_all_permissions
- call_rpc (generic forwarder; the typed rpc() namespace replaces it)

Removed from `Client`:
- get_quota (typed `client.rpc().account().get_quota()` already
  available everywhere including Rust)

Kept on Session: send, send_and_wait, abort, set_model, log,
disconnect/destroy, subscribe, capabilities, cancellation_token,
stop_event_loop, ui (and the field accessors id/cwd/workspace_path/
remote_url). These are either present in every SDK already (abort,
set_model, send/send_and_wait, log, disconnect) or are Rust-shape
helpers that don't have a typed RPC equivalent (subscribe,
cancellation_token, ui sub-API).

Updated:
- README "Rust-only API" section: dropped the "First-class Session
  convenience methods" bullet and the Client::get_quota bullet.
  What remains as Rust-only is now strictly language-shape items
  (newtypes, Transport enum, permission builders, from_streams,
  on_auto_mode_switch).
- CHANGELOG: dropped enumeration of the removed methods; restated
  what stays.
- 5 integration tests removed (get_name, set_name, list_workspace_files,
  read_workspace_file, create_workspace_file) plus the dispatch-table
  case for session.plan.delete.
- Unused imports cleaned up in session.rs.

Migration for the github-app consumer (the only known caller):
- session.set_approve_all_permissions(b)
  -> session.rpc().permissions().set_approve_all(
       PermissionsSetApproveAllRequest { enabled: b })
- session.set_mode("plan")
  -> session.rpc().mode().set(ModeSetRequest { mode: ... })
- session.read_plan()
  -> session.rpc().plan().read()
- (etc — all typed RPC namespace calls)

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

Author: tclem

rust/CHANGELOG.md

@@ -42,7 +42,7 @@ public surface.
   `get_last_session_id`, `get_foreground_session_id`,
   `set_foreground_session_id`.
 - `Client::list_models`, `get_status` (typed `GetStatusResponse`),
-  `get_auth_status` (typed `GetAuthStatusResponse`), `get_quota`.
+  `get_auth_status` (typed `GetAuthStatusResponse`).
 
 #### Sessions
 - `Client::create_session` and `Client::resume_session` accepting
@@ -54,19 +54,14 @@ public surface.
 - `Session::subscribe` returning an `EventSubscription` for observe-only
   access to the session's event stream. Implements `tokio_stream::Stream`
   and offers an inherent `recv()`; drop the value to unsubscribe.
-- Mode + model controls: `get_mode` / `set_mode`, `get_model` /
-  `set_model(model, SetModelOptions)` with `reasoning_effort` and
-  `model_capabilities` overrides.
-- Plan helpers: `read_plan`, `delete_plan`.
-- Workspace helpers: `list_workspace_files`, `read_workspace_file`,
-  `create_workspace_file`, `cwd`, `remote_url`.
+- `Session::set_model(model, SetModelOptions)` with `reasoning_effort`
+  and `model_capabilities` overrides (matches Node/Python/.NET).
 - UI primitives: `session.ui().elicitation()`, `confirm()`, `select()`,
   `input()` — grouped under a `SessionUi` sub-API to mirror .NET / Python /
   Go.
 - `Session::log(message, LogOptions)` with optional severity and
   ephemeral flag.
-- `Session::start_fleet`, `abort`, `set_approve_all_permissions`,
-  `set_name`.
+- `Session::abort` (matches all other SDKs).
 - `Session::disconnect` (canonical) and `Session::destroy` (alias)
   preserve on-disk session state for later resume.
 - `Session::stop_event_loop` for shutting down the per-session loop.

rust/README.md

@@ -681,21 +681,6 @@ gets to be Rust here — cross-SDK parity for these is a post-release
 conversation, not a release blocker. None of these are deprecated and
 none of them are scheduled for removal.
 
-- **`Client::get_quota`** — top-level convenience wrapper for fetching
-  account-level request quota snapshots. Rust-only as of 0.1.0; the other
-  SDKs do not expose a client-level shortcut. The underlying
-  `account.getQuota` JSON-RPC endpoint itself is available cross-SDK via
-  each SDK's typed `rpc()` namespace (Node
-  `client.rpc().account().getQuota()`, Python
-  `client.rpc().account.get_quota()`, Go
-  `client.Rpc().Account().GetQuota()`, .NET
-  `client.Rpc().Account().GetQuotaAsync()`), including in Rust at
-  `client.rpc().account().get_quota()`.
-- **First-class `Session` convenience methods** — `set_mode` / `get_mode`,
-  `set_name` / `get_name`, `get_model`, `read_plan` / `update_plan` /
-  `delete_plan`, `start_fleet`, `list_workspace_files` /
-  `read_workspace_file` / `create_workspace_file`. The other SDKs require
-  the consumer to drive the typed JSON-RPC namespace directly for these.
 - **Typed newtypes** — `SessionId` and `RequestId` are `#[serde(transparent)]`
   newtypes around `String`, so the type system distinguishes a session
   identifier from an arbitrary `String` at compile time. Node/Python/Go

rust/src/lib.rs

@@ -1680,21 +1680,6 @@ impl Client {
         }
     }
 
-    /// Fetch account-level quota snapshots (request-based usage).
-    ///
-    /// This top-level convenience wrapper is Rust-only as of 0.1.0; the Node,
-    /// Python, Go, and .NET SDKs do not expose a client-level shortcut for
-    /// quota lookup. The underlying `account.getQuota` JSON-RPC endpoint is
-    /// itself available cross-SDK via each SDK's typed `rpc()` namespace
-    /// (Node `client.rpc().account().getQuota()`, Python
-    /// `client.rpc().account.get_quota()`, Go `client.Rpc().Account().GetQuota()`,
-    /// .NET `client.Rpc().Account().GetQuotaAsync()`), and in Rust at
-    /// `client.rpc().account().get_quota()`. This wrapper is a thin shortcut
-    /// for that same call.
-    pub async fn get_quota(&self) -> Result<generated::api_types::AccountGetQuotaResult, Error> {
-        self.rpc().account().get_quota().await
-    }
-
     /// Return the OS process ID of the CLI child process, if one was spawned.
     pub fn pid(&self) -> Option<u32> {
         self.inner.child.lock().as_ref().and_then(|c| c.id())

rust/src/session.rs

@@ -11,10 +11,8 @@ use tokio_util::sync::CancellationToken;
 use tracing::{Instrument, warn};
 
 use crate::generated::api_types::{
-    LogRequest, ModeSetRequest, ModelSwitchToRequest, NameSetRequest, PermissionDecision,
-    PermissionDecisionApproveOnce, PermissionDecisionApproveOnceKind, PermissionDecisionReject,
-    PermissionDecisionRejectKind, PlanUpdateRequest, SessionMode, WorkspacesCreateFileRequest,
-    WorkspacesReadFileRequest,
+    LogRequest, ModelSwitchToRequest, PermissionDecision, PermissionDecisionApproveOnce,
+    PermissionDecisionApproveOnceKind, PermissionDecisionReject, PermissionDecisionRejectKind,
 };
 use crate::generated::session_events::{
     CommandExecuteData, ElicitationRequestedData, ExternalToolRequestedData, SessionErrorData,
@@ -320,17 +318,6 @@ impl Session {
         Ok(message_id)
     }
 
-    /// Enable or disable session-wide auto-approval for tool permission requests.
-    pub async fn set_approve_all_permissions(&self, enabled: bool) -> Result<(), Error> {
-        self.rpc()
-            .permissions()
-            .set_approve_all(
-                crate::generated::api_types::PermissionsSetApproveAllRequest { enabled },
-            )
-            .await?;
-        Ok(())
-    }
-
     /// Send a user message and wait for the agent to finish processing.
     ///
     /// Accepts anything convertible to [`MessageOptions`] — pass a `&str` for the
@@ -436,45 +423,6 @@ impl Session {
         Ok(())
     }
 
-    /// Get the current model.
-    pub async fn get_model(&self) -> Result<Option<String>, Error> {
-        Ok(self.rpc().model().get_current().await?.model_id)
-    }
-
-    /// Set the session mode (e.g. "interactive", "plan", "autopilot").
-    pub async fn set_mode(&self, mode: &str) -> Result<String, Error> {
-        let parsed: SessionMode = serde_json::from_value(Value::String(mode.to_string()))?;
-        self.rpc()
-            .mode()
-            .set(ModeSetRequest { mode: parsed })
-            .await?;
-        Ok(mode.to_string())
-    }
-
-    /// Get the current session mode.
-    pub async fn get_mode(&self) -> Result<String, Error> {
-        let mode = self.rpc().mode().get().await?;
-        Ok(serde_json::to_value(mode)?
-            .as_str()
-            .unwrap_or("interactive")
-            .to_string())
-    }
-
-    /// Get the current session name.
-    pub async fn get_name(&self) -> Result<Option<String>, Error> {
-        Ok(self.rpc().name().get().await?.name)
-    }
-
-    /// Set the current session name.
-    pub async fn set_name(&self, name: &str) -> Result<(), Error> {
-        self.rpc()
-            .name()
-            .set(NameSetRequest {
-                name: name.to_string(),
-            })
-            .await
-    }
-
     /// Disconnect this session from the CLI.
     ///
     /// Sends the `session.destroy` RPC, stops the event loop, and unregisters
@@ -512,55 +460,6 @@ impl Session {
         self.disconnect().await
     }
 
-    /// List files in the session workspace.
-    pub async fn list_workspace_files(&self) -> Result<Vec<String>, Error> {
-        Ok(self.rpc().workspaces().list_files().await?.files)
-    }
-
-    /// Read a file from the session workspace.
-    pub async fn read_workspace_file(&self, path: &Path) -> Result<String, Error> {
-        Ok(self
-            .rpc()
-            .workspaces()
-            .read_file(WorkspacesReadFileRequest {
-                path: path.to_string_lossy().into_owned(),
-            })
-            .await?
-            .content)
-    }
-
-    /// Create a file in the session workspace.
-    pub async fn create_workspace_file(&self, path: &Path, content: &str) -> Result<(), Error> {
-        self.rpc()
-            .workspaces()
-            .create_file(WorkspacesCreateFileRequest {
-                path: path.to_string_lossy().into_owned(),
-                content: content.to_string(),
-            })
-            .await
-    }
-
-    /// Read the session plan.
-    pub async fn read_plan(&self) -> Result<(bool, Option<String>), Error> {
-        let r = self.rpc().plan().read().await?;
-        Ok((r.exists, r.content))
-    }
-
-    /// Update the session plan.
-    pub async fn update_plan(&self, content: &str) -> Result<(), Error> {
-        self.rpc()
-            .plan()
-            .update(PlanUpdateRequest {
-                content: content.to_string(),
-            })
-            .await
-    }
-
-    /// Delete the session plan.
-    pub async fn delete_plan(&self) -> Result<(), Error> {
-        self.rpc().plan().delete().await
-    }
-
     /// Write a log message to the session.
     ///
     /// Pass `None` for `opts` to use defaults (info level, persisted).
@@ -607,34 +506,6 @@ impl Session {
         }
         Ok(())
     }
-
-    /// Start a fleet of sub-agents.
-    pub async fn start_fleet(&self, prompt: Option<&str>) -> Result<bool, Error> {
-        Ok(self
-            .rpc()
-            .fleet()
-            .start(crate::generated::api_types::FleetStartRequest {
-                prompt: prompt.map(|s| s.to_string()),
-            })
-            .await?
-            .started)
-    }
-
-    /// Generic RPC forwarder — auto-injects sessionId into params.
-    pub async fn call_rpc(
-        &self,
-        method: &str,
-        extra_params: Option<Value>,
-    ) -> Result<Value, Error> {
-        let mut params = serde_json::json!({ "sessionId": self.id });
-        let extra_obj = extra_params.as_ref().and_then(Value::as_object);
-        if let (Some(base), Some(extra_obj)) = (params.as_object_mut(), extra_obj) {
-            for (k, v) in extra_obj {
-                base.insert(k.clone(), v.clone());
-            }
-        }
-        self.client.call(method, Some(params)).await
-    }
 }
 
 impl Drop for Session {

rust/tests/session_test.rs

@@ -377,7 +377,6 @@ async fn session_rpc_methods_send_correct_method_names() {
 
     let cases: Vec<(&str, Option<&str>)> = vec![
         ("session.abort", None),
-        ("session.plan.delete", None),
         ("session.log", Some("message")),
         ("session.destroy", None),
     ];
@@ -387,7 +386,6 @@ async fn session_rpc_methods_send_correct_method_names() {
         let handle = tokio::spawn(async move {
             match expected_method {
                 "session.abort" => s.abort().await.map(|_| ()),
-                "session.plan.delete" => s.delete_plan().await,
                 "session.log" => s.log("test msg", None).await,
                 "session.destroy" => s.destroy().await,
                 _ => unreachable!(),
@@ -1008,46 +1006,6 @@ async fn set_model_sends_switch_to_request() {
     timeout(TIMEOUT, handle).await.unwrap().unwrap();
 }
 
-#[tokio::test]
-async fn get_name_returns_name() {
-    let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;
-    let session = Arc::new(session);
-
-    let handle = tokio::spawn({
-        let session = session.clone();
-        async move { session.get_name().await.unwrap() }
-    });
-
-    let request = server.read_request().await;
-    assert_eq!(request["method"], "session.name.get");
-    server
-        .respond(&request, serde_json::json!({ "name": "Fix input flicker" }))
-        .await;
-
-    assert_eq!(
-        timeout(TIMEOUT, handle).await.unwrap().unwrap(),
-        Some("Fix input flicker".to_string())
-    );
-}
-
-#[tokio::test]
-async fn set_name_sends_name() {
-    let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;
-    let session = Arc::new(session);
-
-    let handle = tokio::spawn({
-        let session = session.clone();
-        async move { session.set_name("Fix input flicker").await.unwrap() }
-    });
-
-    let request = server.read_request().await;
-    assert_eq!(request["method"], "session.name.set");
-    assert_eq!(request["params"]["name"], "Fix input flicker");
-    server.respond(&request, serde_json::json!(null)).await;
-
-    timeout(TIMEOUT, handle).await.unwrap().unwrap();
-}
-
 #[tokio::test]
 async fn elicitation_returns_typed_result() {
     let (session, mut server) = create_session_pair_with_capabilities(
@@ -2407,70 +2365,6 @@ async fn system_message_transform_returns_error_for_missing_sections() {
     assert_eq!(response["error"]["code"], -32602);
 }
 
-#[tokio::test]
-async fn list_workspace_files_uses_plural_method_name() {
-    let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;
-    let session = Arc::new(session);
-
-    let s = session.clone();
-    let handle = tokio::spawn(async move { s.list_workspace_files().await });
-
-    let request = server.read_request().await;
-    assert_eq!(request["method"], "session.workspaces.listFiles");
-    assert_eq!(request["params"]["sessionId"], server.session_id);
-    server
-        .respond(
-            &request,
-            serde_json::json!({ "files": ["a.txt", "subdir/b.txt"] }),
-        )
-        .await;
-
-    let files = timeout(TIMEOUT, handle).await.unwrap().unwrap().unwrap();
-    assert_eq!(files, vec!["a.txt".to_string(), "subdir/b.txt".to_string()]);
-}
-
-#[tokio::test]
-async fn read_workspace_file_uses_plural_method_name_and_forwards_path() {
-    let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;
-    let session = Arc::new(session);
-
-    let s = session.clone();
-    let handle =
-        tokio::spawn(async move { s.read_workspace_file(Path::new("notes/plan.md")).await });
-
-    let request = server.read_request().await;
-    assert_eq!(request["method"], "session.workspaces.readFile");
-    assert_eq!(request["params"]["sessionId"], server.session_id);
-    assert_eq!(request["params"]["path"], "notes/plan.md");
-    server
-        .respond(&request, serde_json::json!({ "content": "hello" }))
-        .await;
-
-    let content = timeout(TIMEOUT, handle).await.unwrap().unwrap().unwrap();
-    assert_eq!(content, "hello");
-}
-
-#[tokio::test]
-async fn create_workspace_file_uses_plural_method_name_and_forwards_payload() {
-    let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;
-    let session = Arc::new(session);
-
-    let s = session.clone();
-    let handle = tokio::spawn(async move {
-        s.create_workspace_file(Path::new("notes/plan.md"), "body")
-            .await
-    });
-
-    let request = server.read_request().await;
-    assert_eq!(request["method"], "session.workspaces.createFile");
-    assert_eq!(request["params"]["sessionId"], server.session_id);
-    assert_eq!(request["params"]["path"], "notes/plan.md");
-    assert_eq!(request["params"]["content"], "body");
-    server.respond(&request, serde_json::json!({})).await;
-
-    timeout(TIMEOUT, handle).await.unwrap().unwrap().unwrap();
-}
-
 #[tokio::test]
 async fn rpc_namespace_session_agent_list_dispatches_correctly() {
     let (session, mut server) = create_session_pair(Arc::new(NoopHandler)).await;