@corbet-labs/ccht 0.1.0 → 0.2.0

package/README.md

@@ -24,14 +24,14 @@ call paid model HTTP APIs or select an API-key fallback.
 
 ```toml
 [dependencies]
-ccht = "0.1"
+ccht = "0.2"
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 ```
 
 `native` is the default feature. For the portable model alone:
 
 ```toml
-ccht = { version = "0.1", default-features = false }
+ccht = { version = "0.2", default-features = false }
 ```
 
 ```rust
@@ -62,6 +62,16 @@ A session accepts one active prompt; another returns `Busy`. Different sessions
 have separate streams and permission identities. History load/resume and model
 selection require the agent's advertised capabilities; unsupported requests fail.
 
+`session.handle().configuration()` exposes the agent's ordered model, reasoning,
+mode and boolean controls. Call `set_model(id)` or `set_config_option(id, value)`
+to change them. The full response replaces the advertised configuration, including
+dependent options; configuration notifications update both the native handle and
+the portable conversation snapshot. Unknown values fail without a fallback.
+`SessionOptions::configuration` applies explicit settings when creating or restoring
+a session. Retain the agent session ID and its working directory in your product
+storage to resume completed conversations across process restarts. Never replay an
+uncertain delivery automatically.
+
 Permissions default to denial. Applications that opt into asking must render the
 request, check their authority and respond with one of the advertised choices.
 A permission callback is not a sandbox: agent-owned tools may have separate runtime
@@ -103,12 +113,51 @@ render(snapshot.turns);
 conversation.free();
 ```
 
-Without an explicit `wasm` option, initialization loads `wasm/ccht_bg.wasm`
-relative to the generated module. A browser cannot launch native processes: its
+Version 0.2.0 requires an explicit `wasm` URL or bytes on first initialization.
+A browser cannot launch native processes: its
 application server or desktop host runs `ccht::native`. The package makes no
 network connection apart from loading its Wasm module. The host decides which
 backend is available and how users authenticate to the application.
 
