micro_mcp 0.1.4 → 0.1.5.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 237681f7f02a95987b7492f348eb11a5d2fd5f47cd241857cef7dc483abe003a
-  data.tar.gz: 9ce0515ed9aa5dc20bc80634211aaa623113729745497b905a8fcd91ceafe766
+  metadata.gz: e552447ebf478c88bda0459eb3141fe6ba5420c95e2d77c40aa38b288ca15316
+  data.tar.gz: b595bbd5ea356a94e655db28187d654beff9eaefe17a2ecd89ec195bc12094da
 SHA512:
-  metadata.gz: 2c95b5f9f2405e0fbfb026b9d90b925d6ae633c8911cdc0e7441e39e5df45841b464cfa353c2db87d7f4ba1c4ad2803f0fd6c0d90fe1a839c1aaa2d432a5135a
-  data.tar.gz: 90043b1f1b456f4fd9dce0a916928189bb63337601b57ea3a015fad400c5afc83f622b239e78a8591b4759d40f0b84fb75403914e2abf369295ac9c8f83106f7
+  metadata.gz: 90b0849f3d2a230a9549469361b8cd28eaacedda35bc56dca909db7c56b8ef76bb524a95d438cbf44171e3802b1012b86430027b043310fa843b4cf7bc127f1a
+  data.tar.gz: 3ba54b142bdfc3001b4fade24baf4b6e446041bf9b5d7009cae52d1085c434ae60f3e4b20ce38ac72066d8864c0342787d5a3fac741ba9e3d1c159f5db57b40c

data/CHANGELOG.md

@@ -6,11 +6,14 @@
 - Argument support for tools
 - Exposed `client_supports_sampling` on runtime
 - Exposed `create_message` on runtime
+- Prompt registry for registering prompts with arguments and runtime access
 
 ### Changed
 - Gem renamed from `mcp_lite` to `micro_mcp`
 - Tool handling uses a dynamic registry
 - Improved server error handling
+- Updated dependency `rust-mcp-sdk` to 0.5.0
+- Rooted stored Ruby `Proc` objects to avoid GC issues
 
 ## [0.1.0] - 2025-06-17
 

data/Cargo.lock

