chore: sync public mirror from internal

.repository-projection.json

@@ -3,11 +3,11 @@
   "projection": "deixic-code",
   "projectionSchemaVersion": 1,
   "sourceRepository": "dx-corp/mono",
-  "sourceSha": "a38427baafa6f23d02126d70a1df17f738b06ad2",
+  "sourceSha": "6f320c6bc2d80a310dfa0188e2fb7eb9d7f657b5",
   "destinationRepository": "dx-corp/code",
-  "priorProjectedBase": "dfc60c773d92e1d8313d1e91c4b37bc22a9b4324",
+  "priorProjectedBase": "99e3ef534d21f41e4b650fb3a8a251fe1b99273c",
   "definitionDigest": "cb9d429542ebb0a2de9b42a7aad60d9d8696a648ceba47c30f05c0b285ca0db7",
   "toolDigest": "f6d8b2a0b6f867d1db845a086635357eed196054b6a47f0695e49fdde616d6e6",
-  "contentDigest": "68bde457e4331061a93756704c2c5903b3a81f43446ec6b9faf372849aef47a4",
+  "contentDigest": "ff8ba42a56e83f0fa71b52cb6c3ee4e97f2e035ebc738d3d209204a76455962b",
   "publicationEligible": true
 }

packages/dex-host-rs/src/host_turn/tests.rs

@@ -45,8 +45,12 @@ fn tools(workspace: &Path, mode: NativeApprovalMode) -> HostTools {
         cwd: workspace.to_string_lossy().into_owned(),
         ..NativeAgentConfig::default()
     };
-    let host =
-        dex_loop_execution_host(&config, CredentialVault::new()).expect("compose native host");
+    let host = dex_loop_execution_host(
+        std::sync::Arc::new(maestro_local_host::agent::tool_host::BuiltInToolHost),
+        &config,
+        CredentialVault::new(),
+    )
+    .expect("compose native host");
     HostTools::new(host, mode)
 }
 

packages/dex-host-rs/src/host_turn/tests/compaction.rs

@@ -69,7 +69,12 @@ fn tools(workspace: &Path) -> HostTools {
         cwd: workspace.to_string_lossy().into_owned(),
         ..NativeAgentConfig::default()
     };
-    let host = dex_loop_execution_host(&config, CredentialVault::new()).unwrap();
+    let host = dex_loop_execution_host(
+        std::sync::Arc::new(maestro_local_host::agent::tool_host::BuiltInToolHost),
+        &config,
+        CredentialVault::new(),
+    )
+    .unwrap();
     HostTools::new(host, maestro_runtime::agent::ApprovalMode::Selective).with_client_tools([
         ToolSpec {
             name: ToolName::new("fixture.read"),

packages/dex-host-rs/tests/host_tools.rs

@@ -147,7 +147,12 @@ fn host_tools(workspace: &Path, mode: ApprovalMode) -> HostTools {
         cwd: workspace.to_string_lossy().into_owned(),
         ..NativeAgentConfig::default()
     };
-    let host = dex_loop_execution_host(&config, CredentialVault::new()).expect("compose host");
+    let host = dex_loop_execution_host(
+        std::sync::Arc::new(maestro_local_host::agent::tool_host::BuiltInToolHost),
+        &config,
+        CredentialVault::new(),
+    )
+    .expect("compose host");
     HostTools::new(host, mode)
 }
 

packages/hosted-runner-rs/src/hosted_runner.rs

@@ -51,6 +51,8 @@ use crate::headless::{
 };
 use crate::headless_server::{GovernedGrantVerificationContext, verify_governed_tool_grant};
 
+mod capabilities;
+use capabilities::*;
 mod config;
 mod env_aliases;
 mod handle;
@@ -1602,66 +1604,6 @@ impl HostedRunnerHeadlessMessageExecutor for TransportOnlyHostedRunnerMessageExe
     }
 }
 