+## JSR
+
+The JSR package exposes the same Rust/Wasm model:
+
+```ts
+import { createConversation } from 'jsr:@corbet-labs/ccht@0.2.0';
+
+const conversation = await createConversation('workspace/creator', {
+  wasm: new URL('https://jsr.io/@corbet-labs/ccht/0.2.0/wasm/ccht_bg.wasm'),
+});
+```
+
+In Deno, allow access with `--allow-net=jsr.io` for this Wasm download.
+Applications can also supply their own Wasm bytes or URL. JSR's corresponding
+source archive uses `dependencies.tar.xz` to fit its package size limit; the
+source files and runtime bytes are the same as the npm distribution.
+
+## Python
+
+Install from [PyPI](https://pypi.org/project/ccht/0.2.0/):
+
+```sh
+python -m pip install ccht==0.2.0
+```
+
+```python
+from ccht import Conversation
+
+conversation = Conversation('workspace/creator')
+# Deliver an authorized WireEvent from your application transport.
+conversation.apply_event(event)
+snapshot = conversation.snapshot()
+```
+
+The Python package wraps the published Rust conversation model through PyO3.
+It exposes event reduction and snapshots; native agent execution uses a Rust
+host with `ccht::native`. See [py/README.md](py/README.md) for the Python API,
+binary wheel requirements and source rebuild/replacement instructions.
+
 ## Event and persistence contract
 
 `WireEvent` version 1 contains `conversation_id`, `request_id`, a per-request
@@ -145,7 +194,7 @@ cargo build --locked --release --no-default-features --features web --target was
 cargo run --locked --release -p ccht-wasm-bundle -- target/wasm32-unknown-unknown/release/ccht.wasm web/wasm
 ```
 
-Published browser archives include the corresponding Rust source and generator
+Published npm browser archives include the corresponding Rust source and generator
 under `source/`, original notices, and the full locked dependency sources in
 `source/dependencies.tar.gz`. Cargo's vendor checksums are preserved inside that
 archive. To rebuild from the distributed package, extract it inside `source/`:

package/index.d.ts

@@ -35,7 +35,17 @@ export interface TurnState {
   stop_reason: string | null;
   error: { code: string; message: string } | null;
 }
-export interface ConversationSnapshot { conversation_id: string; turns: TurnState[] }
+export interface ConfigChoice { value: string; name: string; description?: string }
+export interface ConfigGroup { group: string; name: string; options: ConfigChoice[] }
+export type SessionConfigOption = {
+  id: string; name: string; description?: string; category?: string;
+} & ({ type: 'select'; currentValue: string; options: ConfigChoice[] | ConfigGroup[] }
+  | { type: 'boolean'; currentValue: boolean });
+export interface SessionConfiguration {
+  options: SessionConfigOption[];
+  modes: null | { currentModeId: string; availableModes: Array<{id: string; name: string; description?: string}> };
+}
+export interface ConversationSnapshot { conversation_id: string; turns: TurnState[]; configuration: SessionConfiguration }
 export interface Conversation {
   applyEvent(event: WireEvent | string): ConversationSnapshot;
   snapshot(): ConversationSnapshot;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corbet-labs/ccht",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Reusable conversations for your applications, powered by the shared Rust/Wasm model",
   "license": "LGPL-3.0-only",
   "type": "module",
@@ -32,5 +32,5 @@
     "access": "public"
   },
   "sideEffects": false,
-  "gitHead": "340b9c2d41c77c2c1448666ddad8cd28307517bd"
+  "gitHead": "387d2d172a285508efae68b24822a73b152b1633"
 }

package/source/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.0 — 2026-09-12
+
+- Expose live session configuration and validated model, select and boolean controls.
+- Preserve dependent configuration changes and agent notifications across Rust/Wasm snapshots.
+- Apply explicit controls when creating, loading or resuming native sessions.
+- Close the native connection after an uncertain configuration timeout.
+
+
+## Additional 0.1.0 distributions
+
+- Add JSR packaging with the original Rust/Wasm runtime and a losslessly
+  recompressed corresponding-source kit.
+- Add Python conversation-model bindings through PyO3, with a native wheel,
+  source distribution and independent source-replacement checks.
+- Record each additional distribution's producing source separately; the
+  original Rust/npm packages and core release tag remain unchanged.
+
 ## 0.1.0 — 2026-09-11
 
 - Rename the unpublished cllm package to ccht and license current work LGPL-3.0-only.

package/source/Cargo.lock

@@ -226,7 +226,7 @@ dependencies = [
 
 [[package]]
 name = "ccht"
-version = "0.1.0"
+version = "0.2.0"
 dependencies = [
  "agent-client-protocol",
  "agent-client-protocol-schema",

package/source/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ccht"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2024"
 rust-version = "1.88"
 license = "LGPL-3.0-only"

package/source/README.md

@@ -24,14 +24,14 @@ call paid model HTTP APIs or select an API-key fallback.
 
 ```toml
 [dependencies]
-ccht = "0.1"
+ccht = "0.2"
 tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 ```
 
 `native` is the default feature. For the portable model alone:
 
 ```toml
-ccht = { version = "0.1", default-features = false }
+ccht = { version = "0.2", default-features = false }
 ```
 
 ```rust
@@ -62,6 +62,16 @@ A session accepts one active prompt; another returns `Busy`. Different sessions
 have separate streams and permission identities. History load/resume and model
 selection require the agent's advertised capabilities; unsupported requests fail.
 
+`session.handle().configuration()` exposes the agent's ordered model, reasoning,
+mode and boolean controls. Call `set_model(id)` or `set_config_option(id, value)`
+to change them. The full response replaces the advertised configuration, including
+dependent options; configuration notifications update both the native handle and
+the portable conversation snapshot. Unknown values fail without a fallback.
+`SessionOptions::configuration` applies explicit settings when creating or restoring
+a session. Retain the agent session ID and its working directory in your product
+storage to resume completed conversations across process restarts. Never replay an
+uncertain delivery automatically.
+
 Permissions default to denial. Applications that opt into asking must render the
 request, check their authority and respond with one of the advertised choices.
 A permission callback is not a sandbox: agent-owned tools may have separate runtime
@@ -103,12 +113,51 @@ render(snapshot.turns);
 conversation.free();
 ```
 
-Without an explicit `wasm` option, initialization loads `wasm/ccht_bg.wasm`
-relative to the generated module. A browser cannot launch native processes: its
+Version 0.2.0 requires an explicit `wasm` URL or bytes on first initialization.
+A browser cannot launch native processes: its
 application server or desktop host runs `ccht::native`. The package makes no
 network connection apart from loading its Wasm module. The host decides which
 backend is available and how users authenticate to the application.
 
+## JSR
+
+The JSR package exposes the same Rust/Wasm model:
+
+```ts
+import { createConversation } from 'jsr:@corbet-labs/ccht@0.2.0';
+
+const conversation = await createConversation('workspace/creator', {
+  wasm: new URL('https://jsr.io/@corbet-labs/ccht/0.2.0/wasm/ccht_bg.wasm'),
+});
+```
+
+In Deno, allow access with `--allow-net=jsr.io` for this Wasm download.
+Applications can also supply their own Wasm bytes or URL. JSR's corresponding
+source archive uses `dependencies.tar.xz` to fit its package size limit; the
+source files and runtime bytes are the same as the npm distribution.
+
+## Python
+
+Install from [PyPI](https://pypi.org/project/ccht/0.2.0/):
+
+```sh
+python -m pip install ccht==0.2.0
+```
+
+```python
+from ccht import Conversation
+
+conversation = Conversation('workspace/creator')
+# Deliver an authorized WireEvent from your application transport.
+conversation.apply_event(event)
+snapshot = conversation.snapshot()
+```
+
+The Python package wraps the published Rust conversation model through PyO3.
+It exposes event reduction and snapshots; native agent execution uses a Rust
+host with `ccht::native`. See [py/README.md](py/README.md) for the Python API,
+binary wheel requirements and source rebuild/replacement instructions.
+
 ## Event and persistence contract
 
 `WireEvent` version 1 contains `conversation_id`, `request_id`, a per-request
@@ -145,7 +194,7 @@ cargo build --locked --release --no-default-features --features web --target was
 cargo run --locked --release -p ccht-wasm-bundle -- target/wasm32-unknown-unknown/release/ccht.wasm web/wasm
 ```
 
-Published browser archives include the corresponding Rust source and generator
+Published npm browser archives include the corresponding Rust source and generator
 under `source/`, original notices, and the full locked dependency sources in
 `source/dependencies.tar.gz`. Cargo's vendor checksums are preserved inside that
 archive. To rebuild from the distributed package, extract it inside `source/`:

package/source/src/configuration.rs

@@ -0,0 +1,89 @@
+//! Agent-owned session controls shared by native, Wasm and transport consumers.
+
+use serde::{Deserialize, Serialize};
+
+use crate::acp::{
+    SessionConfigKind, SessionConfigOption, SessionConfigOptionCategory, SessionConfigOptionValue,
+    SessionConfigSelectOptions, SessionModeState, SessionUpdate,
+};
+
+/// An agent's current advertised configuration; option order is significant.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SessionConfiguration {
+    /// Model, mode, reasoning and other controls supplied by the agent.
+    pub options: Vec<SessionConfigOption>,
+    /// Legacy modes for agents that have not adopted configuration options.
+    pub modes: Option<SessionModeState>,
+}
+
+impl SessionConfiguration {
+    /// The first model selector, following the agent's priority ordering.
+    pub fn model_option(&self) -> Option<&SessionConfigOption> {
+        self.options.iter().find(|option| {
+            option.category == Some(SessionConfigOptionCategory::Model)
+                || option.id.0.as_ref() == "model"
+        })
+    }
+
+    /// Whether an exact value is offered, including grouped selectors and booleans.
+    pub fn accepts(&self, id: &str, value: &SessionConfigOptionValue) -> bool {
+        let Some(option) = self
+            .options
+            .iter()
+            .find(|option| option.id.0.as_ref() == id)
+        else {
+            return false;
+        };
+        match (&option.kind, value) {
+            (SessionConfigKind::Boolean(_), SessionConfigOptionValue::Boolean { .. }) => true,
+            (SessionConfigKind::Select(select), SessionConfigOptionValue::ValueId { value }) => {
+                match &select.options {
+                    SessionConfigSelectOptions::Ungrouped(options) => {
+                        options.iter().any(|option| option.value == *value)
+                    }
+                    SessionConfigSelectOptions::Grouped(groups) => groups
+                        .iter()
+                        .any(|group| group.options.iter().any(|option| option.value == *value)),
+                    _ => false,
+                }
+            }
+            _ => false,
+        }
+    }
+
+    /// Apply an agent update. Configuration updates replace the complete option list.
+    pub fn apply(&mut self, update: &SessionUpdate) {
+        match update {
+            SessionUpdate::ConfigOptionUpdate(update) => {
+                self.options.clone_from(&update.config_options);
+            }
+            SessionUpdate::CurrentModeUpdate(update) => {
+                if let Some(modes) = &mut self.modes {
+                    modes.current_mode_id.clone_from(&update.current_mode_id);
+                }
+            }
+            _ => {}
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn grouped_selectors_and_boolean_controls_preserve_exact_types() {
+        let settings: SessionConfiguration = serde_json::from_value(serde_json::json!({
+            "options": [{"id":"model","name":"Model","category":"model","type":"select",
+                "currentValue":"one","options":[{"group":"provider","name":"Provider","options":[
+                    {"value":"one","name":"One"},{"value":"two","name":"Two"}]}]},
+                {"id":"thinking","name":"Thinking","type":"boolean","currentValue":false}],
+            "modes":null
+        }))
+        .unwrap();
+        assert!(settings.accepts("model", &"two".into()));
+        assert!(!settings.accepts("model", &true.into()));
+        assert!(settings.accepts("thinking", &true.into()));
+        assert!(!settings.accepts("thinking", &"true".into()));
+        assert!(!settings.accepts("missing", &true.into()));
+    }
+}

package/source/src/conversation.rs

@@ -274,6 +274,7 @@ impl TurnState {
 pub struct Conversation {
     conversation_id: String,
     turns: Vec<TurnState>,
+    configuration: crate::SessionConfiguration,
 }
 
 impl Conversation {
@@ -282,6 +283,7 @@ impl Conversation {
         Self {
             conversation_id: conversation_id.into(),
             turns: Vec::new(),
+            configuration: crate::SessionConfiguration::default(),
         }
     }
 
@@ -295,6 +297,11 @@ impl Conversation {
         &self.turns
     }
 
+    /// Latest session controls observed in the ordered event stream.
+    pub fn configuration(&self) -> &crate::SessionConfiguration {
+        &self.configuration
+    }
+
     /// Serialize the render state for a browser or another transport.
     pub fn snapshot_json(&self) -> Result<String, ConversationError> {
         serde_json::to_string(self).map_err(|_| ConversationError::Json)
@@ -349,6 +356,10 @@ impl Conversation {
         {
             return Err(ConversationError::Capacity);
         }
+        let mut configuration = self.configuration.clone();
+        if let Event::Update { update } = &wire.event {
+            configuration.apply(update);
+        }
         match wire.event {
             Event::Update { update } => turn.update(update)?,
             Event::Permission {
@@ -387,6 +398,7 @@ impl Conversation {
         {
             return Err(ConversationError::Capacity);
         }
+        self.configuration = configuration;
         match index {
             Some(i) => self.turns[i] = turn,
             None => self.turns.push(turn),

package/source/src/lib.rs

@@ -17,6 +17,9 @@
 /// The official platform-independent ACP version 1 schema.
 pub use agent_client_protocol_schema::v1 as acp;
 
+mod configuration;
+pub use configuration::*;
+
 mod conversation;
 pub use conversation::*;
 

package/source/src/native/client.rs

@@ -8,8 +8,7 @@ use tokio::time::timeout;
 
 use crate::acp::{
     AuthMethod, AuthenticateRequest, InitializeRequest, InitializeResponse, LoadSessionRequest,
-    McpServer, NewSessionRequest, ResumeSessionRequest, SessionConfigKind,
-    SessionConfigOptionCategory, SessionConfigSelectOptions, SetSessionConfigOptionRequest,
+    McpServer, NewSessionRequest, ResumeSessionRequest,
 };
 
 use super::{
@@ -129,7 +128,18 @@ impl NativeClient {
                 .builder()
                 .connect_with(agent, async move |connection| {
                     let info = connection
-                        .send_request(InitializeRequest::new(ProtocolVersion::V1))
+                        .send_request(
+                            InitializeRequest::new(ProtocolVersion::V1).client_capabilities(
+                                crate::acp::ClientCapabilities::new().session(
+                                    crate::acp::ClientSessionCapabilities::new().config_options(
+                                        crate::acp::SessionConfigOptionsCapabilities::new()
+                                            .boolean(
+                                                crate::acp::BooleanConfigOptionCapabilities::new(),
+                                            ),
+                                    ),
+                                ),
+                            ),
+                        )
                         .block_task()
                         .await?;
                     if info.protocol_version != ProtocolVersion::V1 {
@@ -293,47 +303,15 @@ impl NativeClient {
         session: ActiveSession<'static, Agent>,
         options: SessionOptions,
     ) -> Result<NativeSession> {
+        let session = NativeSession::start(self.inner.clone(), session)?;
+        let handle = session.handle();
         if let Some(model) = options.model {
-            let config = session
-                .config_options()
-                .unwrap_or_default()
-                .iter()
-                .find(|option| {
-                    option.category == Some(SessionConfigOptionCategory::Model)
-                        || option.id.0.as_ref() == "model"
-                })
-                .ok_or(NativeError::Unsupported("model selection"))?;
-            let SessionConfigKind::Select(select) = &config.kind else {
-                return Err(NativeError::Unsupported("model selection"));
-            };
-            let available = match &select.options {
-                SessionConfigSelectOptions::Ungrouped(options) => options
-                    .iter()
-                    .any(|option| option.value.0.as_ref() == model),
-                SessionConfigSelectOptions::Grouped(groups) => groups.iter().any(|group| {
-                    group
-                        .options
-                        .iter()
-                        .any(|option| option.value.0.as_ref() == model)
-                }),
-                _ => false,
-            };
-            if !available {
-                return Err(NativeError::Unsupported("the selected model"));
-            }
-            self.operation(
-                self.inner
-                    .connection
-                    .send_request(SetSessionConfigOptionRequest::new(
-                        session.session_id().clone(),
-                        config.id.clone(),
-                        model.as_str(),
-                    ))
-                    .block_task(),
-            )
-            .await?;
+            handle.set_model(&model).await?;
+        }
+        for (id, value) in options.configuration {
+            handle.set_config_option(&id, value).await?;
         }
-        NativeSession::start(self.inner.clone(), session)
+        Ok(session)
     }
 
     fn validate_session(&self, options: &SessionOptions) -> Result<()> {

package/source/src/native/fixture.py

@@ -8,6 +8,7 @@ import time
 
 mode = sys.argv[1]
 sessions = 0
+configurations = {}
 pending = {}
 permissions = {}
 permission_id = 100
@@ -51,11 +52,20 @@ for line in sys.stdin:
         session = params.get("sessionId", "fixture-" + str(sessions))
         if method == "session/load":
             update(session, "restored history")
-        response(request_id, {"sessionId": session, "configOptions": [{
+        configurations[session] = [{
             "id": "model", "name": "Model", "category": "model", "type": "select",
-            "currentValue": "test-model", "options": [{"value": "test-model", "name": "Test"}]}]})
+            "currentValue": "test-model", "options": [{"value": "test-model", "name": "Test"},
+                {"value": "second-model", "name": "Second"}]},
+            {"id": "thinking", "name": "Thinking", "type": "boolean", "currentValue": False}]
+        response(request_id, {"sessionId": session, "configOptions": configurations[session]})
     elif method == "session/set_config_option":
-        response(request_id, {"configOptions": []})
+        configuration = configurations[params["sessionId"]]
+        for option in configuration:
+            if option["id"] == params["configId"]:
+                option["currentValue"] = params["value"]
+        if params["configId"] == "model":
+            configuration[1]["currentValue"] = params["value"] == "second-model"
+        response(request_id, {"configOptions": configuration})
     elif method == "session/prompt":
         session = params["sessionId"]
         pending[session] = request_id

package/source/src/native/mod.rs

@@ -153,6 +153,8 @@ pub struct SessionOptions {
     pub cwd: PathBuf,
     /// Exact advertised model option value, or the agent's default when absent.
     pub model: Option<String>,
+    /// Agent-advertised configuration values, applied in order after model selection.
+    pub configuration: Vec<(String, crate::acp::SessionConfigOptionValue)>,
     /// Application-owned MCP server descriptors passed to the agent.
     pub mcp_servers: Vec<McpServer>,
 }
@@ -163,6 +165,7 @@ impl SessionOptions {
         Self {
             cwd: cwd.into(),
             model: None,
+            configuration: Vec::new(),
             mcp_servers: Vec::new(),
         }
     }

package/source/src/native/session.rs

@@ -13,7 +13,7 @@ use crate::acp::{
     RequestPermissionOutcome, RequestPermissionRequest, RequestPermissionResponse, SessionId,
     SessionNotification, StopReason,
 };
-use crate::{Event, Prompt, SessionEvent};
+use crate::{Event, Prompt, SessionConfiguration, SessionEvent};
 
 use super::client::{ClientLease, ClientState};
 use super::{NativeError, PermissionDecision, PermissionPolicy, Result, lock};
@@ -51,6 +51,8 @@ struct SessionState {
     failure: Mutex<Option<NativeError>>,
     events: Mutex<Option<mpsc::Sender<SessionEvent>>>,
     permissions: Mutex<BTreeMap<String, PendingPermission>>,
+    configuration: Mutex<SessionConfiguration>,
+    configuring: tokio::sync::Mutex<()>,
     task: Mutex<Option<JoinHandle<()>>>,
 }
 
@@ -107,6 +109,9 @@ impl SessionState {
     }
 
     fn emit(&self, event: Event) -> Result<()> {
+        if let Event::Update { update } = &event {
+            lock(&self.configuration).apply(update);
+        }
         let request_id = lock(&self.turn).current.clone();
         let result = lock(&self.events)
             .as_ref()
@@ -200,6 +205,11 @@ impl NativeSession {
             failure: Mutex::new(None),
             events: Mutex::new(Some(events_tx)),
             permissions: Mutex::new(BTreeMap::new()),
+            configuration: Mutex::new(SessionConfiguration {
+                options: session.config_options().unwrap_or_default().to_vec(),
+                modes: session.modes().cloned(),
+            }),
+            configuring: tokio::sync::Mutex::new(()),
             task: Mutex::new(None),
         });
         let worker_state = state.clone();
@@ -236,6 +246,58 @@ impl NativeSession {
 }
 
 impl SessionHandle {
+    /// Latest agent-advertised controls, including dependent changes and notifications.
+    pub fn configuration(&self) -> SessionConfiguration {
+        lock(&self.lease.state.configuration).clone()
+    }
+
+    /// Select an exact model advertised by this session, without any fallback.
+    pub async fn set_model(&self, model: &str) -> Result<SessionConfiguration> {
+        let id = self
+            .configuration()
+            .model_option()
+            .map(|option| option.id.to_string())
+            .ok_or(NativeError::Unsupported("model selection"))?;
+        self.set_config_option(&id, model.into()).await
+    }
+
+    /// Change an advertised select or boolean control and retain the full response.
+    /// Unknown controls and values fail before sending a request to the agent.
+    pub async fn set_config_option(
+        &self,
+        id: &str,
+        value: crate::acp::SessionConfigOptionValue,
+    ) -> Result<SessionConfiguration> {
+        let state = &self.lease.state;
+        let _serial = state.configuring.lock().await;
+        if state.is_closed() {
+            return Err(state.error());
+        }
+        if !self.configuration().accepts(id, &value) {
+            return Err(NativeError::Unsupported("the selected configuration value"));
+        }
+        let request =
+            crate::acp::SetSessionConfigOptionRequest::new(state.id.clone(), id.to_owned(), value);
+        let response = match timeout(
+            self.lease.client.options.operation_timeout,
+            state.connection.send_request(request).block_task(),
+        )
+        .await
+        {
+            Ok(result) => result?,
+            Err(_) => {
+                state.close(NativeError::Timeout, true);
+                return Err(NativeError::Timeout);
+            }
+        };
+        state.emit(Event::Update {
+            update: crate::acp::SessionUpdate::ConfigOptionUpdate(
+                crate::acp::ConfigOptionUpdate::new(response.config_options),
+            ),
+        })?;
+        Ok(self.configuration())
+    }
+
     /// The agent-owned session identifier, suitable for explicit load or resume.
     pub fn id(&self) -> &str {
         self.lease.state.id.0.as_ref()

package/source/src/native/tests.rs

@@ -425,3 +425,39 @@ async fn dropping_connect_during_initialization_really_terminates_its_children()
     assert_processes_stopped(&pids).await;
     let _ = std::fs::remove_file(path);
 }
+
+#[tokio::test]
+async fn advertised_controls_preserve_dependent_changes_and_reject_invalid_values() {
+    let (client, _session, handle, mut events) = session("normal", options()).await;
+    assert!(
+        handle
+            .configuration()
+            .accepts("model", &"test-model".into())
+    );
+    let changed = handle.set_model("second-model").await.unwrap();
+    assert!(matches!(&changed.options[1].kind,
+        crate::acp::SessionConfigKind::Boolean(value) if value.current_value));
+    let event = events.recv().await.unwrap();
+    assert!(event.request_id.is_none());
+    assert!(matches!(
+        event.event,
+        Event::Update {
+            update: SessionUpdate::ConfigOptionUpdate(_)
+        }
+    ));
+    assert!(
+        handle
+            .set_config_option("thinking", false.into())
+            .await
+            .is_ok()
+    );
+    assert!(matches!(
+        handle.set_model("not-offered").await,
+        Err(NativeError::Unsupported(_))
+    ));
+    assert!(matches!(
+        handle.set_config_option("thinking", "false".into()).await,
+        Err(NativeError::Unsupported(_))
+    ));
+    client.close().await.unwrap();
+}