@@ -1092,9 +1092,9 @@ dependencies = [
 
 [[package]]
 name = "rust-mcp-macros"
-version = "0.4.2"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "375eba9388d9d5ffc8951e5f25296f9739be4e5700375ac7c74ad957a903b92b"
+checksum = "5a495ee12964fa392044792db4e9da78c94756e186a5712e5d7e625c143419ff"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1105,9 +1105,9 @@ dependencies = [
 
 [[package]]
 name = "rust-mcp-schema"
-version = "0.6.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a794de25669a2d21c5074ec5082f74f5e88863a112339fe90264d9e480b0ee8b"
+checksum = "fec1ff3507a619b9945f60a94dac448541aef8c9803aa6192c30f4a932cb1499"
 dependencies = [
  "serde",
  "serde_json",
@@ -1115,9 +1115,9 @@ dependencies = [
 
 [[package]]
 name = "rust-mcp-sdk"
-version = "0.4.7"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83f03dc968444ec56bdcddf17536b4b6860136a0d81d987f2fb909d5aec61ed7"
+checksum = "1fb7d9a1fdcf02efee5cd21a568f31c819b7f2d767c42b37cb79aab302ac5b35"
 dependencies = [
  "async-trait",
  "futures",
@@ -1133,9 +1133,9 @@ dependencies = [
 
 [[package]]
 name = "rust-mcp-transport"
-version = "0.3.6"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94b5a7f8e688f8b15d67f8d94cc0481cd08c9f4e848f4b9e832677dd5fdb063e"
+checksum = "d7f5468b8a00e800c3d708321216439ee1ad433592d725df93668bff75436348"
 dependencies = [
  "async-trait",
  "bytes",
@@ -1294,9 +1294,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.10"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04dc19736151f35336d325007ac991178d504a119863a2fcb3758cdb5e52c50d"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "smallvec"

data/ext/micro_mcp/AGENTS.md

@@ -64,3 +64,34 @@ cargo metadata --format-version 1 --no-deps \
    - Memory management between Rust and Ruby
    - Proper error handling across language boundaries
    - Thread safety considerations
+
+## Ruby & Rust GC Rules
+
+- Ruby's GC can't see values stored in ordinary Rust memory. Anything kept in a
+  `Vec`, `HashMap`, `OnceCell`, or static variable must be rooted or pinned.
+- Use `value::BoxValue<T>` to pin individual Ruby `Value`s. `BoxValue::new` will
+  `rb_gc_register_address` the object so it stays valid.
+- Expose Rust structs to Ruby with `#[magnus::wrap]`/`#[derive(TypedData)]` and
+  `Obj<T>`. `Obj<T>` is just a typed handle, so wrap it again in `BoxValue` (or
+  register it) if you keep it on the Rust side.
+- For containers of many Ruby values, wrap the container itself in a `TypedData`
+  struct and implement a `mark` method to mark each entry. Root that single
+  wrapper instead of each entry.
+- When using globals, prefer a wrapper similar to:
+
+  ```rust
+  static REG: OnceCell<Obj<Registry>> = OnceCell::new();
+  let reg = REG.get_or_init(|| {
+      let obj = Obj::wrap(Registry::new());
+      magnus::gc::register_mark_object(obj); // root the wrapper
+      obj
+  });
+  ```
+
+## Testing Checklist
+
+1. Call `GC.start` and `GC.compact` after each Ruby call in tests to stress the
+   garbage collector.
+2. Run `cargo miri` (or valgrind) to detect use-after-free in unsafe code.
+3. Remember `Obj<T>` is not `Send`/`Sync`; `BoxValue<T>` is. Convert or guard
+   before crossing threads.

data/ext/micro_mcp/Cargo.toml

@@ -15,8 +15,8 @@ magnus = { version = "0.7", features = ["rb-sys"] }
 rb-sys = { version = "*", default-features = false, features = [
   "stable-api-compiled-fallback",
 ] }
-rust-mcp-sdk = { version = "0.4.3", default-features = false, features = [
-  "server", "client", "2025_03_26"
+rust-mcp-sdk = { version = "0.5.0", default-features = false, features = [
+  "server", "client", "2025_06_18"
 ]}
 serde = "1.0.219"
 serde_json = "1.0.140"

data/ext/micro_mcp/src/lib.rs

@@ -9,6 +9,7 @@ fn init(ruby: &Ruby) -> Result<(), Error> {
     native.define_singleton_method("start_server", function!(server::start_server, 0))?;
     native.define_singleton_method("shutdown_server", function!(server::shutdown_server, 0))?;
     native.define_singleton_method("register_tool", function!(server::register_tool, 4))?;
+    native.define_singleton_method("register_prompt", function!(server::register_prompt, 4))?;
 
     let parent = ruby.define_module("MicroMcp")?;
     let class = parent.define_class("Runtime", ruby.class_object())?;

data/ext/micro_mcp/src/server.rs

@@ -2,9 +2,11 @@ use async_trait::async_trait;
 use rust_mcp_sdk::{
     mcp_server::{server_runtime, ServerHandler, ServerRuntime},
     schema::{
-        schema_utils::CallToolError, CallToolRequest, CallToolResult, Implementation,
-        InitializeResult, ListToolsRequest, ListToolsResult, RpcError, ServerCapabilities,
-        ServerCapabilitiesTools, Tool, ToolInputSchema, LATEST_PROTOCOL_VERSION,
+        schema_utils::CallToolError, CallToolRequest, CallToolResult, GetPromptRequest,
+        GetPromptResult, Implementation, InitializeResult, ListPromptsRequest, ListPromptsResult,
+        ListToolsRequest, ListToolsResult, Prompt, PromptArgument, PromptMessage, RpcError,
+        ServerCapabilities, ServerCapabilitiesPrompts, ServerCapabilitiesTools, TextContent, Tool,
+        ToolInputSchema, LATEST_PROTOCOL_VERSION,
     },
     McpServer, StdioTransport, TransportOptions,
 };
@@ -14,7 +16,11 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Mutex, OnceLock};
 use tokio::runtime::Runtime;
 
-use magnus::{block::Proc, value::ReprValue, Error, Ruby, Value};
+use magnus::{
+    block::Proc,
+    value::{BoxValue, ReprValue},
+    Error, Ruby, Value,
+};
 use magnus::{typed_data::DataTypeFunctions, TypedData};
 use std::cell::RefCell;
 use std::rc::Rc;
@@ -30,8 +36,13 @@ fn shutdown_flag() -> &'static Arc<AtomicBool> {
 
 type ToolHandler = RubyHandler;
 
-#[derive(Clone)]
-struct RubyHandler(Proc);
+struct RubyHandler(BoxValue<Proc>);
+
+impl Clone for RubyHandler {
+    fn clone(&self) -> Self {
+        RubyHandler(BoxValue::new(*self.0.as_ref()))
+    }
+}
 
 // SAFETY: We only call the stored Proc while holding the GVL.
 unsafe impl Send for RubyHandler {}
@@ -45,10 +56,22 @@ struct ToolEntry {
 
 static TOOLS: OnceLock<Mutex<HashMap<String, ToolEntry>>> = OnceLock::new();
 
+#[derive(Clone)]
+struct PromptEntry {
+    prompt: Prompt,
+    handler: RubyHandler,
+}
+
+static PROMPTS: OnceLock<Mutex<HashMap<String, PromptEntry>>> = OnceLock::new();
+
 fn tools() -> &'static Mutex<HashMap<String, ToolEntry>> {
     TOOLS.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
+fn prompts() -> &'static Mutex<HashMap<String, PromptEntry>> {
+    PROMPTS.get_or_init(|| Mutex::new(HashMap::new()))
+}
+
 fn ruby_value_to_json_value(ruby: &Ruby, val: Value) -> Result<JsonValue, Error> {
     let json_str: String = magnus::eval!(ruby, "require 'json'; JSON.generate(obj)", obj = val)?;
     serde_json::from_str(&json_str)
@@ -96,6 +119,36 @@ fn parse_tool_input_schema(json: JsonValue) -> ToolInputSchema {
     }
 }
 
+fn parse_prompt_arguments(json: JsonValue) -> Vec<PromptArgument> {
+    match json {
+        JsonValue::Array(items) => items
+            .into_iter()
+            .filter_map(|item| match item {
+                JsonValue::Object(map) => {
+                    let name = map.get("name")?.as_str()?.to_string();
+                    let description = map
+                        .get("description")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string());
+                    let required = map.get("required").and_then(|v| v.as_bool());
+                    let title = map
+                        .get("title")
+                        .and_then(|v| v.as_str())
+                        .map(|s| s.to_string());
+                    Some(PromptArgument {
+                        description,
+                        name,
+                        required,
+                        title,
+                    })
+                }
+                _ => None,
+            })
+            .collect(),
+        _ => Vec::new(),
+    }
+}
+
 #[derive(Clone, TypedData)]
 #[magnus(class = "MicroMcp::Runtime", free_immediately, unsafe_generics)]
 pub struct RubyMcpServer<'a> {
@@ -184,10 +237,13 @@ pub fn register_tool(
         annotations: None,
         description,
         input_schema: schema,
+        meta: None,
         name: name.clone(),
+        output_schema: None,
+        title: None,
     };
 
-    let handler_fn = RubyHandler(handler);
+    let handler_fn = RubyHandler(BoxValue::new(handler));
 
     let mut map = tools()
         .lock()
@@ -202,10 +258,121 @@ pub fn register_tool(
     Ok(())
 }
 
+pub fn register_prompt(
+    ruby: &Ruby,
+    name: String,
+    description: Option<String>,
+    arguments: Option<Value>,
+    handler: Proc,
+) -> Result<(), Error> {
+    let parsed_args = match arguments {
+        Some(val) => {
+            let json = ruby_value_to_json_value(ruby, val)?;
+            parse_prompt_arguments(json)
+        }
+        None => Vec::new(),
+    };
+
+    let prompt = Prompt {
+        arguments: parsed_args,
+        description,
+        meta: None,
+        name: name.clone(),
+        title: None,
+    };
+
+    let entry = PromptEntry {
+        prompt,
+        handler: RubyHandler(BoxValue::new(handler)),
+    };
+
+    let mut map = prompts()
+        .lock()
+        .map_err(|_| Error::new(ruby.exception_runtime_error(), "prompts mutex poisoned"))?;
+    map.insert(name, entry);
+    Ok(())
+}
+
 pub struct MyServerHandler;
 
 #[async_trait]
 impl ServerHandler for MyServerHandler {
+    async fn handle_list_prompts_request(
+        &self,
+        _request: ListPromptsRequest,
+        _runtime: &dyn McpServer,
+    ) -> Result<ListPromptsResult, RpcError> {
+        let prompts = {
+            let map = prompts().lock().map_err(|_| {
+                RpcError::internal_error().with_message("prompts mutex poisoned".to_string())
+            })?;
+            map.values().map(|p| p.prompt.clone()).collect()
+        };
+        Ok(ListPromptsResult {
+            prompts,
+            meta: None,
+            next_cursor: None,
+        })
+    }
+
+    async fn handle_get_prompt_request(
+        &self,
+        request: GetPromptRequest,
+        runtime: &dyn McpServer,
+    ) -> Result<GetPromptResult, RpcError> {
+        let map = prompts().lock().map_err(|_| {
+            RpcError::internal_error().with_message("prompts mutex poisoned".to_string())
+        })?;
+        match map.get(&request.params.name) {
+            Some(entry) => {
+                let proc = *entry.handler.0.as_ref();
+                let wrapper = RubyMcpServer::new(runtime);
+                let args_value = if let Some(map) = &request.params.arguments {
+                    let json = JsonValue::Object(
+                        map.iter()
+                            .map(|(k, v)| (k.clone(), JsonValue::String(v.clone())))
+                            .collect(),
+                    );
+                    Some(
+                        crate::utils::with_gvl(|| {
+                            let ruby = Ruby::get().unwrap();
+                            json_value_to_ruby_value(&ruby, &json)
+                        })
+                        .map_err(|e: Error| {
+                            RpcError::internal_error().with_message(e.to_string())
+                        })?,
+                    )
+                } else {
+                    None
+                };
+                let msg_value: Result<Value, Error> = crate::utils::with_gvl(|| {
+                    let ruby = Ruby::get().unwrap();
+                    let args = args_value.unwrap_or_else(|| ruby.qnil().as_value());
+                    proc.call::<_, Value>((args, wrapper.clone()))
+                });
+                wrapper.invalidate();
+                let json = msg_value
+                    .map_err(|e| RpcError::internal_error().with_message(e.to_string()))
+                    .and_then(|val| {
+                        crate::utils::with_gvl(|| {
+                            let ruby = Ruby::get().unwrap();
+                            ruby_value_to_json_value(&ruby, val)
+                        })
+                        .map_err(|e: Error| RpcError::internal_error().with_message(e.to_string()))
+                    })?;
+
+                let msgs: Vec<PromptMessage> = serde_json::from_value(json)
+                    .map_err(|e| RpcError::internal_error().with_message(e.to_string()))?;
+
+                Ok(GetPromptResult {
+                    description: entry.prompt.description.clone(),
+                    messages: msgs,
+                    meta: None,
+                })
+            }
+            None => Err(RpcError::invalid_params().with_message("Unknown prompt".to_string())),
+        }
+    }
     async fn handle_list_tools_request(
         &self,
         _request: ListToolsRequest,
@@ -234,7 +401,7 @@ impl ServerHandler for MyServerHandler {
             .map_err(|_| CallToolError::new(std::io::Error::other("tools mutex poisoned")))?;
         match map.get(request.tool_name()) {
             Some(entry) => {
-                let proc = entry.handler.0;
+                let proc = *entry.handler.0.as_ref();
                 let wrapper = RubyMcpServer::new(runtime);
                 let args_value = if let Some(map) = &request.params.arguments {
                     let json = JsonValue::Object(map.clone());
@@ -257,7 +424,9 @@ impl ServerHandler for MyServerHandler {
                 });
                 wrapper.invalidate();
                 match text_result {
-                    Ok(text) => Ok(CallToolResult::text_content(text, None)),
+                    Ok(text) => Ok(CallToolResult::text_content(vec![TextContent::new(
+                        text, None, None,
+                    )])),
                     Err(e) => Err(CallToolError::new(std::io::Error::other(e.to_string()))),
                 }
             }
@@ -277,10 +446,12 @@ pub fn start_server() -> String {
             let server_details = InitializeResult {
                 server_info: Implementation {
                     name: "Hello World MCP Server".to_string(),
+                    title: None,
                     version: "0.1.0".to_string(),
                 },
                 capabilities: ServerCapabilities {
                     tools: Some(ServerCapabilitiesTools { list_changed: None }),
+                    prompts: Some(ServerCapabilitiesPrompts { list_changed: None }),
                     ..Default::default()
                 },
                 meta: None,
@@ -347,8 +518,8 @@ mod tests {
         mcp_client::client_runtime,
         schema::{
             CallToolRequestParams, ClientCapabilities, CreateMessageRequest, CreateMessageResult,
-            Implementation, InitializeRequestParams, Role, RpcError, TextContent,
-            LATEST_PROTOCOL_VERSION,
+            GetPromptRequestParams, Implementation, InitializeRequestParams, Role, RpcError,
+            TextContent, LATEST_PROTOCOL_VERSION,
         },
         McpClient, StdioTransport, TransportOptions,
     };
@@ -363,7 +534,7 @@ mod tests {
             _runtime: &dyn McpClient,
         ) -> std::result::Result<CreateMessageResult, RpcError> {
             Ok(CreateMessageResult {
-                content: TextContent::new("hello".to_string(), None).into(),
+                content: TextContent::new("hello".to_string(), None, None).into(),
                 meta: None,
                 model: "test-model".to_string(),
                 role: Role::Assistant,
@@ -392,6 +563,7 @@ mod tests {
             capabilities: ClientCapabilities::default(),
             client_info: Implementation {
                 name: "test-client".into(),
+                title: None,
                 version: "0.1.0".into(),
             },
             protocol_version: LATEST_PROTOCOL_VERSION.into(),
@@ -434,6 +606,7 @@ mod tests {
             capabilities: ClientCapabilities::default(),
             client_info: Implementation {
                 name: "test-client".into(),
+                title: None,
                 version: "0.1.0".into(),
             },
             protocol_version: LATEST_PROTOCOL_VERSION.into(),
@@ -490,6 +663,7 @@ mod tests {
             capabilities: ClientCapabilities::default(),
             client_info: Implementation {
                 name: "test-client".into(),
+                title: None,
                 version: "0.1.0".into(),
             },
             protocol_version: LATEST_PROTOCOL_VERSION.into(),
@@ -544,6 +718,7 @@ mod tests {
             capabilities: ClientCapabilities::default(),
             client_info: Implementation {
                 name: "test-client".into(),
+                title: None,
                 version: "0.1.0".into(),
             },
             protocol_version: LATEST_PROTOCOL_VERSION.into(),
@@ -583,6 +758,7 @@ mod tests {
             capabilities: ClientCapabilities::default(),
             client_info: Implementation {
                 name: "test-client".into(),
+                title: None,
                 version: "0.1.0".into(),
             },
             protocol_version: LATEST_PROTOCOL_VERSION.into(),
@@ -605,4 +781,60 @@ mod tests {
 
         Ok(())
     }
+
+    #[tokio::test]
+    async fn prompts_feature_works() -> SdkResult<()> {
+        let transport = StdioTransport::create_with_server_launch(
+            "ruby",
+            vec![
+                "-I".into(),
+                "../../lib".into(),
+                "../../bin/mcp".into(),
+                "../../test/support/prompt_example.rb".into(),
+            ],
+            None,
+            TransportOptions::default(),
+        )?;
+
+        let client_details = InitializeRequestParams {
+            capabilities: ClientCapabilities::default(),
+            client_info: Implementation {
+                name: "test-client".into(),
+                title: None,
+                version: "0.1.0".into(),
+            },
+            protocol_version: LATEST_PROTOCOL_VERSION.into(),
+        };
+
+        let client = client_runtime::create_client(client_details, transport, TestClientHandler);
+
+        client.clone().start().await?;
+
+        // list prompts
+        let result = client.list_prompts(None).await?;
+        assert_eq!(result.prompts.len(), 1);
+        assert_eq!(result.prompts[0].name, "greeting");
+
+        // get prompt
+        let get_res = client
+            .get_prompt(GetPromptRequestParams {
+                name: "greeting".into(),
+                arguments: Some(
+                    [("name".to_string(), "Codex".to_string())]
+                        .into_iter()
+                        .collect(),
+                ),
+            })
+            .await?;
+        assert_eq!(get_res.messages.len(), 2);
+        let text = get_res.messages[0]
+            .content
+            .as_text_content()
+            .unwrap()
+            .text
+            .clone();
+        assert_eq!(text, "Hello Codex");
+
+        Ok(())
+    }
 }

data/lib/micro_mcp/prompt_registry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MicroMcp
+  module PromptRegistry
+    def self.register_prompt(name:, description: nil, arguments: nil, &block)
+      raise ArgumentError, "block required" unless block
+
+      MicroMcpNative.register_prompt(name, description, arguments, block)
+    end
+  end
+end

data/lib/micro_mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MicroMcp
-  VERSION = "0.1.4"
+  VERSION = "0.1.5.pre.1"
 end

data/lib/micro_mcp.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "micro_mcp/version"
-ruby_version = "#{RUBY_VERSION[/\d+\.\d+/]}"
+ruby_version = RUBY_VERSION[/\d+\.\d+/].to_s
 begin
   require_relative "micro_mcp/micro_mcp"
 rescue LoadError
@@ -13,6 +13,7 @@ rescue LoadError
 end
 require_relative "micro_mcp/schema"
 require_relative "micro_mcp/tool_registry"
+require_relative "micro_mcp/prompt_registry"
 require_relative "micro_mcp/server"
 require_relative "micro_mcp/runtime_helpers"
 require_relative "micro_mcp/validation_helpers"

data/scripts/build_platforms.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Script to build MicroMcp gem for multiple platforms using rb-sys-dock
+# This script calls rb-sys-dock for each platform with the specified Ruby versions
+
+PLATFORMS = %w[arm64-darwin x86_64-darwin x86_64-linux].freeze
+RUBY_VERSIONS = "3.2,3.3,3.4"
+
+def run_command(command)
+  puts "Running: #{command}"
+  success = system(command)
+  unless success
+    puts "ERROR: Command failed: #{command}"
+    exit 1
+  end
+  puts "✓ Command completed successfully\n"
+end
+
+def main
+  puts "Building MicroMcp gem for multiple platforms..."
+  puts "Platforms: #{PLATFORMS.join(", ")}"
+  puts "Ruby versions: #{RUBY_VERSIONS}"
+  puts
+
+  run_command("bundle exec rake build")
+
+  PLATFORMS.each do |platform|
+    puts "=" * 60
+    puts "Building for platform: #{platform}"
+    puts "=" * 60
+
+    command = "bundle exec rb-sys-dock --platform #{platform} --ruby-versions #{RUBY_VERSIONS} --build"
+    run_command(command)
+  end
+
+  puts "=" * 60
+  puts "All platforms built successfully! 🎉"
+  puts "=" * 60
+end
+
+if __FILE__ == $PROGRAM_NAME
+  main
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: micro_mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5.pre.1
 platform: ruby
 authors:
 - Erwin Kroon
@@ -50,12 +50,14 @@ files:
 - ext/micro_mcp/src/server.rs
 - ext/micro_mcp/src/utils.rs
 - lib/micro_mcp.rb
+- lib/micro_mcp/prompt_registry.rb
 - lib/micro_mcp/runtime_helpers.rb
 - lib/micro_mcp/schema.rb
 - lib/micro_mcp/server.rb
 - lib/micro_mcp/tool_registry.rb
 - lib/micro_mcp/validation_helpers.rb
 - lib/micro_mcp/version.rb
+- scripts/build_platforms.rb
 homepage: https://github.com/ekroon/micro_mcp
 licenses:
 - MIT
@@ -78,7 +80,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 3.3.11
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Simple gem for quick MCP server creation
 test_files: []