act-cli 0.6.0__tar.gz → 0.7.0__tar.gz

{act_cli-0.6.0 → act_cli-0.7.0}/Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "act-build"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "act-types",
  "anyhow",
@@ -25,7 +25,7 @@ dependencies = [
 
 [[package]]
 name = "act-cli"
-version = "0.6.0"
+version = "0.7.0"
 dependencies = [
  "act-types",
  "anyhow",
@@ -70,9 +70,9 @@ dependencies = [
 
 [[package]]
 name = "act-types"
-version = "0.5.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8061ce793866b6430317d2f06f9be9a0db3d08127ad398f133bbd0537824e5ca"
+checksum = "c814130fd708c159f2b8ae45f24e9a7de770b4980f8c82f6a6edce3fc0bdcbbd"
 dependencies = [
  "base64",
  "ciborium",

{act_cli-0.6.0 → act_cli-0.7.0}/Cargo.toml

@@ -3,7 +3,7 @@ members = ["act-cli"]
 resolver = "3"
 
 [workspace.package]
-version = "0.6.0"
+version = "0.7.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/actcore/act-cli"
@@ -11,7 +11,7 @@ homepage = "https://actcore.dev"
 readme = "README.md"
 
 [workspace.dependencies]
-act-types = "0.5"
+act-types = "0.7"
 wasmparser = "0.247.0"
 
 [profile.release]

{act_cli-0.6.0 → act_cli-0.7.0}/PKG-INFO

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

{act_cli-0.6.0 → act_cli-0.7.0}/act-cli/src/http.rs

@@ -377,6 +377,137 @@ fn query_method() -> &'static Method {
     &QUERY
 }
 
+// ── Session helpers ────────────────────────────────────────────────────────
+//
+// Wire types live in `act_types::http` (OpenSessionRequest, OpenSessionResponse).
+// Per ACT-SESSIONS.md §6.2.
+
+/// Convert `Metadata` (Vec<(String, CborBytes)>) to a JSON object, dropping
+/// entries whose CBOR can't be decoded.
+fn metadata_pairs_to_json(
+    pairs: &[(String, Vec<u8>)],
+) -> serde_json::Map<String, serde_json::Value> {
+    pairs
+        .iter()
+        .filter_map(|(k, v)| Some((k.clone(), cbor::cbor_to_json(v).ok()?)))
+        .collect()
+}
+
+// ── Session handlers ───────────────────────────────────────────────────────
+
+async fn session_open_args_schema_dispatcher(
+    state: State<Arc<AppState>>,
+    request: Request,
+) -> axum::response::Response {
+    if request.method() != Method::POST && request.method() != query_method() {
+        return StatusCode::METHOD_NOT_ALLOWED.into_response();
+    }
+    let metadata_value = match parse_metadata_body(request).await {
+        Ok(m) => m,
+        Err(status) => return status.into_response(),
+    };
+
+    let mut meta = state.metadata.clone();
+    if let Some(value) = metadata_value {
+        meta.extend(Metadata::from(value));
+    }
+
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    let request = runtime::ComponentRequest::GetOpenSessionArgsSchema {
+        metadata: meta.into(),
+        reply: reply_tx,
+    };
+
+    if state.component.send(request).await.is_err() {
+        return internal_error_response("component actor unavailable");
+    }
+
+    match reply_rx.await {
+        Ok(Ok(schema)) => match serde_json::from_str::<serde_json::Value>(&schema) {
+            Ok(v) => Json(v).into_response(),
+            Err(_) => internal_error_response("component returned non-JSON schema"),
+        },
+        Ok(Err(e)) => component_error_response(e),
+        Err(_) => internal_error_response("component actor dropped reply"),
+    }
+}
+
+async fn session_open(
+    State(state): State<Arc<AppState>>,
+    Json(body): Json<act_http::OpenSessionRequest>,
+) -> axum::response::Response {
+    let serde_json::Value::Object(args_obj) = body.arguments else {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(act_http::ErrorResponse {
+                error: act_http::ToolError {
+                    kind: ERR_INVALID_ARGS.to_string(),
+                    message: "arguments must be a JSON object".to_string(),
+                    metadata: None,
+                },
+            }),
+        )
+            .into_response();
+    };
+
+    let mut wit_args: Vec<(String, Vec<u8>)> = Vec::with_capacity(args_obj.len());
+    for (key, value) in args_obj {
+        match cbor::json_to_cbor(&value) {
+            Ok(bytes) => wit_args.push((key, bytes)),
+            Err(_) => return StatusCode::BAD_REQUEST.into_response(),
+        }
+    }
+
+    let mut meta = state.metadata.clone();
+    if let Some(value) = body.metadata {
+        meta.extend(Metadata::from(value));
+    }
+
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    let request = runtime::ComponentRequest::OpenSession {
+        args: wit_args,
+        metadata: meta.into(),
+        reply: reply_tx,
+    };
+
+    if state.component.send(request).await.is_err() {
+        return internal_error_response("component actor unavailable");
+    }
+
+    match reply_rx.await {
+        Ok(Ok(session)) => {
+            let resp = act_http::OpenSessionResponse {
+                id: session.id,
+                metadata: metadata_pairs_to_json(&session.metadata),
+            };
+            (StatusCode::CREATED, Json(resp)).into_response()
+        }
+        Ok(Err(e)) => component_error_response(e),
+        Err(_) => internal_error_response("component actor dropped reply"),
+    }
+}
+
+async fn session_close(
+    State(state): State<Arc<AppState>>,
+    Path(session_id): Path<String>,
+) -> axum::response::Response {
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    let request = runtime::ComponentRequest::CloseSession {
+        session_id,
+        reply: reply_tx,
+    };
+
+    if state.component.send(request).await.is_err() {
+        return internal_error_response("component actor unavailable");
+    }
+
+    match reply_rx.await {
+        Ok(Ok(())) => StatusCode::NO_CONTENT.into_response(),
+        Ok(Err(e)) => component_error_response(e),
+        Err(_) => internal_error_response("component actor dropped reply"),
+    }
+}
+
 // ── Protocol version middleware ──
 
 async fn protocol_version_layer(request: Request, next: Next) -> axum::response::Response {
@@ -428,6 +559,12 @@ pub fn create_router(state: Arc<AppState>) -> Router {
         .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))
         .layer(middleware::from_fn(protocol_version_layer))
         .with_state(state)
 }

{act_cli-0.6.0 → act_cli-0.7.0}/act-cli/src/main.rs

@@ -146,6 +146,35 @@ enum Command {
         #[arg(short = 'O', conflicts_with = "output")]
         output_from_ref: bool,
     },
+    /// Manage component sessions (`act:sessions/session-provider`).
+    #[command(subcommand)]
+    Session(SessionCommand),
+}
+
+#[derive(clap::Subcommand)]
+enum SessionCommand {
+    /// Print the JSON Schema for `open-session` args.
+    OpenArgsSchema {
+        component: ComponentRef,
+        #[command(flatten)]
+        opts: CommonOpts,
+    },
+    /// Open a new session, print the session record (id + metadata) as JSON.
+    Open {
+        component: ComponentRef,
+        /// JSON object with session-args.
+        #[arg(long, default_value = "{}")]
+        args: String,
+        #[command(flatten)]
+        opts: CommonOpts,
+    },
+    /// Close a session by id.
+    Close {
+        component: ComponentRef,
+        session_id: String,
+        #[command(flatten)]
+        opts: CommonOpts,
+    },
 }
 
 #[tokio::main]
