fix(acp-nats): fix compilation errors across the workspace

- Close unclosed handle() function in prompt.rs (missing `result` + `}`)
- Remove dead code: delete unused helper functions from prompt.rs
- Mark test-only helpers with #[cfg(test)]; trim cfg(test) imports to only what's needed
- Centralize session_ready publish logic in agent/mod.rs; remove duplicates from load_session.rs and new_session.rs
- Add terminal_output_cap field and supports_terminal_output() getter to Bridge
- Fix metrics field name: errors_total → errors
- Fix futures_util import in bridge_integration.rs (use futures::StreamExt)
- Add prompt/prompt_wildcard/prompt_events aliases to subjects::agent for runner crate
- Fix futures_util import in runner.rs (use futures_util::StreamExt — crate dependency)
- Remove duplicate test_flush_policy_default in trogon-nats/messaging.rs
- Declare prompt_event module in lib.rs

Author: jramirezhdez02

rsworkspace/crates/acp-nats/src/agent/load_session.rs

@@ -1,20 +1,12 @@
 use super::Bridge;
-use crate::acp_prefix::AcpPrefix;
 use crate::error::AGENT_UNAVAILABLE;
-use crate::nats::{
-    self, ExtSessionReady, FlushClient, FlushPolicy, PublishClient, PublishOptions, RequestClient,
-    RetryPolicy, agent,
-};
+use crate::nats::{self, FlushClient, PublishClient, RequestClient, agent};
 use crate::session_id::AcpSessionId;
-use crate::telemetry::metrics::Metrics;
 use agent_client_protocol::{Error, ErrorCode, LoadSessionRequest, LoadSessionResponse, Result};
-use std::time::Duration;
 use tracing::{info, instrument, warn};
 use trogon_nats::NatsError;
 use trogon_std::time::GetElapsed;
 
