feat(acp): expose current model in SessionInfoUpdate and session/list (#2435) (#2453)

Each in-memory SessionInfo in session/list now carries meta.currentModel.
After session/set_config_option with configId=model, a SessionInfoUpdate
notification is sent with meta.currentModel in addition to the existing
ConfigOptionUpdate. Same notification is emitted after set_session_model.

Author: bug-ops

CHANGELOG.md

@@ -8,6 +8,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ### Added
 
+- feat(acp): expose current model in `session/list` and emit `SessionInfoUpdate` on model change — each in-memory `SessionInfo` now carries `meta.currentModel`; after `session/set_config_option` with `configId=model` a `SessionInfoUpdate` notification with `meta.currentModel` is sent in addition to the existing `ConfigOptionUpdate`; same notification is sent after `session/set_session_model` (closes #2435)
 - feat(memory): Memex tool output archive — before compaction, `ToolOutput` bodies in the compaction range are saved to `tool_overflow` with `archive_type = 'archive'`; archived UUIDs are appended as a postfix after LLM summarization so references survive compaction; controlled by `[memory.compression] archive_tool_outputs = false`; archives are excluded from the short-lived cleanup job via `archive_type` column (migration 054, closes #2432)
 - feat(memory): ACON per-category compression guidelines — `compression_failure_pairs` now stores a `category` column (`tool_output`, `assistant_reasoning`, `user_context`, `unknown`); the compression guidelines table gains a `category` column with `UNIQUE(version, category)` constraint; the `compression_guidelines` updater can now maintain per-category guideline documents when `categorized_guidelines = true`; failure category is classified from the compaction summary content before calling the LLM (migration 054, closes #2433)
 - feat(memory): RL-based admission control — new `AdmissionStrategy` enum with `heuristic` (default) and `rl` variants; `admission_training_data` table records all messages seen by A-MAC (admitted and rejected) to eliminate survivorship bias; `was_recalled` flag is set by `SemanticMemory::recall()` to provide positive training signal; lightweight logistic regression model in `admission_rl.rs` replaces the LLM `future_utility` factor when enough samples are available; weights persisted in `admission_rl_weights` table; controlled by `[memory.admission] admission_strategy`, `rl_min_samples = 500`, `rl_retrain_interval_secs = 3600` (migration 055, closes #2416)

crates/zeph-acp/src/agent/helpers.rs

@@ -75,6 +75,16 @@ pub(super) fn tool_kind_from_name(name: &str) -> acp::ToolKind {
     }
 }
 
+/// Build a `Meta` map carrying the current model name under the `"currentModel"` key.
+pub(super) fn model_meta(model: &str) -> serde_json::Map<String, serde_json::Value> {
+    let mut map = serde_json::Map::new();
+    map.insert(
+        "currentModel".to_owned(),
+        serde_json::Value::String(model.to_owned()),
+    );
+    map
+}
+
 pub(super) const DEFAULT_MODE_ID: &str = "code";
 
 /// MIME type used by Zed IDE to deliver LSP diagnostics as embedded resource blocks.

crates/zeph-acp/src/agent/mod.rs

@@ -1129,8 +1129,10 @@ impl acp::Agent for ZephAcpAgent {
                     {
                         return None;
                     }
+                    let meta = model_meta(&entry.current_model.borrow());
                     let mut info = acp::SessionInfo::new(session_id.clone(), working_dir)
-                        .updated_at(entry.created_at.to_rfc3339());
+                        .updated_at(entry.created_at.to_rfc3339())
+                        .meta(meta);
                     if let Some(ref t) = *entry.title.borrow() {
                         info = info.title(t.clone());
                     }
@@ -1403,11 +1405,24 @@ impl acp::Agent for ZephAcpAgent {
             // deadlocks in callers that do not drain notifications.
             let update =
                 acp::SessionUpdate::ConfigOptionUpdate(acp::ConfigOptionUpdate::new(vec![option]));
-            let notification = acp::SessionNotification::new(args.session_id, update);
+            let notification = acp::SessionNotification::new(args.session_id.clone(), update);
             let (tx, _rx) = oneshot::channel();
             if self.notify_tx.send((notification, tx)).is_err() {
                 tracing::warn!("failed to send ConfigOptionUpdate notification: channel closed");
             }
+
+            // When the model config changes, also emit a SessionInfoUpdate so IDE clients
+            // that track session metadata learn about the new model immediately.
+            if config_id.as_ref() == "model" {
+                let info_update = acp::SessionUpdate::SessionInfoUpdate(
+                    acp::SessionInfoUpdate::new().meta(model_meta(&current_model)),
+                );
+                let info_notification = acp::SessionNotification::new(args.session_id, info_update);
+                let (tx2, _rx2) = oneshot::channel();
+                if self.notify_tx.send((info_notification, tx2)).is_err() {
+                    tracing::warn!("failed to send SessionInfoUpdate notification: channel closed");
+                }
+            }
         }
 
         Ok(acp::SetSessionConfigOptionResponse::new(config_options))
@@ -1487,6 +1502,16 @@ impl acp::Agent for ZephAcpAgent {
             "ACP session model switched via set_session_model"
         );
 
+        // Notify IDE clients about the new model via SessionInfoUpdate.
+        let info_update = acp::SessionUpdate::SessionInfoUpdate(
+            acp::SessionInfoUpdate::new().meta(model_meta(model_id)),
+        );
+        let notification = acp::SessionNotification::new(args.session_id, info_update);
+        let (tx, _rx) = oneshot::channel();
+        if self.notify_tx.send((notification, tx)).is_err() {
+            tracing::warn!("failed to send SessionInfoUpdate notification: channel closed");
+        }
+
         Ok(acp::SetSessionModelResponse::new())
     }
 }
@@ -2208,7 +2233,7 @@ impl ZephAcpAgent {
 pub(super) mod helpers;
 use helpers::{
     DEFAULT_MODE_ID, DIAGNOSTICS_MIME_TYPE, build_available_commands, build_config_options,
-    build_mode_state, format_diagnostics_block, loopback_event_to_updates, mime_to_ext,
+    build_mode_state, format_diagnostics_block, loopback_event_to_updates, mime_to_ext, model_meta,
     session_update_to_event, xml_escape,
 };
 

crates/zeph-acp/src/agent/tests.rs

@@ -3804,6 +3804,119 @@ async fn close_session_unknown_id_is_ok() {
         .await;
 }
 
+#[tokio::test]
+async fn list_sessions_includes_model_meta() {
+    let local = tokio::task::LocalSet::new();
+    local
+        .run_until(async {
+            let (tx, _rx) = mpsc::unbounded_channel();
+            let conn_slot = std::rc::Rc::new(std::cell::RefCell::new(None));
+            let models = shared_models(vec!["ollama:llama3".to_owned()]);
+            let factory: ProviderFactory = Arc::new(|_key| None);
+            let agent = ZephAcpAgent::new(make_spawner(), tx, conn_slot, 4, 1800, None)
+                .with_provider_factory(factory, Arc::clone(&models));
+            let resp = agent
+                .new_session(acp::NewSessionRequest::new(std::path::PathBuf::from(".")))
+                .await
+                .unwrap();
+            let sid = resp.session_id.clone();
+
+            let list_resp = agent
+                .list_sessions(acp::ListSessionsRequest::new())
+                .await
+                .unwrap();
+
+            let info = list_resp
+                .sessions
+                .iter()
+                .find(|s| s.session_id == sid)
+                .expect("session must appear in list");
+
+            let meta = info.meta.as_ref().expect("meta must be present");
+            assert!(
+                meta.contains_key("currentModel"),
+                "meta must contain 'currentModel'"
+            );
+            assert_eq!(
+                meta["currentModel"],
+                serde_json::Value::String("ollama:llama3".to_owned())
+            );
+        })
+        .await;
+}
+
+#[tokio::test]
+async fn set_config_option_model_emits_session_info_update() {
+    let local = tokio::task::LocalSet::new();
+    local
+        .run_until(async {
+            let (tx, mut notify_rx) = mpsc::unbounded_channel();
+            let conn_slot = std::rc::Rc::new(std::cell::RefCell::new(None));
+            let models = shared_models(vec!["ollama:llama3".to_owned()]);
+            let factory: ProviderFactory = Arc::new(|key: &str| {
+                if key == "ollama:llama3" {
+                    Some(zeph_llm::any::AnyProvider::Ollama(
+                        zeph_llm::ollama::OllamaProvider::new(
+                            "http://localhost:11434",
+                            "llama3".into(),
+                            "nomic-embed-text".into(),
+                        ),
+                    ))
+                } else {
+                    None
+                }
+            });
+            let agent = ZephAcpAgent::new(make_spawner(), tx, conn_slot, 4, 1800, None)
+                .with_provider_factory(factory, Arc::clone(&models));
+            let resp = agent
+                .new_session(acp::NewSessionRequest::new(std::path::PathBuf::from(".")))
+                .await
+                .unwrap();
+            let sid = resp.session_id.clone();
+
+            // Drain any notifications from new_session.
+            while notify_rx.try_recv().is_ok() {}
+
+            agent
+                .set_session_config_option(acp::SetSessionConfigOptionRequest::new(
+                    sid.clone(),
+                    "model",
+                    "ollama:llama3",
+                ))
+                .await
+                .unwrap();
+
+            // Collect all notifications sent.
+            let mut updates = vec![];
+            while let Ok((notif, _ack)) = notify_rx.try_recv() {
+                updates.push(notif.update);
+            }
+
+            let has_config_update = updates
+                .iter()
+                .any(|u| matches!(u, acp::SessionUpdate::ConfigOptionUpdate(_)));
+            assert!(has_config_update, "ConfigOptionUpdate must be sent");
+
+            let session_info_update = updates.iter().find_map(|u| {
+                if let acp::SessionUpdate::SessionInfoUpdate(siu) = u {
+                    Some(siu)
+                } else {
+                    None
+                }
+            });
+            let siu = session_info_update.expect("SessionInfoUpdate must be sent on model change");
+            let meta = siu
+                .meta
+                .as_ref()
+                .expect("SessionInfoUpdate must carry meta");
+            assert_eq!(
+                meta["currentModel"],
+                serde_json::Value::String("ollama:llama3".to_owned())
+            );
+        })
+        .await;
+}
+
 #[cfg(feature = "unstable-session-close")]
 #[tokio::test]
 async fn close_session_signals_cancel() {