@@ -168,6 +197,11 @@ async fn main() -> Result<()> {
                 opts.config.as_deref()
             }
             Command::Skill { .. } | Command::Pull { .. } => None,
+            Command::Session(sub) => match sub {
+                SessionCommand::OpenArgsSchema { opts, .. }
+                | SessionCommand::Open { opts, .. }
+                | SessionCommand::Close { opts, .. } => opts.config.as_deref(),
+            },
         };
         let log_level = config::load_config(config_path)
             .ok()
@@ -210,6 +244,21 @@ async fn main() -> Result<()> {
             output,
             output_from_ref,
         } => cmd_pull(reference, output, output_from_ref).await,
+        Command::Session(sub) => match sub {
+            SessionCommand::OpenArgsSchema { component, opts } => {
+                cmd_session_open_args_schema(component, opts).await
+            }
+            SessionCommand::Open {
+                component,
+                args,
+                opts,
+            } => cmd_session_open(component, args, opts).await,
+            SessionCommand::Close {
+                component,
+                session_id,
+                opts,
+            } => cmd_session_close(component, session_id, opts).await,
+        },
     }
 }
 
@@ -278,6 +327,8 @@ struct PreparedComponent {
     info: runtime::ComponentInfo,
     handle: runtime::ComponentHandle,
     metadata: runtime::Metadata,
+    /// Whether the component exports `act:sessions/session-provider`.
+    has_sessions: bool,
 }
 
 /// Resolve, load, and instantiate a component. Returns a running actor handle.
@@ -314,10 +365,11 @@ async fn prepare_component(
     let engine = runtime::create_engine()?;
     let wasm = runtime::load_component(&engine, &component_path)?;
     let linker = runtime::create_linker(&engine)?;
-    let (instance, store) =
+    let (instance, session_provider, store) =
         runtime::instantiate_component(&engine, &wasm, &linker, &preopens, &http, &fs, &info)
             .await?;
-    let handle = runtime::spawn_component_actor(instance, store);
+    let has_sessions = session_provider.is_some();
+    let handle = runtime::spawn_component_actor(instance, session_provider, store);
 
     tracing::debug!(name = %info.std.name, version = %info.std.version, "Component ready");
 
@@ -325,6 +377,7 @@ async fn prepare_component(
         info,
         handle,
         metadata,
+        has_sessions,
     })
 }
 
