ACP Wrap up

crates/acp/src/agent_runtime.rs

@@ -74,18 +74,18 @@ pub struct AcpAgentRuntime {
 }
 
 impl AcpAgentRuntime {
+    #[must_use]
+    pub const fn capabilities() -> RuntimeCapabilities {
+        RuntimeCapabilities::session_runtime()
+    }
+
     #[must_use]
     pub fn new(manager: AcpSessionManager, config: AcpAgentRuntimeConfig) -> Self {
         let descriptor = RuntimeDescriptor {
             id: config.runtime_id.clone(),
             display_name: config.display_name.clone(),
             kind: RuntimeKind::Acp,
-            capabilities: RuntimeCapabilities {
-                model_selection: false,
-                session_resume: true,
-                steering: true,
-                tool_permissions: true,
-            },
+            capabilities: Self::capabilities(),
         };
         Self {
             manager,

crates/galaxy_agent_core/src/runtime.rs

@@ -21,6 +21,48 @@ pub struct RuntimeCapabilities {
     pub session_resume: bool,
     pub steering: bool,
     pub tool_permissions: bool,
+    /// Galaxy owns and persists the message history supplied to each turn.
+    pub host_managed_history: bool,
+    /// Tool proposals cross the runtime boundary for Galaxy to approve and execute.
+    pub host_tool_execution: bool,
+    /// A failed turn can be safely replayed from the same request payload.
+    pub request_retries: bool,
+    /// Galaxy can append corrective instructions and start a follow-up turn.
+    pub corrective_retries: bool,
+    /// Transcript events can be forwarded through Galaxy shared sessions.
+    pub shared_session_sync: bool,
+}
+
+impl RuntimeCapabilities {
+    #[must_use]
+    pub const fn provider() -> Self {
+        Self {
+            model_selection: true,
+            session_resume: false,
+            steering: false,
+            tool_permissions: false,
+            host_managed_history: true,
+            host_tool_execution: true,
+            request_retries: true,
+            corrective_retries: true,
+            shared_session_sync: true,
+        }
+    }
+
+    #[must_use]
+    pub const fn session_runtime() -> Self {
+        Self {
+            model_selection: false,
+            session_resume: true,
+            steering: true,
+            tool_permissions: true,
+            host_managed_history: false,
+            host_tool_execution: false,
+            request_retries: false,
+            corrective_retries: false,
+            shared_session_sync: false,
+        }
+    }
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]

crates/galaxy_agent_core/src/runtime_tests.rs

@@ -120,3 +120,22 @@ fn turn_control_delivers_cancel_and_steering_in_order() {
         assert_eq!(control.receive().await.unwrap(), TurnCommand::Cancel);
     });
 }
+
+#[test]
+fn runtime_shapes_publish_controller_policy_as_capabilities() {
+    let provider = RuntimeCapabilities::provider();
+    assert!(provider.host_managed_history);
+    assert!(provider.host_tool_execution);
+    assert!(provider.request_retries);
+    assert!(provider.corrective_retries);
+    assert!(provider.shared_session_sync);
+    assert!(!provider.steering);
+
+    let session = RuntimeCapabilities::session_runtime();
+    assert!(!session.host_managed_history);
+    assert!(!session.host_tool_execution);
+    assert!(!session.request_retries);
+    assert!(!session.corrective_retries);
+    assert!(!session.shared_session_sync);
+    assert!(session.steering);
+}

crates/galaxy_agent_rig/src/bedrock.rs

@@ -47,12 +47,7 @@ impl BedrockRuntime {
             id: format!("rig-bedrock:{resolved_model}"),
             display_name: format!("Rig / Bedrock / {resolved_model}"),
             kind: RuntimeKind::Provider,
-            capabilities: RuntimeCapabilities {
-                model_selection: true,
-                session_resume: false,
-                steering: false,
-                tool_permissions: false,
-            },
+            capabilities: RuntimeCapabilities::provider(),
         };
 
         Ok(Self {

crates/galaxy_agent_rig/src/openai_compatible.rs

@@ -31,12 +31,7 @@ impl OpenAICompatibleRuntime {
             id: format!("rig-openai-compatible:{}", config.model),
             display_name: format!("Rig / {}", config.model),
             kind: RuntimeKind::Provider,
-            capabilities: RuntimeCapabilities {
-                model_selection: true,
-                session_resume: false,
-                steering: false,
-                tool_permissions: false,
-            },
+            capabilities: RuntimeCapabilities::provider(),
         };
         Self { config, descriptor }
     }

crates/galaxyui_core/src/core/app.rs

@@ -4909,6 +4909,17 @@ impl GetSingletonModelHandle for AppContext {
 }
 
 impl AppContext {
+    /// Returns a singleton model when it has already been registered.
+    ///
+    /// This is useful for infrastructure models that can also be constructed
+    /// in isolation by tests before the full application singleton graph is
+    /// available.
+    pub fn try_get_singleton_model_as_ref<T: SingletonEntity>(&self) -> Option<&T> {
+        self.singleton_models
+            .get(&std::any::TypeId::of::<T>())?
+            .downcast_ref(self)
+    }
+
     pub(super) fn get_singleton_model_as_ref<T: SingletonEntity>(&self) -> &T {
         match self.singleton_models.get(&std::any::TypeId::of::<T>()) {
             Some(model_handle) => model_handle