Use generated session capability enum

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

Author: Morabbin

rust/README.md

@@ -135,36 +135,14 @@ let session = client.resume_session(
 | `SessionStore`       | `session-store`         | Cross-session history tools and session-store metadata |
 | `McpApps`            | `mcp-apps`              | MCP-Apps `ui://` resource passthrough (SEP-1865)      |
 | `CanvasRenderer`     | `canvas-renderer`       | Host-rendered extension canvases                      |
-| `Other(String)`      | *(verbatim)*            | Forward-compat escape hatch for unknown future names  |
+| `Unknown`            | *(none)*                | Deserialization fallback; rejected for outbound config |
 
 **Disable-wins semantics.** If the same capability appears in both
 `enabled_capabilities` and `disabled_capabilities`, disable wins. The runtime
 starts from an `SDK_CAPABILITIES` baseline; enabled capabilities extend it and
-disabled capabilities remove from it, in that order.
-
-**Forward compatibility.** The enum is `#[non_exhaustive]` and carries an
-`Other(String)` variant so callers on older SDK builds can opt into
-capabilities that the runtime adds ahead of a new SDK release, without any
-recompile-blocking enum-variant additions:
-
-```rust,ignore
-use github_copilot_sdk::{SessionCapability, SessionConfig};
-
-// Opt into a capability the SDK doesn't know about yet.
-let config = SessionConfig::default()
-    .with_enable_capability(SessionCapability::Other("future-cap".to_string()));
-```
-
-`&str` and `String` implement `Into<SessionCapability>`, so you can also pass
-string literals directly to the builders:
-
-```rust,ignore
-use github_copilot_sdk::SessionConfig;
-
-let config = SessionConfig::default()
-    .with_enable_capability("memory")          // &str coerces to SessionCapability
-    .with_disable_capability("plan-mode");
-```
+disabled capabilities remove from it, in that order. `SessionCapability::Unknown`
+exists only as a generated deserialization fallback and is rejected if supplied
+to the create/resume capability builders.
 
 ### Session
 
@@ -802,9 +780,8 @@ 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.
 
-- **`SessionCapability` enum** -- typed, `#[non_exhaustive]` enum for per-session
-  capability opt-in / opt-out, with an `Other(String)` escape hatch for
-  forward compatibility. Sent via `enabledCapabilities` /
+- **`SessionCapability` enum** -- generated typed enum for per-session
+  capability opt-in / opt-out. Sent via `enabledCapabilities` /
   `disabledCapabilities` on the `session.create` and `session.resume` wire
   calls -- works for all transports including `Transport::External`. See
   [Session capabilities](#session-capabilities) above. Marked

rust/src/lib.rs

@@ -402,162 +402,6 @@ impl OtelExporterType {
     }
 }
 
-/// A named session capability sent in the `session.create` and
-/// `session.resume` wire payloads.
-///
-/// Capabilities gate optional CLI features (extra tools, system-prompt
-/// sections, host-rendered surfaces). The runtime starts from a
-/// hard-coded `SDK_CAPABILITIES` set; use
-/// [`SessionConfig::with_enable_capability`] /
-/// [`SessionConfig::with_disable_capability`] (and their plural
-/// counterparts) to opt individual sessions in or out.
-///
-/// > **Not** the same as [`SessionCapabilities`] — that struct is the
-/// > *runtime-negotiated* capability descriptor reported by the CLI on
-/// > `session.create`. [`SessionCapability`] is the *opt-in / opt-out
-/// > toggle name* sent with each `session.create` / `session.resume`.
-/// >
-/// > This public type is also separate from the generated protocol enum:
-/// > unknown generated enum values collapse to `Unknown`, while callers
-/// > need [`Other`](Self::Other) to preserve and send capability names
-/// > introduced by newer runtimes.
-///
-/// The runtime's overlap semantics are **disable-wins**: if a capability
-/// appears in both the enabled and disabled lists, the disable wins.
-/// The SDK preserves the order callers add capabilities in so the
-/// resulting wire payload is deterministic.
-///
-/// The enum is `#[non_exhaustive]` and carries an [`Other`](Self::Other)
-/// variant so forward-compat capabilities the runtime grows ahead of an
-/// SDK release can still be opted into without waiting for a new
-/// enum variant.
-///
-/// Requires runtime support for per-session capability controls.
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-#[non_exhaustive]
-pub enum SessionCapability {
-    /// TUI-only prompt hints (keyboard shortcuts).
-    TuiHints,
-    /// `[[PLAN]]` handling and plan-mode instructions.
-    PlanMode,
-    /// `store_memory` tool and the `<memories>` system-prompt section.
-    Memory,
-    /// `fetch_copilot_cli_documentation` tool plus the
-    /// `<self_documentation>` system-prompt section.
-    CliDocumentation,
-    /// `ask_user` tool for interactive clarification.
-    AskUser,
-    /// Interactive-CLI identity (vs non-interactive / headless).
-    InteractiveMode,
-    /// Automatic system notifications to the agent (batched, hidden
-    /// from the user timeline).
-    SystemNotifications,
-    /// Elicitation support (confirm / select / input prompts).
-    Elicitation,
-    /// Cross-session history tools and session-store prompt/tool metadata.
-    SessionStore,
-    /// MCP-Apps (SEP-1865) `ui://` resource passthrough.
-    McpApps,
-    /// Extension-provided canvases rendered by the host.
-    CanvasRenderer,
-    /// A capability name the SDK doesn't have a typed variant for yet.
-    ///
-    /// Pass any kebab-case capability string here to forward it
-    /// verbatim to the runtime.
-    Other(String),
-}
-
-impl SessionCapability {
-    /// The kebab-case wire string sent in `enabledCapabilities` /
-    /// `disabledCapabilities` on `session.create` and `session.resume`.
-    pub fn as_str(&self) -> &str {
-        match self {
-            Self::TuiHints => "tui-hints",
-            Self::PlanMode => "plan-mode",
-            Self::Memory => "memory",
-            Self::CliDocumentation => "cli-documentation",
-            Self::AskUser => "ask-user",
-            Self::InteractiveMode => "interactive-mode",
-            Self::SystemNotifications => "system-notifications",
-            Self::Elicitation => "elicitation",
-            Self::SessionStore => "session-store",
-            Self::McpApps => "mcp-apps",
-            Self::CanvasRenderer => "canvas-renderer",
-            Self::Other(name) => name.as_str(),
-        }
-    }
-
-    fn from_known_name(name: &str) -> Option<Self> {
-        Some(match name {
-            "tui-hints" => Self::TuiHints,
-            "plan-mode" => Self::PlanMode,
-            "memory" => Self::Memory,
-            "cli-documentation" => Self::CliDocumentation,
-            "ask-user" => Self::AskUser,
-            "interactive-mode" => Self::InteractiveMode,
-            "system-notifications" => Self::SystemNotifications,
-            "elicitation" => Self::Elicitation,
-            "session-store" => Self::SessionStore,
-            "mcp-apps" => Self::McpApps,
-            "canvas-renderer" => Self::CanvasRenderer,
-            _ => return None,
-        })
-    }
-}
-
-impl std::fmt::Display for SessionCapability {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(self.as_str())
-    }
-}
-
-impl std::str::FromStr for SessionCapability {
-    type Err = std::convert::Infallible;
-
-    /// Parse a kebab-case capability name. Unknown names round-trip
-    /// through [`SessionCapability::Other`] so old SDK builds stay
-    /// useful against CLIs that add new capabilities. Always returns
-    /// `Ok` — the error type is [`Infallible`](std::convert::Infallible).
-    fn from_str(s: &str) -> std::result::Result<Self, std::convert::Infallible> {
-        Ok(Self::from(s))
-    }
-}
-
-impl From<&str> for SessionCapability {
-    fn from(s: &str) -> Self {
-        Self::from_known_name(s).unwrap_or_else(|| Self::Other(s.to_owned()))
-    }
-}
-
-impl From<String> for SessionCapability {
-    fn from(s: String) -> Self {
-        if let Some(capability) = Self::from_known_name(&s) {
-            capability
-        } else {
-            Self::Other(s)
-        }
-    }
-}
-
-impl Serialize for SessionCapability {
-    fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        serializer.serialize_str(self.as_str())
-    }
-}
-
-impl<'de> Deserialize<'de> for SessionCapability {
-    fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let capability = String::deserialize(deserializer)?;
-        Ok(Self::from(capability))
-    }
-}
-
 /// OpenTelemetry configuration forwarded to the spawned GitHub Copilot CLI
 /// process.
 ///