@@ -356,7 +409,7 @@ async fn cmd_run(
 
     if mcp {
         let pc = prepare_component(&component, &opts).await?;
-        return rmcp_bridge::run_stdio(pc.info, pc.handle, pc.metadata).await;
+        return rmcp_bridge::run_stdio(pc.info, pc.handle, pc.metadata, pc.has_sessions).await;
     }
 
     if http || listen.is_some() {
@@ -458,6 +511,110 @@ async fn cmd_call(
     }
 }
 
+// ── Session subcommands ────────────────────────────────────────────────────
+
+async fn cmd_session_open_args_schema(component: ComponentRef, opts: CommonOpts) -> Result<()> {
+    let pc = prepare_component(&component, &opts).await?;
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    pc.handle
+        .send(runtime::ComponentRequest::GetOpenSessionArgsSchema {
+            metadata: pc.metadata.clone().into(),
+            reply: reply_tx,
+        })
+        .await
+        .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
+    match reply_rx.await? {
+        Ok(schema) => {
+            // Pretty-print if it's valid JSON; otherwise print as-is.
+            match serde_json::from_str::<serde_json::Value>(&schema) {
+                Ok(v) => println!("{}", serde_json::to_string_pretty(&v)?),
+                Err(_) => println!("{schema}"),
+            }
+            Ok(())
+        }
+        Err(runtime::ComponentError::Tool(te)) => {
+            let ls = act_types::types::LocalizedString::from(&te.message);
+            anyhow::bail!("{}: {}", te.kind, ls.any_text());
+        }
+        Err(runtime::ComponentError::Internal(e)) => Err(e),
+    }
+}
+
+async fn cmd_session_open(component: ComponentRef, args: String, opts: CommonOpts) -> Result<()> {
+    let pc = prepare_component(&component, &opts).await?;
+
+    // Args are a JSON object; convert to metadata-shaped (key, cbor) pairs.
+    let args_value: serde_json::Value =
+        serde_json::from_str(&args).context("invalid --args JSON")?;
+    let serde_json::Value::Object(args_obj) = args_value else {
+        anyhow::bail!("--args must be a JSON object");
+    };
+    let mut wit_args: Vec<(String, Vec<u8>)> = Vec::with_capacity(args_obj.len());
+    for (key, value) in args_obj {
+        let cbor = act_types::cbor::json_to_cbor(&value).context("encoding arg as CBOR")?;
+        wit_args.push((key, cbor));
+    }
+
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    pc.handle
+        .send(runtime::ComponentRequest::OpenSession {
+            args: wit_args,
+            metadata: pc.metadata.clone().into(),
+            reply: reply_tx,
+        })
+        .await
+        .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
+
+    match reply_rx.await? {
+        Ok(session) => {
+            // Re-emit metadata as JSON object for human consumption.
+            let metadata_json: serde_json::Map<String, serde_json::Value> = session
+                .metadata
+                .iter()
+                .filter_map(|(k, v)| {
+                    let val = act_types::cbor::cbor_to_json(v).ok()?;
+                    Some((k.clone(), val))
+                })
+                .collect();
+            let out = serde_json::json!({
+                "id": session.id,
+                "metadata": metadata_json,
+            });
+            println!("{}", serde_json::to_string_pretty(&out)?);
+            Ok(())
+        }
+        Err(runtime::ComponentError::Tool(te)) => {
+            let ls = act_types::types::LocalizedString::from(&te.message);
+            anyhow::bail!("{}: {}", te.kind, ls.any_text());
+        }
+        Err(runtime::ComponentError::Internal(e)) => Err(e),
+    }
+}
+
+async fn cmd_session_close(
+    component: ComponentRef,
+    session_id: String,
+    opts: CommonOpts,
+) -> Result<()> {
+    let pc = prepare_component(&component, &opts).await?;
+    let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+    pc.handle
+        .send(runtime::ComponentRequest::CloseSession {
+            session_id,
+            reply: reply_tx,
+        })
+        .await
+        .map_err(|_| anyhow::anyhow!("component actor unavailable"))?;
+    match reply_rx.await? {
+        Ok(()) => Ok(()),
+        Err(runtime::ComponentError::Tool(te)) => {
+            let ls = act_types::types::LocalizedString::from(&te.message);
+            anyhow::bail!("{}: {}", te.kind, ls.any_text());
+        }
+        Err(runtime::ComponentError::Internal(e)) => Err(e),
+    }
+}
+
 async fn cmd_info(
     component: ComponentRef,
     show_tools: bool,

{act_cli-0.6.0 → act_cli-0.7.0}/act-cli/src/rmcp_bridge.rs

@@ -1,16 +1,27 @@
 use crate::runtime;
 use act_types::cbor;
-use act_types::constants::{ERR_CAPABILITY_DENIED, ERR_INVALID_ARGS, ERR_NOT_FOUND};
+use act_types::constants::{
+    ERR_CAPABILITY_DENIED, ERR_INVALID_ARGS, ERR_NOT_FOUND, META_SESSION_OP,
+};
 use rmcp::ErrorData;
 use rmcp::model::{Content, ErrorCode, Tool};
 use serde_json::Value;
 use std::borrow::Cow;
 use std::sync::Arc;
 
+/// Synthetic MCP tool name that maps to `session-provider.open-session`.
+/// Per ACT-SESSIONS §6.1 these names are reserved.
+const VIRTUAL_OPEN_SESSION: &str = "open_session";
+const VIRTUAL_CLOSE_SESSION: &str = "close_session";
+
 pub struct ActRmcpBridge {
     pub handle: runtime::ComponentHandle,
     pub info: runtime::ComponentInfo,
     pub metadata: runtime::Metadata,
+    /// Whether the underlying component exports
+    /// `act:sessions/session-provider`. Controls synthesis of virtual
+    /// `open_session`/`close_session` tools and routing of those calls.
+    pub has_sessions: bool,
 }
 
 fn map_content_part(part: &runtime::exports::act::tools::tool_provider::ContentPart) -> Content {
@@ -146,11 +157,13 @@ pub async fn run_stdio(
     info: runtime::ComponentInfo,
     handle: runtime::ComponentHandle,
     metadata: runtime::Metadata,
+    has_sessions: bool,
 ) -> anyhow::Result<()> {
     let bridge = ActRmcpBridge {
         handle,
         info,
         metadata,
+        has_sessions,
     };
 
     let service = rmcp::serve_server(bridge, (tokio::io::stdin(), tokio::io::stdout()))
@@ -194,7 +207,14 @@ impl ActRmcpBridge {
             })?
             .map_err(component_error_to_mcp)?;
 
-        let tools = convert_tool_definitions(&list.tools);
+        let mut tools = convert_tool_definitions(&list.tools);
+
+        if self.has_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());
+        }
+
         Ok(rmcp::model::ListToolsResult {
             tools,
             next_cursor: None,
@@ -202,24 +222,84 @@ impl ActRmcpBridge {
         })
     }
 
+    /// Ask the component for its `get-open-session-args-schema` JSON Schema.
+    /// Errors bubble up as MCP errors so the agent sees them at list_tools time.
+    async fn fetch_open_session_args_schema(&self) -> Result<Value, rmcp::ErrorData> {
+        let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+        let req = runtime::ComponentRequest::GetOpenSessionArgsSchema {
+            metadata: self.metadata.clone().into(),
+            reply: reply_tx,
+        };
+        self.handle.send(req).await.map_err(|_| {
+            rmcp::ErrorData::new(
+                rmcp::model::ErrorCode::INTERNAL_ERROR,
+                "component actor unavailable",
+                None,
+            )
+        })?;
+        let schema = reply_rx
+            .await
+            .map_err(|_| {
+                rmcp::ErrorData::new(
+                    rmcp::model::ErrorCode::INTERNAL_ERROR,
+                    "component actor dropped reply",
+                    None,
+                )
+            })?
+            .map_err(component_error_to_mcp)?;
+        serde_json::from_str::<Value>(&schema).map_err(|e| {
+            rmcp::ErrorData::new(
+                rmcp::model::ErrorCode::INTERNAL_ERROR,
+                format!("component returned non-JSON schema: {e}"),
+                None,
+            )
+        })
+    }
+
     async fn call_tool_impl(
         &self,
         request: rmcp::model::CallToolRequestParams,
+        ctx_meta: &rmcp::model::Meta,
     ) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
         use rmcp::model::ErrorCode;
 
-        let mut arguments = request
+        // Merge protocol-level `_meta` (per MCP SEP-1319) into the WIT
+        // metadata before dispatching. Hosts MUST forward `std:session-id`
+        // here per ACT-SESSIONS §6.1.
+        //
+        // rmcp moves `_meta` off params into `RequestContext::meta` during
+        // request dispatch (see service.rs `std::mem::swap`), so that's
+        // where we read it from — not `params.meta` (always None) and not
+        // `extensions` (which holds non-meta extension values).
+        let mut call_metadata = self.metadata.clone();
+        if !ctx_meta.0.is_empty() {
+            call_metadata.extend(act_types::types::Metadata::from(Value::Object(
+                ctx_meta.0.clone(),
+            )));
+        }
+
+        // Route reserved virtual tools (`open_session` / `close_session`).
+        if self.has_sessions {
+            match request.name.as_ref() {
+                VIRTUAL_OPEN_SESSION => {
+                    return self
+                        .virtual_open_session(request.arguments, call_metadata)
+                        .await;
+                }
+                VIRTUAL_CLOSE_SESSION => {
+                    return self
+                        .virtual_close_session(request.arguments, call_metadata)
+                        .await;
+                }
+                _ => {}
+            }
+        }
+
+        let arguments = request
             .arguments
             .map(Value::Object)
             .unwrap_or_else(|| serde_json::json!({}));
 
-        let mut call_metadata = self.metadata.clone();
-        if let Some(obj) = arguments.as_object_mut()
-            && let Some(Value::Object(extra)) = obj.remove("_metadata")
-        {
-            call_metadata.extend(act_types::types::Metadata::from(Value::Object(extra)));
-        }
-
         let cbor_args = act_types::cbor::json_to_cbor(&arguments).map_err(|_| {
             rmcp::ErrorData::new(ErrorCode::INVALID_PARAMS, "invalid arguments", None)
         })?;
@@ -253,6 +333,160 @@ impl ActRmcpBridge {
 
         Ok(fold_events_to_result(result))
     }
+
+    async fn virtual_open_session(
+        &self,
+        arguments: Option<rmcp::model::JsonObject>,
+        metadata: runtime::Metadata,
+    ) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
+        let args_obj = arguments.unwrap_or_default();
+        let mut wit_args: Vec<(String, Vec<u8>)> = Vec::with_capacity(args_obj.len());
+        for (key, value) in args_obj {
+            let cbor_bytes = cbor::json_to_cbor(&value).map_err(|_| {
+                rmcp::ErrorData::new(
+                    rmcp::model::ErrorCode::INVALID_PARAMS,
+                    format!("encoding `{key}` as CBOR failed"),
+                    None,
+                )
+            })?;
+            wit_args.push((key, cbor_bytes));
+        }
+
+        let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+        let req = runtime::ComponentRequest::OpenSession {
+            args: wit_args,
+            metadata: metadata.into(),
+            reply: reply_tx,
+        };
+        self.handle.send(req).await.map_err(|_| {
+            rmcp::ErrorData::new(
+                rmcp::model::ErrorCode::INTERNAL_ERROR,
+                "component actor unavailable",
+                None,
+            )
+        })?;
+        let session = reply_rx
+            .await
+            .map_err(|_| {
+                rmcp::ErrorData::new(
+                    rmcp::model::ErrorCode::INTERNAL_ERROR,
+                    "component actor dropped reply",
+                    None,
+                )
+            })?
+            .map_err(component_error_to_mcp)?;
+
+        let metadata_json: serde_json::Map<String, Value> = session
+            .metadata
+            .iter()
+            .filter_map(|(k, v)| Some((k.clone(), cbor::cbor_to_json(v).ok()?)))
+            .collect();
+        let payload = serde_json::json!({
+            "id": session.id,
+            "metadata": metadata_json,
+        });
+        let json_text = serde_json::to_string(&payload).unwrap_or_default();
+
+        Ok(rmcp::model::CallToolResult::success(vec![Content::text(
+            json_text,
+        )]))
+    }
+
+    async fn virtual_close_session(
+        &self,
+        arguments: Option<rmcp::model::JsonObject>,
+        _metadata: runtime::Metadata,
+    ) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
+        let session_id = arguments
+            .as_ref()
+            .and_then(|obj| obj.get("session_id"))
+            .and_then(|v| v.as_str())
+            .ok_or_else(|| {
+                rmcp::ErrorData::new(
+                    rmcp::model::ErrorCode::INVALID_PARAMS,
+                    "close_session requires `session_id` (string)",
+                    None,
+                )
+            })?
+            .to_string();
+
+        let (reply_tx, reply_rx) = tokio::sync::oneshot::channel();
+        let req = runtime::ComponentRequest::CloseSession {
+            session_id,
+            reply: reply_tx,
+        };
+        self.handle.send(req).await.map_err(|_| {
+            rmcp::ErrorData::new(
+                rmcp::model::ErrorCode::INTERNAL_ERROR,
+                "component actor unavailable",
+                None,
+            )
+        })?;
+        reply_rx
+            .await
+            .map_err(|_| {
+                rmcp::ErrorData::new(
+                    rmcp::model::ErrorCode::INTERNAL_ERROR,
+                    "component actor dropped reply",
+                    None,
+                )
+            })?
+            .map_err(component_error_to_mcp)?;
+        Ok(rmcp::model::CallToolResult::success(vec![]))
+    }
+}
+
+/// Build the synthetic `open_session` MCP tool. The args schema comes from
+/// `get-open-session-args-schema`. `_meta.std:session-op = "open"`
+/// per ACT-CONSTANTS so agents can recognize this is a session-lifecycle
+/// tool, not an ordinary capability.
+fn virtual_open_session_tool(args_schema: Value) -> Tool {
+    let mut schema_map: serde_json::Map<String, Value> =
+        args_schema.as_object().cloned().unwrap_or_default();
+    schema_map
+        .entry("type".to_string())
+        .or_insert(Value::String("object".into()));
+
+    let mut tool = Tool::new(
+        Cow::Borrowed(VIRTUAL_OPEN_SESSION),
+        Cow::Borrowed("Open a new session against this component."),
+        Arc::new(schema_map),
+    );
+    tool = tool.with_meta(session_op_meta("open"));
+    tool
+}
+
+/// Build the synthetic `close_session` MCP tool. Args is fixed:
+/// `{ session_id: string }`. `_meta.std:session-op = "close"`.
+fn virtual_close_session_tool() -> Tool {
+    let schema_map: serde_json::Map<String, Value> = serde_json::json!({
+        "type": "object",
+        "properties": {
+            "session_id": {
+                "type": "string",
+                "description": "Session-id returned by `open_session`."
+            }
+        },
+        "required": ["session_id"],
+        "additionalProperties": false,
+    })
+    .as_object()
+    .cloned()
+    .unwrap_or_default();
+
+    let mut tool = Tool::new(
+        Cow::Borrowed(VIRTUAL_CLOSE_SESSION),
+        Cow::Borrowed("Close a session previously opened via `open_session`."),
+        Arc::new(schema_map),
+    );
+    tool = tool.with_meta(session_op_meta("close"));
+    tool
+}
+
+fn session_op_meta(op: &'static str) -> rmcp::model::Meta {
+    let mut map = serde_json::Map::new();
+    map.insert(META_SESSION_OP.to_string(), Value::String(op.to_string()));
+    rmcp::model::Meta(map)
 }
 
 impl rmcp::ServerHandler for ActRmcpBridge {
@@ -278,14 +512,12 @@ impl rmcp::ServerHandler for ActRmcpBridge {
         self.list_tools_impl()
     }
 
-    fn call_tool(
+    async fn call_tool(
         &self,
         request: rmcp::model::CallToolRequestParams,
-        _context: rmcp::service::RequestContext<rmcp::RoleServer>,
-    ) -> impl std::future::Future<Output = Result<rmcp::model::CallToolResult, rmcp::ErrorData>>
-    + Send
-    + '_ {
-        self.call_tool_impl(request)
+        context: rmcp::service::RequestContext<rmcp::RoleServer>,
+    ) -> Result<rmcp::model::CallToolResult, rmcp::ErrorData> {
+        self.call_tool_impl(request, &context.meta).await
     }
 }
 
