act-cli 0.7.4__tar.gz → 0.7.6__tar.gz

{act_cli-0.7.4 → act_cli-0.7.6}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "act-build"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "act-types",
  "anyhow",
@@ -35,7 +35,7 @@ dependencies = [
 
 [[package]]
 name = "act-cli"
-version = "0.7.4"
+version = "0.7.6"
 dependencies = [
  "act-types",
  "anyhow",
@@ -1418,34 +1418,6 @@ dependencies = [
  "tracing",
 ]
 
-[[package]]
-name = "h3"
-version = "0.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10872b55cfb02a821b69dc7cf8dc6a71d6af25eb9a79662bec4a9d016056b3be"
-dependencies = [
- "bytes",
- "fastrand",
- "futures-util",
- "http",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "h3-quinn"
-version = "0.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b2e732c8d91a74731663ac8479ab505042fbf547b9a207213ab7fbcbfc4f8b4"
-dependencies = [
- "bytes",
- "futures",
- "h3",
- "quinn",
- "tokio",
- "tokio-util",
-]
-
 [[package]]
 name = "half"
 version = "2.7.1"
@@ -2510,7 +2482,6 @@ checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
 dependencies = [
  "bytes",
  "cfg_aliases",
- "futures-io",
  "pin-project-lite",
  "quinn-proto",
  "quinn-udp",
@@ -2760,8 +2731,6 @@ dependencies = [
  "futures-core",
  "futures-util",
  "h2",
- "h3",
- "h3-quinn",
  "http",
  "http-body",
  "http-body-util",

{act_cli-0.7.4 → act_cli-0.7.6}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["act-cli"]
 resolver = "3"
 
 [workspace.package]
-version = "0.7.4"
+version = "0.7.6"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/actcore/act-cli"

{act_cli-0.7.4 → act_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: act-cli
-Version: 0.7.4
+Version: 0.7.6
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

{act_cli-0.7.4 → act_cli-0.7.6}/act-cli/Cargo.toml

@@ -37,7 +37,7 @@ dirs = "6"
 futures-util = "0.3"
 indicatif = "0.18.4"
 regex = "1"
-reqwest = { version = "0.13.3", default-features = false, features = ["rustls", "stream", "http2", "http3"] }
+reqwest = { version = "0.13.3", default-features = false, features = ["rustls", "stream", "http2"] }
 oci-client = "0.17"
 sha2 = "0.11.0"
 tar = "0.4"

{act_cli-0.7.4 → act_cli-0.7.6}/act-cli/src/http.rs

@@ -24,6 +24,10 @@ pub struct AppState {
     pub info: act_types::ComponentInfo,
     pub component: runtime::ComponentHandle,
     pub metadata: Metadata,
+    /// When `Some`, a single default session was pre-opened (session-of-1,
+    /// ACT-SESSIONS §3): `/sessions*` routes are unregistered and this id is
+    /// forced into every call's `std:session-id` metadata.
+    pub default_session_id: Option<String>,
 }
 
 // ── Conversion helpers ──
@@ -84,6 +88,14 @@ fn internal_error_response(message: &str) -> axum::response::Response {
         .into_response()
 }
 
+/// Force `std:session-id` to the default when in session-of-1 mode, overriding
+/// any body-supplied value (ACT-SESSIONS §3 "session-of-1").
+fn apply_default_session(meta: &mut Metadata, default: &Option<String>) {
+    if let Some(id) = default {
+        meta.insert(META_SESSION_ID, serde_json::Value::String(id.clone()));
+    }
+}
+
 /// Format an SseEvent as an axum SSE Event.
 fn sse_event_to_axum(event: runtime::SseEvent) -> Option<Result<Event, std::convert::Infallible>> {
     match event {
@@ -151,6 +163,7 @@ async fn list_tools_inner(
     if let Some(value) = metadata {
         meta.extend(runtime::Metadata::from(value));
     }
+    apply_default_session(&mut meta, &state.default_session_id);
 
     let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
     let request = runtime::ComponentRequest::ListTools {
@@ -361,6 +374,7 @@ async fn tool_call_dispatcher(
     if let Some(value) = body.metadata {
         metadata.extend(Metadata::from(value));
     }
+    apply_default_session(&mut metadata, &state.default_session_id);
 
     let metadata_wit: Vec<(String, Vec<u8>)> = metadata.into();
 
@@ -522,16 +536,25 @@ async fn protocol_version_layer(request: Request, next: Next) -> axum::response:
 }
 
 pub fn create_router(state: Arc<AppState>) -> Router {
-    Router::new()
+    let mut router = Router::new()
         .route("/info", get(get_info))
         .route("/tools", axum::routing::any(tools_dispatcher))
-        .route("/tools/{name}", axum::routing::any(tool_call_dispatcher))
-        .route(
-            "/sessions/open-args-schema",
-            axum::routing::any(session_open_args_schema_dispatcher),
-        )
-        .route("/sessions", axum::routing::post(session_open))
-        .route("/sessions/{id}", axum::routing::delete(session_close))
+        .route("/tools/{name}", axum::routing::any(tool_call_dispatcher));
+
+    // Session-of-1 hides the session machinery (ACT-SESSIONS §3): when a
+    // default session is pre-opened, the component looks stateless and the
+    // lifecycle endpoints are absent (404).
+    if state.default_session_id.is_none() {
+        router = router
+            .route(
+                "/sessions/open-args-schema",
+                axum::routing::any(session_open_args_schema_dispatcher),
+            )
+            .route("/sessions", axum::routing::post(session_open))
+            .route("/sessions/{id}", axum::routing::delete(session_close));
+    }
+
+    router
         .layer(middleware::from_fn(protocol_version_layer))
         .with_state(state)
 }
@@ -567,4 +590,23 @@ mod tests {
     fn query_method_is_valid() {
         assert_eq!(query_method().as_str(), "QUERY");
     }
+
+    #[test]
+    fn apply_default_session_overrides_and_skips() {
+        // Some(id): inject, overriding any existing value.
+        let mut meta = Metadata::from(serde_json::json!({"std:session-id": "client"}));
+        apply_default_session(&mut meta, &Some("sid_default".to_string()));
+        assert_eq!(
+            meta.get_as::<String>(META_SESSION_ID).as_deref(),
+            Some("sid_default")
+        );
+
+        // None: leave metadata untouched.
+        let mut meta2 = Metadata::from(serde_json::json!({"std:session-id": "client"}));
+        apply_default_session(&mut meta2, &None);
+        assert_eq!(
+            meta2.get_as::<String>(META_SESSION_ID).as_deref(),
+            Some("client")
+        );
+    }
 }

{act_cli-0.7.4 → act_cli-0.7.6}/act-cli/src/main.rs

@@ -101,6 +101,15 @@ enum Command {
         #[arg(short, long)]
         listen: Option<String>,
 
+        /// Pre-open a single session at startup from this JSON object and
+        /// run as session-of-1: every call uses the pre-opened session, the
+        /// session machinery is hidden from clients (no virtual
+        /// open_session/close_session tools, no /sessions endpoints), and any
+        /// client-supplied std:session-id is ignored. Requires a component
+        /// that exports act:sessions/session-provider.
+        #[arg(long)]
+        session_args: Option<String>,
+
         #[command(flatten)]
         opts: CommonOpts,
     },
@@ -233,8 +242,9 @@ async fn main() -> Result<()> {
             mcp,
             http,
             listen,
+            session_args,
             opts,
-        } => cmd_run(component, mcp, http, listen, opts).await,
+        } => cmd_run(component, mcp, http, listen, session_args, opts).await,
         Command::Call {
             component,
             tool,
@@ -404,11 +414,34 @@ fn parse_listen_addr(s: &str) -> Result<SocketAddr> {
     anyhow::bail!("invalid listen address: {s} (expected [host]:port or port number)")
 }
 
+/// If `session_args` is set, open a single default session against the
+/// prepared component and return its id (session-of-1, ACT-SESSIONS §3). The
+/// session is closed automatically when the component actor shuts down
+/// (`runtime` closes every tracked session on deinit).
+async fn maybe_open_default_session(
+    pc: &PreparedComponent,
+    session_args: &Option<String>,
+) -> Result<Option<String>> {
+    match session_args {
+        Some(json) => {
+            if !pc.has_sessions {
+                anyhow::bail!(
+                    "--session-args was set, but the component does not export \
+                     act:sessions/session-provider"
+                );
+            }
+            Ok(Some(open_session_for_call(pc, json).await?))
+        }
+        None => Ok(None),
+    }
+}
+
 async fn cmd_run(
     component: ComponentRef,
     mcp: bool,
     http: bool,
     listen: Option<String>,
+    session_args: Option<String>,
     opts: CommonOpts,
 ) -> Result<()> {
     // Transport matrix:
@@ -422,7 +455,16 @@ async fn cmd_run(
             None => "[::1]:3000".parse().unwrap(),
         };
         let pc = prepare_component(&component, &opts).await?;
-        return rmcp_bridge::run_http(addr, pc.info, pc.handle, pc.metadata, pc.has_sessions).await;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
+        return rmcp_bridge::run_http(
+            addr,
+            pc.info,
+            pc.handle,
+            pc.metadata,
+            pc.has_sessions,
+            default_session_id,
+        )
+        .await;
     }
 
     if mcp {
@@ -430,7 +472,15 @@ async fn cmd_run(
             anyhow::bail!("--listen requires --http (MCP stdio has no listen address)");
         }
         let pc = prepare_component(&component, &opts).await?;
-        return rmcp_bridge::run_stdio(pc.info, pc.handle, pc.metadata, pc.has_sessions).await;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
+        return rmcp_bridge::run_stdio(
+            pc.info,
+            pc.handle,
+            pc.metadata,
+            pc.has_sessions,
+            default_session_id,
+        )
+        .await;
     }
 
     if http || listen.is_some() {
@@ -440,11 +490,13 @@ async fn cmd_run(
         };
 
         let pc = prepare_component(&component, &opts).await?;
+        let default_session_id = maybe_open_default_session(&pc, &session_args).await?;
 
         let state = Arc::new(http::AppState {
             info: pc.info,
             component: pc.handle,
             metadata: pc.metadata,
+            default_session_id,
         });
 
         tracing::info!(%addr, "ACT host listening");

{act_cli-0.7.4 → act_cli-0.7.6}/act-cli/src/rmcp_bridge.rs

@@ -31,6 +31,11 @@ pub struct ActRmcpBridge {
     /// `act:sessions/session-provider`. Controls synthesis of virtual
     /// `open_session`/`close_session` tools and routing of those calls.
     pub has_sessions: bool,
+    /// When `Some`, the host pre-opened a single default session
+    /// (session-of-1, ACT-SESSIONS §3): session machinery is hidden and
+    /// this id is forced into every call's `std:session-id` metadata,
+    /// overriding any client-supplied value.
+    pub default_session_id: Option<String>,
 }
 
 fn map_content_part(part: &runtime::exports::act::tools::tool_provider::ContentPart) -> Content {
@@ -194,12 +199,14 @@ pub async fn run_stdio(
     handle: runtime::ComponentHandle,
     metadata: runtime::Metadata,
     has_sessions: bool,
+    default_session_id: Option<String>,
 ) -> anyhow::Result<()> {
     let bridge = ActRmcpBridge {
         handle,
         info,
         metadata,
         has_sessions,
+        default_session_id,
     };
 
     let service = rmcp::serve_server(bridge, (tokio::io::stdin(), tokio::io::stdout()))
@@ -225,6 +232,7 @@ pub async fn run_http(
     handle: runtime::ComponentHandle,
     metadata: runtime::Metadata,
     has_sessions: bool,
+    default_session_id: Option<String>,
 ) -> anyhow::Result<()> {
     use rmcp::transport::streamable_http_server::{
         StreamableHttpServerConfig, StreamableHttpService, session::local::LocalSessionManager,
@@ -237,6 +245,7 @@ pub async fn run_http(
                 info: info.clone(),
                 metadata: metadata.clone(),
                 has_sessions,
+                default_session_id: default_session_id.clone(),
             })
         },
         Arc::new(LocalSessionManager::default()),
@@ -257,10 +266,24 @@ pub async fn run_http(
 // ── ServerHandler impl ──────────────────────────────────────────────────────
 
 impl ActRmcpBridge {
+    /// Whether session lifecycle ops are exposed to clients. False in
+    /// session-of-1 mode (a default session is pre-opened and hidden).
+    fn expose_sessions(&self) -> bool {
+        self.has_sessions && self.default_session_id.is_none()
+    }
+
+    /// Base metadata for non-call requests (list-tools, schema fetch),
+    /// with the default session-id injected when in session-of-1 mode.
+    fn base_metadata(&self) -> runtime::Metadata {
+        let mut meta = self.metadata.clone();
+        force_session_id(&mut meta, &self.default_session_id);
+        meta
+    }
+
     async fn list_tools_impl(&self) -> Result<rmcp::model::ListToolsResult, rmcp::ErrorData> {
         let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
         let req = runtime::ComponentRequest::ListTools {
-            metadata: self.metadata.clone(),
+            metadata: self.base_metadata(),
             reply: reply_tx,
         };
 
@@ -286,10 +309,12 @@ impl ActRmcpBridge {
         // Per ACT-MCP §3.2, adapters MUST inject the `_meta` argument
         // property into tools of components exporting session-provider
         // so agents can supply `std:session-id` (and other `std:*`
-        // keys) without relying on transport-level `_meta`.
-        let mut tools = convert_tool_definitions(&list.tools, self.has_sessions);
+        // keys) without relying on transport-level `_meta`. In
+        // session-of-1 mode the host forces the session-id, so the hint
+        // is suppressed — the agent must NOT be prompted to supply it.
+        let mut tools = convert_tool_definitions(&list.tools, self.expose_sessions());
 
-        if self.has_sessions {
+        if self.expose_sessions() {
             let open_schema = self.fetch_open_session_args_schema().await?;
             tools.push(virtual_open_session_tool(open_schema));
             tools.push(virtual_close_session_tool());
@@ -347,7 +372,7 @@ impl ActRmcpBridge {
         // before any argument-level `_meta` extraction. Virtual tools
         // are session-lifecycle ops, not session-bound capability calls,
         // so they do not participate in the argument metadata channel.
-        if self.has_sessions {
+        if self.expose_sessions() {
             match request.name.as_ref() {
                 VIRTUAL_OPEN_SESSION => {
                     let mut call_metadata = self.metadata.clone();
@@ -380,6 +405,9 @@ impl ActRmcpBridge {
             call_metadata.extend(act_types::types::Metadata::from(Value::Object(map)));
         }
         apply_transport_meta(&mut call_metadata, ctx_meta);
+        // Session-of-1: force the pre-opened default id over any
+        // client-supplied std:session-id so the façade stays stateless.
+        force_session_id(&mut call_metadata, &self.default_session_id);
 
         let cbor_args =
             act_types::cbor::json_to_cbor(&Value::Object(arguments_obj)).map_err(|_| {
@@ -571,6 +599,18 @@ fn session_op_meta(op: &'static str) -> rmcp::model::Meta {
     rmcp::model::Meta(map)
 }
 
+/// Force `std:session-id` to `default` when set, overriding any existing
+/// value. Used in session-of-1 mode so the hidden default session wins over
+/// client-supplied ids (ACT-SESSIONS §3 "session-of-1").
+fn force_session_id(meta: &mut act_types::types::Metadata, default: &Option<String>) {
+    if let Some(id) = default {
+        meta.insert(
+            act_types::constants::META_SESSION_ID,
+            Value::String(id.clone()),
+        );
+    }
+}
+
 /// Merge the MCP transport-level `_meta` (lifted by rmcp into
 /// `RequestContext::meta`) onto `call_metadata`. Per ACT-MCP §3.3 the
 /// transport channel overrides any same-keyed value already present
@@ -701,6 +741,71 @@ mod tests {
         tx
     }
 
+    fn bridge_with_default(default: Option<&str>) -> ActRmcpBridge {
+        ActRmcpBridge {
+            handle: fake_handle(),
+            info: fake_info(),
+            metadata: runtime::Metadata::default(),
+            has_sessions: true,
+            default_session_id: default.map(str::to_string),
+        }
+    }
+
+    #[test]
+    fn expose_sessions_false_when_default_set() {
+        assert!(
+            !bridge_with_default(Some("sid_0")).expose_sessions(),
+            "session-of-1 must hide session machinery"
+        );
+        assert!(
+            bridge_with_default(None).expose_sessions(),
+            "without a default session, machinery stays exposed"
+        );
+    }
+
+    #[test]
+    fn base_metadata_injects_default_session_id() {
+        let meta = bridge_with_default(Some("sid_0")).base_metadata();
+        assert_eq!(
+            meta.get_as::<String>(act_types::constants::META_SESSION_ID)
+                .as_deref(),
+            Some("sid_0"),
+            "base metadata must carry the default session-id"
+        );
+        let none = bridge_with_default(None).base_metadata();
+        assert!(
+            none.get_as::<String>(act_types::constants::META_SESSION_ID)
+                .is_none(),
+            "no default → no session-id seeded"
+        );
+    }
+
+    #[test]
+    fn force_session_id_overrides_client_value() {
+        let mut meta = act_types::types::Metadata::from(serde_json::json!({
+            "std:session-id": "client-supplied",
+        }));
+        force_session_id(&mut meta, &Some("sid_default".to_string()));
+        assert_eq!(
+            meta.get_as::<String>(act_types::constants::META_SESSION_ID)
+                .as_deref(),
+            Some("sid_default"),
+            "default must override client-supplied session-id"
+        );
+
+        let mut meta2 = act_types::types::Metadata::from(serde_json::json!({
+            "std:session-id": "client-supplied",
+        }));
+        force_session_id(&mut meta2, &None);
+        assert_eq!(
+            meta2
+                .get_as::<String>(act_types::constants::META_SESSION_ID)
+                .as_deref(),
+            Some("client-supplied"),
+            "no default → client value preserved"
+        );
+    }
+
     #[test]
     fn get_info_exposes_server_name_version_and_tools_capability() {
         let bridge = ActRmcpBridge {
@@ -708,6 +813,7 @@ mod tests {
             info: fake_info(),
             metadata: runtime::Metadata::default(),
             has_sessions: false,
+            default_session_id: None,
         };
         let info = rmcp::ServerHandler::get_info(&bridge);
         assert_eq!(info.server_info.name, "example");