@@ -2535,106 +2379,6 @@ mod tests {
         assert_eq!(Client::remote_args(&opts), vec!["--remote".to_string()]);
     }
 
-    #[test]
-    fn session_capability_round_trips_via_str() {
-        for cap in [
-            SessionCapability::TuiHints,
-            SessionCapability::PlanMode,
-            SessionCapability::Memory,
-            SessionCapability::CliDocumentation,
-            SessionCapability::AskUser,
-            SessionCapability::InteractiveMode,
-            SessionCapability::SystemNotifications,
-            SessionCapability::Elicitation,
-            SessionCapability::SessionStore,
-            SessionCapability::McpApps,
-            SessionCapability::CanvasRenderer,
-        ] {
-            let s = cap.to_string();
-            let parsed: SessionCapability = s.parse().unwrap();
-            assert_eq!(parsed, cap, "round-trip failed for {s}");
-        }
-    }
-
-    #[test]
-    fn session_capability_from_str_falls_back_to_other_for_unknown_names() {
-        let parsed: SessionCapability = "brand-new-cap".parse().unwrap();
-        assert_eq!(
-            parsed,
-            SessionCapability::Other("brand-new-cap".to_string())
-        );
-        assert_eq!(parsed.as_str(), "brand-new-cap");
-    }
-
-    #[test]
-    fn session_capability_into_from_str_and_string() {
-        let from_str: SessionCapability = "memory".into();
-        let from_string: SessionCapability = "memory".to_string().into();
-        assert_eq!(from_str, SessionCapability::Memory);
-        assert_eq!(from_string, SessionCapability::Memory);
-        // Unknown names go to Other
-        let other: SessionCapability = "future-cap".into();
-        assert_eq!(other, SessionCapability::Other("future-cap".to_string()));
-    }
-
-    #[test]
-    fn session_capability_serializes_as_wire_string() {
-        assert_eq!(
-            serde_json::to_value(SessionCapability::Memory).unwrap(),
-            serde_json::json!("memory")
-        );
-        assert_eq!(
-            serde_json::to_value(SessionCapability::Other("future-cap".to_string())).unwrap(),
-            serde_json::json!("future-cap")
-        );
-    }
-
-    #[test]
-    fn session_capability_deserializes_unknown_as_other() {
-        let parsed: SessionCapability =
-            serde_json::from_value(serde_json::json!("future-cap")).unwrap();
-        assert_eq!(parsed, SessionCapability::Other("future-cap".to_string()));
-    }
-
-    #[test]
-    fn generated_session_capabilities_have_public_variants() {
-        use crate::generated::api_types::SessionCapability as GeneratedSessionCapability;
-
-        fn expected_wire_name(capability: GeneratedSessionCapability) -> Option<&'static str> {
-            match capability {
-                GeneratedSessionCapability::TuiHints => Some("tui-hints"),
-                GeneratedSessionCapability::PlanMode => Some("plan-mode"),
-                GeneratedSessionCapability::Memory => Some("memory"),
-                GeneratedSessionCapability::CliDocumentation => Some("cli-documentation"),
-                GeneratedSessionCapability::AskUser => Some("ask-user"),
-                GeneratedSessionCapability::InteractiveMode => Some("interactive-mode"),
-                GeneratedSessionCapability::SystemNotifications => Some("system-notifications"),
-                GeneratedSessionCapability::Elicitation => Some("elicitation"),
-                GeneratedSessionCapability::SessionStore => Some("session-store"),
-                GeneratedSessionCapability::McpApps => Some("mcp-apps"),
-                GeneratedSessionCapability::CanvasRenderer => Some("canvas-renderer"),
-                GeneratedSessionCapability::Unknown => None,
-            }
-        }
-
-        for generated in [
-            GeneratedSessionCapability::TuiHints,
-            GeneratedSessionCapability::PlanMode,
-            GeneratedSessionCapability::Memory,
-            GeneratedSessionCapability::CliDocumentation,
-            GeneratedSessionCapability::AskUser,
-            GeneratedSessionCapability::InteractiveMode,
-            GeneratedSessionCapability::SystemNotifications,
-            GeneratedSessionCapability::Elicitation,
-            GeneratedSessionCapability::SessionStore,
-            GeneratedSessionCapability::McpApps,
-            GeneratedSessionCapability::CanvasRenderer,
-        ] {
-            let wire_name = expected_wire_name(generated).unwrap();
-            assert_eq!(SessionCapability::from(wire_name).as_str(), wire_name);
-        }
-    }
-
     #[test]
     fn log_level_args_omitted_when_unset() {
         let opts = ClientOptions::default();