@@ -378,6 +610,7 @@ mod tests {
             handle: fake_handle(),
             info: fake_info(),
             metadata: runtime::Metadata::default(),
+            has_sessions: false,
         };
         let info = rmcp::ServerHandler::get_info(&bridge);
         assert_eq!(info.server_info.name, "example");

{act_cli-0.6.0 → act_cli-0.7.0}/act-cli/src/runtime/mod.rs

@@ -5,7 +5,7 @@ use std::pin::Pin;
 use std::task::{Context, Poll};
 use tokio::sync::{mpsc, oneshot};
 use wasmtime::component::{Component, Linker, ResourceTable, Source, StreamConsumer, StreamResult};
-use wasmtime::{Config, Engine, Store, StoreContextMut};
+use wasmtime::{AsContextMut, Config, Engine, Store, StoreContextMut};
 use wasmtime_wasi::{WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView};
 use wasmtime_wasi_http::WasiHttpCtx;
 use wasmtime_wasi_http::p3::WasiHttpCtxView;
@@ -16,6 +16,7 @@ pub mod fs_policy;
 pub mod http_client;
 pub mod http_policy;
 pub mod network;
+pub mod sessions;
 
 // Generated bindings from WIT — fully auto-generated, no manual patching.
 #[allow(unused_mut, unused_variables, dead_code)]