-const SESSION_READY_DELAY: Duration = Duration::from_millis(100);
-
 fn map_load_session_error(e: NatsError) -> Error {
     match &e {
         NatsError::Timeout { subject } => {
@@ -102,38 +94,6 @@ pub async fn handle<N: RequestClient + PublishClient + FlushClient, C: GetElapse
     result
 }
 
-async fn publish_session_ready<N: PublishClient + FlushClient>(
-    nats: &N,
-    prefix: &AcpPrefix,
-    session_id: &AcpSessionId,
-    metrics: &Metrics,
-) {
-    tokio::time::sleep(SESSION_READY_DELAY).await;
-
-    let subject = agent::ext_session_ready(prefix.as_str(), session_id.as_str());
-    info!(session_id = %session_id, subject = %subject, "Publishing session.ready");
-
-    let message = ExtSessionReady::new(agent_client_protocol::SessionId::from(
-        session_id.to_string(),
-    ));
-
-    let options = PublishOptions::builder()
-        .publish_retry_policy(RetryPolicy::standard())
-        .flush_policy(FlushPolicy::standard())
-        .build();
-
-    if let Err(e) = nats::publish(nats, &subject, &message, options).await {
-        warn!(
-            error = %e,
-            session_id = %session_id,
-            "Failed to publish session.ready"
-        );
-        metrics.record_error("session_ready", "session_ready_publish_failed");
-    } else {
-        info!(session_id = %session_id, "Published session.ready");
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::{Bridge, map_load_session_error};

rsworkspace/crates/acp-nats/src/agent/mod.rs

@@ -29,7 +29,9 @@ use agent_client_protocol::{
     ExtRequest, ExtResponse, ForkSessionRequest, ForkSessionResponse, InitializeRequest,
     InitializeResponse, ListSessionsRequest, ListSessionsResponse, LoadSessionRequest,
     LoadSessionResponse, NewSessionRequest, NewSessionResponse, PromptRequest, PromptResponse,
-    Result, SessionId, SessionNotification, SetSessionModeRequest, SetSessionModeResponse,
+    Result, ResumeSessionRequest, ResumeSessionResponse, SessionId, SessionNotification,
+    SetSessionConfigOptionRequest, SetSessionConfigOptionResponse, SetSessionModeRequest,
+    SetSessionModeResponse, SetSessionModelRequest, SetSessionModelResponse,
 };
 use opentelemetry::metrics::Meter;
 use std::cell::RefCell;
@@ -54,6 +56,7 @@ pub struct Bridge<N, C: GetElapsed> {
     pub(crate) notification_sender: mpsc::Sender<SessionNotification>,
     pub(crate) pending_session_prompt_responses: PendingSessionPromptResponseWaiters<C::Instant>,
     pub(crate) background_tasks: RefCell<Vec<JoinHandle<()>>>,
+    pub(crate) terminal_output_cap: std::cell::Cell<bool>,
 }
 
 impl<N, C: GetElapsed> Bridge<N, C> {
@@ -72,9 +75,18 @@ impl<N, C: GetElapsed> Bridge<N, C> {
             notification_sender,
             pending_session_prompt_responses: PendingSessionPromptResponseWaiters::new(),
             background_tasks: RefCell::new(Vec::new()),
+            terminal_output_cap: std::cell::Cell::new(false),
         }
     }
 
+    pub fn set_terminal_output_cap(&self, value: bool) {
+        self.terminal_output_cap.set(value);
+    }
+
+    pub fn supports_terminal_output(&self) -> bool {
+        self.terminal_output_cap.get()
+    }
+
     pub(crate) fn nats(&self) -> &N {
         &self.nats
     }

rsworkspace/crates/acp-nats/src/agent/new_session.rs

@@ -1,32 +1,11 @@
 use super::Bridge;
 use crate::error::AGENT_UNAVAILABLE;
-use crate::nats::{
-    self, ExtSessionReady, FlushClient, FlushPolicy, PublishClient, PublishOptions, RequestClient,
-    RetryPolicy, agent,
-};
-use crate::telemetry::metrics::Metrics;
-use agent_client_protocol::{
-    Error, ErrorCode, NewSessionRequest, NewSessionResponse, Result, SessionId,
-};
-use std::time::Duration;
+use crate::nats::{self, FlushClient, PublishClient, RequestClient, agent};
+use agent_client_protocol::{Error, ErrorCode, NewSessionRequest, NewSessionResponse, Result};
 use tracing::{Span, info, instrument, warn};
 use trogon_nats::NatsError;
 use trogon_std::time::GetElapsed;
 
-/// Delay before publishing `session.ready` to NATS.
-///
-/// The `Agent` trait returns the response value *before* the transport layer
-/// serializes and writes it to the client. Without a delay the spawned task
-/// could publish `session.ready` to NATS before the client has received the
-/// `session/new` response, violating the ordering guarantee documented on
-/// [`ExtSessionReady`].
-///
-/// A post-send callback from the transport would be the ideal fix, but the
-/// external `agent_client_protocol` crate does not expose one. This constant
-/// delay provides a practical safety margin (serialization + write is typically
-/// sub-millisecond).
-const SESSION_READY_DELAY: Duration = Duration::from_millis(100);
-
 fn map_new_session_error(e: NatsError) -> Error {
     match &e {
         NatsError::Timeout { subject } => {
@@ -108,36 +87,6 @@ pub async fn handle<N: RequestClient + PublishClient + FlushClient, C: GetElapse
     result
 }
 
-async fn publish_session_ready<N: PublishClient + FlushClient>(
-    nats: &N,
-    prefix: &str,
-    session_id: &SessionId,
-    metrics: &Metrics,
-) {
-    tokio::time::sleep(SESSION_READY_DELAY).await;
-
-    let subject = agent::ext_session_ready(prefix, &session_id.to_string());
-    info!(session_id = %session_id, subject = %subject, "Publishing session.ready");
-
-    let message = ExtSessionReady::new(session_id.clone());
-
-    let options = PublishOptions::builder()
-        .publish_retry_policy(RetryPolicy::standard())
-        .flush_policy(FlushPolicy::standard())
-        .build();
-
-    if let Err(e) = nats::publish(nats, &subject, &message, options).await {
-        warn!(
-            error = %e,
-            session_id = %session_id,
-            "Failed to publish session.ready"
-        );
-        metrics.record_error("session_ready", "session_ready_publish_failed");
-    } else {
-        info!(session_id = %session_id, "Published session.ready");
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::{Bridge, map_new_session_error};