-impl AgentSupervisorHostedRunnerMessageExecutor {
-    fn negotiated_server_capabilities(&self) -> Option<ServerCapabilities> {
-        let Ok(supervisor) = self.supervisor.lock() else {
-            return Some(native_server_capabilities_without_governed_grants());
-        };
-        supervisor.state().server_capabilities.clone().or_else(|| {
-            (supervisor.transport_generation() == 0)
-                .then(native_server_capabilities_without_governed_grants)
-        })
-    }
-
-    fn hosted_hello_ok_for_context(
-        &self,
-        context: &HostedRunnerHeadlessMessageContext,
-    ) -> FromAgentMessage {
-        FromAgentMessage::HelloOk {
-            protocol_version: HEADLESS_PROTOCOL_VERSION.to_string(),
-            controller_binding_version: None,
-            controller_binding_sha256: None,
-            connection_id: Some(context.connection_id.clone()),
-            client_protocol_version: context.client_protocol_version.clone(),
-            client_info: context.client_info.clone(),
-            capabilities: context.capabilities.clone(),
-            server_capabilities: self.negotiated_server_capabilities(),
-            opt_out_notifications: context.opt_out_notifications.clone(),
-            role: Some(context.role),
-            controller_connection_id: context.controller_connection_id.clone(),
-            lease_expires_at: Some(context.lease_expires_at.clone()),
-        }
-    }
-}
-
-fn server_capabilities_for_executor(
-    message_executor: &dyn HostedRunnerHeadlessMessageExecutor,
-) -> Option<ServerCapabilities> {
-    match message_executor.state() {
-        Ok(Some(agent_state)) => agent_state.server_capabilities,
-        Ok(None) | Err(_) => Some(native_server_capabilities_without_governed_grants()),
-    }
-}
-
-fn native_server_capabilities_without_governed_grants() -> ServerCapabilities {
-    server_capabilities_without_governed_grants(native_server_capabilities())
-}
-
-fn server_capabilities_without_governed_grants(
-    mut capabilities: ServerCapabilities,
-) -> ServerCapabilities {
-    capabilities.governed_tool_grant_algorithms.clear();
-    capabilities
-}
-
-fn governed_grant_algorithms_for_executor(
-    message_executor: &dyn HostedRunnerHeadlessMessageExecutor,
-) -> Vec<String> {
-    server_capabilities_for_executor(message_executor)
-        .map(|capabilities| capabilities.governed_tool_grant_algorithms)
-        .unwrap_or_default()
-}
-
 fn hosted_runner_error_from_async_transport(error: AsyncTransportError) -> HostedRunnerError {
     HostedRunnerError::runtime_not_ready(format!("agent supervisor is not ready: {error}"))
 }

packages/hosted-runner-rs/src/hosted_runner/capabilities.rs

@@ -0,0 +1,65 @@
+//! Capability negotiation for attached and transport-only hosted executors.
+
+use super::*;
+
+impl AgentSupervisorHostedRunnerMessageExecutor {
+    pub(super) fn negotiated_server_capabilities(&self) -> Option<ServerCapabilities> {
+        let Ok(supervisor) = self.supervisor.lock() else {
+            return Some(native_server_capabilities_without_governed_grants());
+        };
+        supervisor.state().server_capabilities.clone().or_else(|| {
+            (supervisor.transport_generation() == 0)
+                .then(native_server_capabilities_without_governed_grants)
+        })
+    }
+
+    pub(super) fn hosted_hello_ok_for_context(
+        &self,
+        context: &HostedRunnerHeadlessMessageContext,
+    ) -> FromAgentMessage {
+        FromAgentMessage::HelloOk {
+            protocol_version: HEADLESS_PROTOCOL_VERSION.to_string(),
+            controller_binding_version: None,
+            controller_binding_sha256: None,
+            connection_id: Some(context.connection_id.clone()),
+            client_protocol_version: context.client_protocol_version.clone(),
+            client_info: context.client_info.clone(),
+            capabilities: context.capabilities.clone(),
+            server_capabilities: self.negotiated_server_capabilities(),
+            opt_out_notifications: context.opt_out_notifications.clone(),
+            role: Some(context.role),
+            controller_connection_id: context.controller_connection_id.clone(),
+            lease_expires_at: Some(context.lease_expires_at.clone()),
+        }
+    }
+}
+
+pub(super) fn server_capabilities_for_executor(
+    message_executor: &dyn HostedRunnerHeadlessMessageExecutor,
+) -> Option<ServerCapabilities> {
+    match message_executor.state() {
+        Ok(Some(agent_state)) => agent_state.server_capabilities,
+        Ok(None) | Err(_) => Some(native_server_capabilities_without_governed_grants()),
+    }
+}
+
+pub(super) fn native_server_capabilities_without_governed_grants() -> ServerCapabilities {
+    server_capabilities_without_governed_grants(native_server_capabilities(
+        &maestro_local_host::agent::tool_host::BuiltInToolHost,
+    ))
+}
+
+pub(super) fn server_capabilities_without_governed_grants(
+    mut capabilities: ServerCapabilities,
+) -> ServerCapabilities {
+    capabilities.governed_tool_grant_algorithms.clear();
+    capabilities
+}
+
+pub(super) fn governed_grant_algorithms_for_executor(
+    message_executor: &dyn HostedRunnerHeadlessMessageExecutor,
+) -> Vec<String> {
+    server_capabilities_for_executor(message_executor)
+        .map(|capabilities| capabilities.governed_tool_grant_algorithms)
+        .unwrap_or_default()
+}