@@ -283,6 +284,26 @@ pub enum ComponentRequest {
         metadata: Vec<(String, Vec<u8>)>,
         event_tx: mpsc::Sender<SseEvent>,
     },
+    /// Returns a JSON Schema string. Errors with `std:not-found` if the
+    /// component does not export `session-provider`.
+    GetOpenSessionArgsSchema {
+        metadata: Vec<(String, Vec<u8>)>,
+        reply: oneshot::Sender<Result<String, ComponentError>>,
+    },
+    /// Errors with `std:not-found` if the component does not export
+    /// `session-provider`.
+    OpenSession {
+        args: Vec<(String, Vec<u8>)>,
+        metadata: Vec<(String, Vec<u8>)>,
+        reply: oneshot::Sender<Result<sessions::Session, ComponentError>>,
+    },
+    /// Errors with `std:not-found` if the component does not export
+    /// `session-provider`. The reply carries `()` so callers can wait for
+    /// the close to complete.
+    CloseSession {
+        session_id: String,
+        reply: oneshot::Sender<Result<(), ComponentError>>,
+    },
 }
 
 /// Collected result from call-tool (stream already consumed).
@@ -300,8 +321,12 @@ pub enum SseEvent {
 /// Handle to send requests to the component actor.
 pub type ComponentHandle = mpsc::Sender<ComponentRequest>;
 
-/// Instantiate the component. Returns the ActWorld and the store.
-/// Component info is read from custom sections (no instantiation needed for that).
+/// Instantiate the component. Returns the ActWorld, an optional
+/// SessionProvider (present iff the component exports
+/// `act:sessions/session-provider`), and the store.
+///
+/// Component info is read from custom sections (no instantiation needed
+/// for that).
 pub async fn instantiate_component(
     engine: &Engine,
     component: &Component,
@@ -310,20 +335,50 @@ pub async fn instantiate_component(
     http: &crate::config::HttpConfig,
     fs: &crate::config::FsConfig,
     info: &ComponentInfo,
-) -> Result<(ActWorld, Store<HostState>)> {
+) -> Result<(
+    ActWorld,
+    Option<sessions::SessionProvider>,
+    Store<HostState>,
+)> {
     let mut store = create_store(engine, preopens, http, fs, info)?;
-    let instance = ActWorld::instantiate_async(&mut store, component, linker)
+
+    // Manual instantiation flow (replicates ActWorld::instantiate_async)
+    // so we keep access to the raw `Instance` for session-provider lookup.
+    let pre = linker
+        .instantiate_pre(component)
+        .map_err(|e| anyhow::anyhow!("failed to pre-instantiate component: {e}"))?;
+    let indices =
+        ActWorldIndices::new(&pre).map_err(|e| anyhow::anyhow!("ActWorld indices: {e}"))?;
+    let instance = pre
+        .instantiate_async(&mut store)
         .await
         .map_err(|e| anyhow::anyhow!("failed to instantiate component: {e}"))?;
+    let act_world = indices
+        .load(&mut store, &instance)
+        .map_err(|e| anyhow::anyhow!("failed to load ActWorld: {e}"))?;
+
+    let session_provider = sessions::SessionProvider::lookup(&instance, store.as_context_mut())?;
 
-    Ok((instance, store))
+    Ok((act_world, session_provider, store))
 }
 
-/// Spawn the component actor task. Owns the Store and ActWorld.
+/// Spawn the component actor task. Owns the Store, ActWorld, and the
+/// optional SessionProvider (present iff the component supports
+/// `act:sessions/session-provider`).
+///
 /// Returns a handle for sending requests.
-pub fn spawn_component_actor(instance: ActWorld, mut store: Store<HostState>) -> ComponentHandle {
+pub fn spawn_component_actor(
+    instance: ActWorld,
+    session_provider: Option<sessions::SessionProvider>,
+    mut store: Store<HostState>,
+) -> ComponentHandle {
     let (tx, mut rx) = mpsc::channel::<ComponentRequest>(32);
 
+    // Session-ids opened through this actor. Closed on actor shutdown
+    // per ACT-SESSIONS §2.5 ("host MUST call close-session for every
+    // still-open session before deinit").
+    let mut tracked_sessions: Vec<String> = Vec::new();
+
     tokio::spawn(async move {
         while let Some(request) = rx.recv().await {
             match request {
@@ -477,6 +532,97 @@ pub fn spawn_component_actor(instance: ActWorld, mut store: Store<HostState>) ->
                     };
                     let _ = event_tx.send(terminal).await;
                 }
+
+                ComponentRequest::GetOpenSessionArgsSchema { metadata, reply } => {
+                    let response = match &session_provider {
+                        Some(sp) => {
+                            let sp = sp.clone();
+                            let result = store
+                                .run_concurrent(async |accessor| {
+                                    sp.get_open_session_args_schema
+                                        .call_concurrent(&accessor, (metadata,))
+                                        .await
+                                })
+                                .await;
+                            session_call_to_response(result, |(r,)| r)
+                        }
+                        None => Err(ComponentError::Internal(anyhow::anyhow!(
+                            "component does not export act:sessions/session-provider"
+                        ))),
+                    };
+                    let _ = reply.send(response);
+                }
+
+                ComponentRequest::OpenSession {
+                    args,
+                    metadata,
+                    reply,
+                } => {
+                    let response = match &session_provider {
+                        Some(sp) => {
+                            let sp = sp.clone();
+                            let result = store
+                                .run_concurrent(async |accessor| {
+                                    sp.open_session
+                                        .call_concurrent(&accessor, (args, metadata))
+                                        .await
+                                })
+                                .await;
+                            let inner = session_call_to_response(result, |(r,)| r);
+                            // Track open id so we can close on deinit.
+                            if let Ok(s) = &inner {
+                                tracked_sessions.push(s.id.clone());
+                            }
+                            inner
+                        }
+                        None => Err(ComponentError::Internal(anyhow::anyhow!(
+                            "component does not export act:sessions/session-provider"
+                        ))),
+                    };
+                    let _ = reply.send(response);
+                }
+
+                ComponentRequest::CloseSession { session_id, reply } => {
+                    let response: Result<(), ComponentError> = match &session_provider {
+                        Some(sp) => {
+                            let sp = sp.clone();
+                            let id = session_id.clone();
+                            let result = store
+                                .run_concurrent(async |accessor| {
+                                    sp.close_session.call_concurrent(&accessor, (id,)).await
+                                })
+                                .await;
+                            // Untrack regardless of error.
+                            tracked_sessions.retain(|sid| sid != &session_id);
+                            match result {
+                                Ok(Ok(())) => Ok(()),
+                                Ok(Err(e)) => Err(ComponentError::Internal(anyhow::anyhow!(
+                                    "close-session failed: {e}"
+                                ))),
+                                Err(e) => Err(ComponentError::Internal(anyhow::anyhow!(
+                                    "run_concurrent failed: {e}"
+                                ))),
+                            }
+                        }
+                        None => Err(ComponentError::Internal(anyhow::anyhow!(
+                            "component does not export act:sessions/session-provider"
+                        ))),
+                    };
+                    let _ = reply.send(response);
+                }
+            }
+        }
+
+        // Actor channel closed → component is shutting down. Close any
+        // sessions we still track, best-effort. ACT-SESSIONS §2.5.
+        if let Some(sp) = &session_provider {
+            for id in std::mem::take(&mut tracked_sessions) {
+                let sp = sp.clone();
+                let _ = store
+                    .run_concurrent(async |accessor| {
+                        sp.close_session.call_concurrent(&accessor, (id,)).await
+                    })
+                    .await;
             }
         }
     });
@@ -484,6 +630,33 @@ pub fn spawn_component_actor(instance: ActWorld, mut store: Store<HostState>) ->
     tx
 }
 
+/// Helper for unwrapping `result<R, error>` returns from session-provider
+/// typed-func calls.
+fn session_call_to_response<R, F>(
+    raw: wasmtime::Result<
+        wasmtime::Result<(Result<R, exports::act::tools::tool_provider::Error>,)>,
+    >,
+    extract: F,
+) -> Result<R, ComponentError>
+where
+    F: FnOnce(
+        (Result<R, exports::act::tools::tool_provider::Error>,),
+    ) -> Result<R, exports::act::tools::tool_provider::Error>,
+{
+    match raw {
+        Ok(Ok(tuple)) => match extract(tuple) {
+            Ok(r) => Ok(r),
+            Err(e) => Err(ComponentError::Tool(e)),
+        },
+        Ok(Err(e)) => Err(ComponentError::Internal(anyhow::anyhow!(
+            "session-provider call failed: {e}"
+        ))),
+        Err(e) => Err(ComponentError::Internal(anyhow::anyhow!(
+            "run_concurrent failed: {e}"
+        ))),
+    }
+}
+
 /// A StreamConsumer that collects all items into a Vec and signals completion.
 struct CollectingConsumer {
     collected: std::sync::Arc<std::sync::Mutex<Vec<exports::act::tools::tool_provider::ToolEvent>>>,

act_cli-0.7.0/act-cli/src/runtime/sessions.rs

@@ -0,0 +1,112 @@
+//! Host-side wrappers for the `act:sessions/session-provider` interface.
+//!
+//! The host's `bindgen!` only covers `act:tools/tool-provider`, so we
+//! look up the session-provider exports manually via raw component-model
+//! APIs. Components without session-provider exports are loaded fine —
+//! `lookup` simply returns `None` for them.
+//!
+//! `Error` and `LocalizedString` types are reused from the tool-provider
+//! bindings (they are the same `act:core/types` records via structural
+//! typing in wasmtime).
+
+use anyhow::Result;
+use wasmtime::component::{ComponentNamedList, ComponentType, Instance, Lift, Lower, TypedFunc};
+use wasmtime::{AsContext, AsContextMut, StoreContextMut};
+
+use super::HostState;
+use super::exports::act::tools::tool_provider::{Error, LocalizedString};
+
+/// `act:sessions/session-provider.session` — the WIT record returned by
+/// `open-session`.
+#[derive(Debug, Clone, ComponentType, Lift, Lower)]
+#[component(record)]
+pub struct Session {
+    pub id: String,
+    pub metadata: Vec<(String, Vec<u8>)>,
+}
+
+// ── Typed function aliases (matching the WIT signatures) ───────────────────
+
+/// `get-open-session-args-schema(metadata: metadata) -> result<string, error>`
+type GetOpenSessionArgsSchemaFn = TypedFunc<(Vec<(String, Vec<u8>)>,), (Result<String, Error>,)>;
+
+/// `open-session(args: metadata, metadata: metadata) -> result<session, error>`
+type OpenSessionFn =
+    TypedFunc<(Vec<(String, Vec<u8>)>, Vec<(String, Vec<u8>)>), (Result<Session, Error>,)>;
+
+/// `close-session(session-id: string)`
+type CloseSessionFn = TypedFunc<(String,), ()>;
+
+const INTERFACE_NAME: &str = "act:sessions/session-provider@0.1.0";
+
+/// Typed handles to the three session-provider functions of one component
+/// instance.
+#[derive(Clone)]
+pub struct SessionProvider {
+    pub get_open_session_args_schema: GetOpenSessionArgsSchemaFn,
+    pub open_session: OpenSessionFn,
+    pub close_session: CloseSessionFn,
+}
+
+impl SessionProvider {
+    /// Look up the session-provider exports of a component instance.
+    /// Returns `None` if the component doesn't export session-provider.
+    pub fn lookup(
+        instance: &Instance,
+        mut store: StoreContextMut<'_, HostState>,
+    ) -> Result<Option<Self>> {
+        let Some((_, iface)) = instance.get_export(&mut store, None, INTERFACE_NAME) else {
+            return Ok(None);
+        };
+
+        let get_schema = lookup_typed(
+            instance,
+            store.as_context_mut(),
+            Some(&iface),
+            "get-open-session-args-schema",
+        )?;
+        let open = lookup_typed(
+            instance,
+            store.as_context_mut(),
+            Some(&iface),
+            "open-session",
+        )?;
+        let close = lookup_typed(
+            instance,
+            store.as_context_mut(),
+            Some(&iface),
+            "close-session",
+        )?;
+
+        Ok(Some(Self {
+            get_open_session_args_schema: get_schema,
+            open_session: open,
+            close_session: close,
+        }))
+    }
+}
+
+fn lookup_typed<Params, Return>(
+    instance: &Instance,
+    mut store: StoreContextMut<'_, HostState>,
+    iface: Option<&wasmtime::component::ComponentExportIndex>,
+    name: &str,
+) -> Result<TypedFunc<Params, Return>>
+where
+    Params: ComponentNamedList + Lower + Send + Sync + 'static,
+    Return: ComponentNamedList + Lift + Send + Sync + 'static,
+{
+    let (_, idx) = instance
+        .get_export(&mut store, iface, name)
+        .ok_or_else(|| anyhow::anyhow!("session-provider missing export `{name}`"))?;
+    let func = instance
+        .get_func(&mut store, idx)
+        .ok_or_else(|| anyhow::anyhow!("session-provider export `{name}` is not a function"))?;
+    func.typed::<Params, Return>(store.as_context())
+        .map_err(|e| anyhow::anyhow!("session-provider `{name}` typed lookup failed: {e}"))
+}
+
+// LocalizedString is currently only referenced indirectly through Error;
+// keep the import alive for callers that grow handling here.
+#[allow(dead_code)]
+fn _localized_string_in_scope(_: LocalizedString) {}