Fix/stateless client server

.github/workflows/integration.yml

@@ -0,0 +1,31 @@
+name: Integration Tests
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  integration:
+    name: Integration tests
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: Run unit and local integration tests
+        run: cargo test --all-features
+
+      - name: Run integration example (local RMCP)
+        run: cargo run --example rmcp_integration_test --features rmcp -- local

.github/workflows/rust.yml

@@ -0,0 +1,42 @@
+name: Rust CI
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache dependencies
+        uses: Swatinem/rust-cache@v2
+
+      - name: Check
+        run: cargo check --all --all-features
+
+      - name: Test
+        run: cargo test --all --all-features
+
+      - name: Format check
+        run: cargo fmt --all -- --check
+
+      - name: Clippy
+        run: cargo clippy --all --all-features -- -D warnings
+
+      - name: Doc check
+        run: cargo doc --no-deps --all-features
+
+      - name: Build
+        run: cargo build --verbose

CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+## [0.1.0] - 2026-05-07
+
+### Added
+
+- Core transport layer: `NostrClientTransport` and `NostrServerTransport` over NIP-59 gift wraps
+- Gateway and Proxy high-level APIs for bridging MCP over Nostr
+- Discovery API: `discover_servers`, `discover_tools`, `discover_resources`, `discover_prompts`, `discover_resource_templates`
+- CEP-6: server announcement publishing and querying (kinds 11316–11320)
+- CEP-19: ephemeral gift wraps (kind 21059) with `GiftWrapMode` negotiation on both client and server
+- CEP-35: stateless session discovery, tag composition, and capability learning
+- LRU-bounded session store with configurable capacity (default 1000 sessions) and TTL expiry
+- Multi-client support in `NostrServerWorker` (removed single-peer barrier)
+- Direct rmcp transport adapters via `into_rmcp_transport()` for native `ContextVM` services
+- `CancellationToken`-based graceful shutdown on `close()`
+- TTL sweep for client and server correlation stores to prevent pending-request leaks
+- `MockRelayPool` for deterministic offline testing
+- Builder pattern for all transport and worker configuration structs
+- Four examples: gateway, proxy, discovery, and rmcp integration test
+
+### Fixed
+
+- Single-peer barrier in RMCP worker rejected concurrent clients (#60)
+- Pending-request leak: correlation store entries never expired by TTL (#61)
+- Event loop tasks not cancelled on `close()`, causing resource leaks (#63)
+- `RecvError::Lagged` killing event loop under high relay throughput (#68)
+- Client race condition: responses lost when publish completed before correlation registration (#55)
+- Uncorrelated responses (missing `e` tag) forwarded to consumer instead of dropped (#55)
+- Non-atomic `send_response` behavior in server transport (#48)
+- Unbounded LRU cache initialization with zero capacity (#50)
+- Announced servers not sending JSON-RPC `-32000 Unauthorized` error for disallowed clients (#53)

Cargo.toml

@@ -2,9 +2,15 @@
 name = "contextvm-sdk"
 version = "0.1.0"
 edition = "2021"
+rust-version = "1.70"
 description = "Rust SDK for the ContextVM protocol — MCP over Nostr"
 license = "MIT"
-repository = "https://github.com/k0sti/rust-contextvm-sdk"
+readme = "README.md"
+repository = "https://github.com/ContextVM/rs-sdk"
+homepage = "https://contextvm.org"
+documentation = "https://docs.rs/contextvm-sdk"
+keywords = ["nostr", "mcp", "model-context-protocol", "decentralized", "ai"]
+categories = ["network-programming", "api-bindings", "asynchronous"]
 
 [dependencies]
 # Async runtime
@@ -24,6 +30,34 @@ nostr-sdk = { version = "0.43", features = ["nip59"] }
 # Logging
 tracing = "0.1"
 
+# Optional MCP integration (Rust equivalent to TS @modelcontextprotocol/sdk)
+rmcp = { version = "0.16.0", features = ["server", "client", "macros", "transport-worker"], optional = true }
+
+# LRU cache for gift-wrap (outer event id) deduplication
+lru = "0.12"
+
+# CancellationToken for graceful event-loop shutdown
+tokio-util = { version = "0.7", features = ["rt"] }
+
+[features]
+# Enable rmcp by default while keeping legacy APIs available.
+default = ["rmcp"]
+rmcp = ["dep:rmcp"]
+
+[[example]]
+name = "rmcp_integration_test"
+required-features = ["rmcp"]
+
+[[example]]
+name = "native_echo_server"
+required-features = ["rmcp"]
+
+[[example]]
+name = "native_echo_client"
+required-features = ["rmcp"]
+
 [dev-dependencies]
 tokio-test = "0.4"
-tracing-subscriber = "0.3"
+anyhow = "1"
+schemars = "0.8"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }

DESIGN.md

@@ -221,7 +221,7 @@ tracing-subscriber = "0.3"
     - Unit test: rejects events from wrong server pubkey
 
 - [x] **2.4** Implement `NostrServerTransport`
-  - Config: relay_urls, encryption_mode, server_info, is_public_server, allowed_public_keys, excluded_capabilities, cleanup_interval_ms, session_timeout_ms
+  - Config: relay_urls, encryption_mode, server_info, is_announced_server, allowed_public_keys, excluded_capabilities, cleanup_interval_ms, session_timeout_ms
   - Implements `Transport` trait
   - Features:
     - Subscribe to events targeting server pubkey

README.md

@@ -77,19 +77,16 @@ use contextvm_sdk::signer;
 async fn main() -> contextvm_sdk::Result<()> {
     let keys = signer::generate();
 
-    let config = GatewayConfig {
-        nostr_config: NostrServerTransportConfig {
-            relay_urls: vec!["wss://relay.damus.io".into()],
-            encryption_mode: EncryptionMode::Optional,
-            server_info: Some(ServerInfo {
-                name: Some("My MCP Server".into()),
-                about: Some("Tools via Nostr".into()),
-                ..Default::default()
-            }),
-            is_public_server: true,
-            ..Default::default()
-        },
-    };
+    let config = GatewayConfig::new(
+        NostrServerTransportConfig::default()
+            .with_encryption_mode(EncryptionMode::Optional)
+            .with_server_info(
+                ServerInfo::default()
+                    .with_name("My MCP Server")
+                    .with_about("Tools via Nostr"),
+            )
+            .with_announced_server(true),
+    );
 
     let mut gateway = NostrMCPGateway::new(keys, config).await?;
     let mut requests = gateway.start().await?;
@@ -116,14 +113,11 @@ use contextvm_sdk::signer;
 async fn main() -> contextvm_sdk::Result<()> {
     let keys = signer::generate();
 
-    let config = ProxyConfig {
-        nostr_config: NostrClientTransportConfig {
-            relay_urls: vec!["wss://relay.damus.io".into()],
-            server_pubkey: "abc123...server_hex_pubkey".into(),
-            encryption_mode: EncryptionMode::Optional,
-            ..Default::default()
-        },
-    };
+    let config = ProxyConfig::new(
+        NostrClientTransportConfig::default()
+            .with_server_pubkey("abc123...server_hex_pubkey")
+            .with_encryption_mode(EncryptionMode::Optional),
+    );
 
     let mut proxy = NostrMCPProxy::new(keys, config).await?;
     let mut responses = proxy.start().await?;
@@ -201,7 +195,7 @@ metadata-private delivery. Server announcements (kinds 11316–11320) are always
 | `relay_urls`             | `["wss://relay.damus.io"]` | Nostr relays to connect to          |
 | `encryption_mode`        | `Optional`            | Encryption policy                        |
 | `server_info`            | `None`                | Server metadata for announcements        |
-| `is_public_server`       | `false`               | Whether to publish announcements         |
+| `is_announced_server`    | `false`               | Whether to publish announcements (CEP-6) |
 | `allowed_public_keys`    | `[]` (allow all)      | Client pubkey allowlist (hex)            |
 | `excluded_capabilities`  | `[]`                  | Methods exempt from allowlist            |
 | `session_timeout`        | `300s`                | Inactive session expiry                  |

examples/discovery.rs

@@ -53,8 +53,7 @@ async fn main() -> contextvm_sdk::Result<()> {
             println!("  Resources: {} found", resources.len());
         }
 
-        let prompts =
-            discovery::discover_prompts(client, &server.pubkey_parsed, &relays).await?;
+        let prompts = discovery::discover_prompts(client, &server.pubkey_parsed, &relays).await?;
         if !prompts.is_empty() {
             println!("  Prompts: {} found", prompts.len());
         }

examples/gateway.rs

@@ -2,6 +2,8 @@
 //!
 //! This demonstrates how to create a ContextVM gateway that receives
 //! MCP requests over Nostr and responds to them.
+//!
+//! Usage: cargo run --example gateway
 
 use contextvm_sdk::core::types::*;
 use contextvm_sdk::gateway::{GatewayConfig, NostrMCPGateway};
@@ -17,18 +19,14 @@ async fn main() -> contextvm_sdk::Result<()> {
     println!("Server pubkey: {}", keys.public_key().to_hex());
 
     // Configure the gateway
-    let config = GatewayConfig {
-        nostr_config: NostrServerTransportConfig {
-            relay_urls: vec!["wss://relay.damus.io".to_string()],
-            server_info: Some(ServerInfo {
-                name: Some("Echo Server".to_string()),
-                about: Some("A simple echo tool exposed via ContextVM".to_string()),
-                ..Default::default()
-            }),
-            is_public_server: true,
-            ..Default::default()
-        },
-    };
+    let nostr_config = NostrServerTransportConfig::default()
+        .with_server_info(
+            ServerInfo::default()
+                .with_name("Echo Server")
+                .with_about("A simple echo tool exposed via ContextVM"),
+        )
+        .with_announced_server(true);
+    let config = GatewayConfig::new(nostr_config);
 
     let mut gateway = NostrMCPGateway::new(keys, config).await?;
     let mut rx = gateway.start().await?;

examples/native_echo_client.rs

@@ -0,0 +1,94 @@
+//! Example: Native rmcp client over ContextVM/Nostr.
+//!
+//! Usage:
+//!   cargo run --example native_echo_client -- <server_pubkey_hex>
+
+use anyhow::{Context, Result};
+use contextvm_sdk::transport::client::{NostrClientTransport, NostrClientTransportConfig};
+use contextvm_sdk::{signer, EncryptionMode, GiftWrapMode};
+use rmcp::{
+    model::{CallToolRequestParams, CallToolResult},
+    ClientHandler, ServiceExt,
+};
+
+const RELAY_URL: &str = "wss://relay.contextvm.org";
+
+#[derive(Clone, Default)]
+struct EchoClient;
+
+impl ClientHandler for EchoClient {}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::from_default_env()
+                .add_directive("contextvm_sdk=info".parse()?)
+                .add_directive("rmcp=warn".parse()?),
+        )
+        .init();
+
+    let server_pubkey = std::env::args()
+        .nth(1)
+        .context("Usage: native_echo_client <server_pubkey_hex>")?;
+
+    let signer = signer::generate();
+    println!("Native ContextVM echo client starting");
+    println!("Relay: {RELAY_URL}");
+    println!("Client pubkey: {}", signer.public_key().to_hex());
+    println!("Target server pubkey: {server_pubkey}");
+
+    let transport = NostrClientTransport::new(
+        signer,
+        NostrClientTransportConfig::default()
+            .with_relay_urls(vec![RELAY_URL.to_string()])
+            .with_server_pubkey(server_pubkey)
+            .with_encryption_mode(EncryptionMode::Optional)
+            .with_gift_wrap_mode(GiftWrapMode::Optional),
+    )
+    .await?;
+
+    let client = EchoClient.serve(transport).await?;
+
+    let peer_info = client
+        .peer_info()
+        .context("server did not provide peer info after initialize")?;
+    println!("Connected to: {:?}", peer_info.server_info.name);
+
+    let tools = client.list_all_tools().await?;
+    println!("Discovered {} tool(s):", tools.len());
+    for tool in &tools {
+        println!("- {}", tool.name);
+    }
+
+    let result = client
+        .call_tool(CallToolRequestParams {
+            name: "echo".into(),
+            arguments: serde_json::from_value(serde_json::json!({
+                "message": "hello from native contextvm client"
+            }))
+            .ok(),
+            meta: None,
+            task: None,
+        })
+        .await?;
+
+    println!("Echo result: {}", first_text(&result));
+
+    client.cancel().await?;
+    Ok(())
+}
+
+fn first_text(result: &CallToolResult) -> String {
+    result
+        .content
+        .iter()
+        .find_map(|content| {
+            if let rmcp::model::RawContent::Text(text) = &content.raw {
+                Some(text.text.clone())
+            } else {
+                None
+            }
+        })
+        .unwrap_or_default()
+}