actionmcp 0.50.4 → 0.50.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b2ba13241313978eedd0619b256d320728391aa9afaa899b6299e65e54867358
-  data.tar.gz: 6bfc9173a29184139f7b9f0ceb543a56da3a557d3c633abae09e8bdc4c8465ee
+  metadata.gz: 334dbf522501eda848a1ab5d66378792b71acfd4177366de980e868be405d4dc
+  data.tar.gz: 1d29dd025817770f2389e99e9e11978e3ca813af5326d1c89ffef867267a82be
 SHA512:
-  metadata.gz: 77740b75ca3ec92fdb1eff6ecbfe1020113093899652b5cee0a56fbfbbe0c40c93e26f82803df732f33464e5cf532018901118cc6092d3e204001c490966b36f
-  data.tar.gz: c4ddcadeac684c84116e7f6fe04dff67b6f9749425bd4d5901471affacc2bfb1bb644e6a3d955718bd0ae6a788af0fd7981df621a2f15f4e372510b809190710
+  metadata.gz: 5c7ef8680677a244d909f482440aeed23033cfb9fbe4d109a14b474eefc4eec061436c22c39bd9b161f84c30cda9e707b9b79acf96bf54582e4fadef219ce5bd
+  data.tar.gz: b8f01db29cac834c91d75353dbeaa9d96c2cc5646c04eb8d17f625b63432e1304d0ae85a7a41a9f892020ab1d64a6c2fafe2cc2d28e017bc3184886da677d9f6

data/README.md

@@ -222,12 +222,31 @@ module Tron
     config.action_mcp.version = "1.2.3"                               # defaults to "0.0.1"
     config.action_mcp.logging_enabled = true                          # defaults to true
     config.action_mcp.logging_level = :info                           # defaults to :info, can be :debug, :info, :warn, :error, :fatal
+    config.action_mcp.vibed_ignore_version = false                    # defaults to false, set to true to ignore client protocol version mismatches
   end
 end
 ```
 
 For dynamic versioning, consider adding the `rails_app_version` gem.
 
+### Protocol Version Compatibility
+
+By default, ActionMCP requires clients to use the exact protocol version supported by the server (currently "2025-03-26"). If the client specifies a different version during initialization, the request will be rejected with an error.
+
+To support clients with incompatible protocol versions, you can enable the `vibed_ignore_version` option:
+
+```ruby
+# In config/application.rb or an initializer
+Rails.application.config.action_mcp.vibed_ignore_version = true
+```
+
+When enabled, the server will ignore protocol version mismatches from clients and always use the latest supported version. This is useful for:
+- Development environments with older client libraries
+- Supporting clients that cannot be easily updated
+- Situations where protocol differences are minor and known to be compatible
+
+> **Note:** Using `vibed_ignore_version = true` in production is not recommended as it may lead to unexpected behavior if clients rely on specific protocol features that differ between versions.
+
 ### PubSub Configuration
 
 ActionMCP uses a pub/sub system for real-time communication. You can choose between several adapters:
@@ -346,7 +365,7 @@ This ensures all thread pools are properly terminated and tasks are completed.
 
 ## Engine and Mounting
 
-**ActionMCP** runs as a standalone Rack application. It is **not** mounted in `routes.rb`.
+**ActionMCP** runs as a standalone Rack application. **Do not attempt to mount it in your application's `routes.rb`**—it is not designed to be mounted as an engine at a custom path. When you use `run ActionMCP::Engine` in your `mcp.ru`, the MCP endpoint is always available at the root path (`/`).
 
 ### Installing the Configuration Generator
 
@@ -367,17 +386,69 @@ This will create `config/mcp.yml` with example configurations for all environmen
 # Load the full Rails environment to access models, DB, Redis, etc.
 require_relative "config/environment"
 
-ActionMCP.configure do |config|
-  config.mcp_endpoint_path = "/mcp"
-end
-
+# No need to set a custom endpoint path. The MCP endpoint is always served at root ("/")
+# when using ActionMCP::Engine directly.
 run ActionMCP::Engine
 ```
 ### 2. Start the server
 ```bash
-bin/rails s -c mcp.ru -p 6277 -P tmp/pids/mcp.pid
+bin/rails s -c mcp.ru -p 62770 -P tmp/pids/mcps0.pid
 ```
 
+## Production Deployment of MCPS0
+
+In production, **MCPS0** (the MCP server) is a standard Rack application. You can run it using any Rack-compatible server (such as Puma, Unicorn, or Passenger). 
+
+> **For best performance and concurrency, it is highly recommended to use a modern, synchronous server like [Falcon](https://github.com/socketry/falcon)**. Falcon is optimized for streaming and concurrent workloads, making it ideal for MCP servers. You can still use Puma, Unicorn, or Passenger, but Falcon will generally provide superior throughput and responsiveness for real-time and streaming use cases.
+
+You have two main options for exposing the server:
+
+### 1. Dedicated Port
+
+Run MCPS0 on its own TCP port (commonly `62770`):
+
+**With Falcon:**
+```bash
+bundle exec falcon serve --bind http://0.0.0.0:62770 mcp.ru
+```
+
+**With Puma:**
+```bash
+bundle exec rails s -c mcp.ru -p 62770
+```
+
+Then, use your web server (Nginx, Apache, etc.) to reverse proxy requests to this port.
+
+### 2. Unix Socket
+
+Alternatively, you can run MCPS0 on a Unix socket for improved performance and security (especially when the web server and app server are on the same machine):
+
+**With Falcon:**
+```bash
+bundle exec falcon serve --bind unix:/tmp/mcps0.sock mcp.ru
+```
+
+**With Puma:**
+```bash
+bundle exec puma -C config/puma.rb -b unix:///tmp/mcps0.sock -c mcp.ru
+```
+
+And configure your web server to proxy to the socket:
+
+```nginx
+location /mcp/ {
+  proxy_pass http://unix:/tmp/mcps0.sock:;
+  proxy_set_header Host $host;
+  proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+}
+```
+
+**Key Points:**
+- MCPS0 is a standalone Rack app—run it separately from your main Rails server.
+- You can expose it via a TCP port (e.g., 62770) or a Unix socket.
+- Use a reverse proxy (Nginx, Apache, etc.) to route requests to MCPS0 as needed.
+- This separation ensures reliability and scalability for both your main app and MCP services.
+
 ## Generators
 
 ActionMCP includes Rails generators to help you quickly set up your MCP server components.

data/app/controllers/action_mcp/application_controller.rb

@@ -207,8 +207,12 @@ module ActionMCP
       session_id = extract_session_id
       if session_id
         session = Session.find_by(id: session_id)
-        if session && session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
-          session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
+        if session
+          if ActionMCP.configuration.vibed_ignore_version
+            session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION) if session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
+          elsif session.protocol_version != self.class::REQUIRED_PROTOCOL_VERSION
+            session.update!(protocol_version: self.class::REQUIRED_PROTOCOL_VERSION)
+          end
         end
         session
       else

data/app/models/action_mcp/session.rb

@@ -64,7 +64,7 @@ module ActionMCP
     before_create :set_server_info, if: -> { role == "server" }
     before_create :set_server_capabilities, if: -> { role == "server" }
 
-    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true
+    validates :protocol_version, inclusion: { in: SUPPORTED_VERSIONS }, allow_nil: true, unless: -> { ActionMCP.configuration.vibed_ignore_version }
 
     def close!
       dummy_callback = ->(*) { } # this callback seem broken
@@ -102,6 +102,8 @@ module ActionMCP
     end
 
     def set_protocol_version(version)
+      # If vibed_ignore_version is true, always use the latest supported version
+      version = PROTOCOL_VERSION if ActionMCP.configuration.vibed_ignore_version
       update(protocol_version: version)
     end
 

data/lib/action_mcp/client/blueprint.rb

@@ -89,18 +89,19 @@ module ActionMCP
 
       # Internal Blueprint class to represent individual URI templates
       class ResourceTemplate
-        attr_reader :pattern, :name, :description, :mime_type
+        attr_reader :pattern, :name, :description, :mime_type, :annotations
 
         # Initialize a new ResourceTemplate instance
         #
         # @param data [Hash] ResourceTemplate definition hash containing uriTemplate, name, description,
-        #   and optionally mimeType
+        #   and optionally mimeType, and annotations
         def initialize(data)
           @pattern = data["uriTemplate"]
           @name = data["name"]
           @description = data["description"]
           @mime_type = data["mimeType"]
           @variable_pattern = /{([^}]+)}/
+          @annotations = data["annotations"] || {}
         end
 
         # Extract variable names from the template pattern
@@ -152,7 +153,8 @@ module ActionMCP
             "uriTemplate" => @pattern,
             "name" => @name,
             "description" => @description,
-            "mimeType" => @mime_type
+            "mimeType" => @mime_type,
+            "annotations" => @annotations
           }
         end
       end

data/lib/action_mcp/client/catalog.rb

@@ -103,7 +103,7 @@ module ActionMCP
 
       # Internal Resource class to represent individual resources
       class Resource
-        attr_reader :uri, :name, :description, :mime_type
+        attr_reader :uri, :name, :description, :mime_type, :annotations
 
         # Initialize a new Resource instance
         #
@@ -113,6 +113,7 @@ module ActionMCP
           @name = data["name"]
           @description = data["description"]
           @mime_type = data["mimeType"]
+          @annotations = data["annotations"] || {}
         end
 
         # Get the file extension from the resource name
@@ -153,7 +154,8 @@ module ActionMCP
             "uri" => @uri,
             "name" => @name,
             "description" => @description,
-            "mimeType" => @mime_type
+            "mimeType" => @mime_type,
+            "annotations" => @annotations
           }
         end
       end

data/lib/action_mcp/client/collection.rb

@@ -6,18 +6,28 @@ module ActionMCP
     class Collection
       include RequestTimeouts
 
-      attr_reader :client, :loaded
+      attr_reader :client, :loaded, :next_cursor, :total
 
       def initialize(items, client, silence_sql: true)
         @collection_data = items || []
         @client = client
         @loaded = !@collection_data.empty?
         @silence_sql = silence_sql
+        @next_cursor = nil
+        @total = items&.size || 0
       end
 
-      def all
-        silence_logs { load_items unless @loaded }
-        @collection_data
+      def all(limit: nil)
+        if limit
+          # If a limit is provided, use pagination
+          result = []
+          each_page(limit: limit) { |page| result.concat(page) }
+          result
+        else
+          # Otherwise, maintain the old behavior
+          silence_logs { load_items unless @loaded }
+          @collection_data
+        end
       end
 
       def all!(timeout: DEFAULT_TIMEOUT)
@@ -25,6 +35,49 @@ module ActionMCP
         @collection_data
       end
 
+      # Fetch a single page of results
+      #
+      # @param cursor [String, nil] Optional cursor for pagination
+      # @param limit [Integer, nil] Optional limit for page size
+      # @return [Array<Object>] The page of items
+      def page(cursor: nil, limit: nil)
+        silence_logs { load_page(cursor: cursor, limit: limit) }
+        @collection_data
+      end
+
+      # Check if there are more pages available
+      #
+      # @return [Boolean] true if there are more pages to fetch
+      def has_more_pages?
+        !@next_cursor.nil?
+      end
+
+      # Fetch the next page of results
+      #
+      # @param limit [Integer, nil] Optional limit for page size
+      # @return [Array<Object>] The next page of items, or empty array if no more pages
+      def next_page(limit: nil)
+        return [] unless has_more_pages?
+        page(cursor: @next_cursor, limit: limit)
+      end
+
+      # Iterate through all pages of results
+      #
+      # @param limit [Integer, nil] Optional limit for page size
+      # @yield [page] Block to process each page
+      # @yieldparam page [Array<Object>] A page of items
+      def each_page(limit: nil, &block)
+        return unless block_given?
+
+        current_page = page(limit: limit)
+        yield current_page
+
+        while has_more_pages?
+          current_page = next_page(limit: limit)
+          yield current_page unless current_page.empty?
+        end
+      end
+
       # Filter items based on a given block
       #
       # @yield [item] Block that determines whether to include an item
@@ -63,6 +116,29 @@ module ActionMCP
         load_with_timeout(@load_method, force: force, timeout: timeout)
       end
 
+      def load_page(cursor: nil, limit: nil, timeout: DEFAULT_TIMEOUT)
+        # Make sure @load_method is defined in the subclass
+        raise NotImplementedError, "Subclass must define @load_method" unless defined?(@load_method)
+
+        # Use the RequestTimeouts module to handle the request with pagination params
+        params = {}
+        params[:cursor] = cursor if cursor
+        params[:limit] = limit if limit
+
+        request_id = client.send(@load_method, params)
+
+        start_time = Time.now
+        while !@loaded && (Time.now - start_time) < timeout
+          sleep(0.1)
+        end
+
+        # Update @loaded status even if we timed out
+        @loaded = true
+
+        # Return the loaded data
+        @collection_data
+      end
+
       private
 
       def silence_logs

data/lib/action_mcp/client/json_rpc_handler.rb

@@ -85,15 +85,23 @@ module ActionMCP
         case request.rpc_method
         when "tools/list"
           client.toolbox.tools = result["tools"]
+          client.toolbox.instance_variable_set(:@next_cursor, result["nextCursor"])
+          client.toolbox.instance_variable_set(:@total, result["tools"]&.size || 0)
           return true
         when "prompts/list"
           client.prompt_book.prompts = result["prompts"]
+          client.prompt_book.instance_variable_set(:@next_cursor, result["nextCursor"])
+          client.prompt_book.instance_variable_set(:@total, result["prompts"]&.size || 0)
           return true
         when "resources/list"
           client.catalog.resources = result["resources"]
+          client.catalog.instance_variable_set(:@next_cursor, result["nextCursor"])
+          client.catalog.instance_variable_set(:@total, result["resources"]&.size || 0)
           return true
         when "resources/templates/list"
           client.blueprint.templates = result["resourceTemplates"]
+          client.blueprint.instance_variable_set(:@next_cursor, result["nextCursor"])
+          client.blueprint.instance_variable_set(:@total, result["resourceTemplates"]&.size || 0)
           return true
         end
 

data/lib/action_mcp/client/prompts.rb

@@ -4,12 +4,21 @@ module ActionMCP
   module Client
     module Prompts
       # List all available prompts from the server
+      # @param params [Hash] Optional parameters for pagination
+      # @option params [String] :cursor Pagination cursor for fetching next page
+      # @option params [Integer] :limit Maximum number of items to return
       # @return [String] Request ID for tracking the request
-      def list_prompts
+      def list_prompts(params = {})
         request_id = SecureRandom.uuid_v7
 
-        # Send request
-        send_jsonrpc_request("prompts/list", id: request_id)
+        # Send request with pagination parameters if provided
+        request_params = {}
+        request_params[:cursor] = params[:cursor] if params[:cursor]
+        request_params[:limit] = params[:limit] if params[:limit]
+
+        send_jsonrpc_request("prompts/list",
+                             params: request_params.empty? ? nil : request_params,
+                             id: request_id)
 
         # Return request ID for tracking the request
         request_id

data/lib/action_mcp/client/resources.rb

@@ -4,24 +4,42 @@ module ActionMCP
   module Client
     module Resources
       # List all available resources from the server
+      # @param params [Hash] Optional parameters for pagination
+      # @option params [String] :cursor Pagination cursor for fetching next page
+      # @option params [Integer] :limit Maximum number of items to return
       # @return [String] Request ID for tracking the request
-      def list_resources
+      def list_resources(params = {})
         request_id = SecureRandom.uuid_v7
 
-        # Send request
-        send_jsonrpc_request("resources/list", id: request_id)
+        # Send request with pagination parameters if provided
+        request_params = {}
+        request_params[:cursor] = params[:cursor] if params[:cursor]
+        request_params[:limit] = params[:limit] if params[:limit]
+
+        send_jsonrpc_request("resources/list",
+                             params: request_params.empty? ? nil : request_params,
+                             id: request_id)
 
         # Return request ID for tracking the request
         request_id
       end
 
       # List resource templates from the server
+      # @param params [Hash] Optional parameters for pagination
+      # @option params [String] :cursor Pagination cursor for fetching next page
+      # @option params [Integer] :limit Maximum number of items to return
       # @return [String] Request ID for tracking the request
-      def list_resource_templates
+      def list_resource_templates(params = {})
         request_id = SecureRandom.uuid_v7
 
-        # Send request
-        send_jsonrpc_request("resources/templates/list", id: request_id)
+        # Send request with pagination parameters if provided
+        request_params = {}
+        request_params[:cursor] = params[:cursor] if params[:cursor]
+        request_params[:limit] = params[:limit] if params[:limit]
+
+        send_jsonrpc_request("resources/templates/list",
+                             params: request_params.empty? ? nil : request_params,
+                             id: request_id)
 
         # Return request ID for tracking the request
         request_id

data/lib/action_mcp/client/toolbox.rb

@@ -104,15 +104,17 @@ module ActionMCP
 
       # Internal Tool class to represent individual tools
       class Tool
-        attr_reader :name, :description, :input_schema
+        attr_reader :name, :description, :input_schema, :annotations
 
         # Initialize a new Tool instance
         #
         # @param data [Hash] Tool definition hash containing name, description, and inputSchema
+        #  and optionally annotations
         def initialize(data)
           @name = data["name"]
           @description = data["description"]
           @input_schema = data["inputSchema"] || {}
+          @annotations = data["annotations"] || {}
         end
 
         # Get all required properties for this tool
@@ -160,7 +162,8 @@ module ActionMCP
           {
             "name" => @name,
             "description" => @description,
-            "inputSchema" => @input_schema
+            "inputSchema" => @input_schema,
+            "annotations" => @annotations
           }
         end
 
@@ -171,7 +174,8 @@ module ActionMCP
           {
             "name" => @name,
             "description" => @description,
-            "input_schema" => @input_schema.transform_keys { |k| k == "inputSchema" ? "input_schema" : k }
+            "input_schema" => @input_schema.transform_keys { |k| k == "inputSchema" ? "input_schema" : k },
+            "annotations" => @annotations
           }
         end
 
@@ -184,7 +188,8 @@ module ActionMCP
             "function" => {
               "name" => @name,
               "description" => @description,
-              "parameters" => @input_schema
+              "parameters" => @input_schema,
+              "annotations" => @annotations
             }
           }
         end

data/lib/action_mcp/client/tools.rb

@@ -4,12 +4,21 @@ module ActionMCP
   module Client
     module Tools
       # List all available tools from the server
+      # @param params [Hash] Optional parameters for pagination
+      # @option params [String] :cursor Pagination cursor for fetching next page
+      # @option params [Integer] :limit Maximum number of items to return
       # @return [String] Request ID for tracking the request
-      def list_tools
+      def list_tools(params = {})
         request_id = SecureRandom.uuid_v7
 
-        # Send request
-        send_jsonrpc_request("tools/list", id: request_id)
+        # Send request with pagination parameters if provided
+        request_params = {}
+        request_params[:cursor] = params[:cursor] if params[:cursor]
+        request_params[:limit] = params[:limit] if params[:limit]
+
+        send_jsonrpc_request("tools/list",
+                             params: request_params.empty? ? nil : request_params,
+                             id: request_id)
 
         # Return request ID for timeout tracking
         request_id

data/lib/action_mcp/configuration.rb

@@ -26,6 +26,8 @@ module ActionMCP
                   :sse_heartbeat_interval,
                   :post_response_preference, # :json or :sse
                   :protocol_version,
+                  # --- VibedIgnoreVersion Option ---
+                  :vibed_ignore_version,
                   # --- SSE Resumability Options ---
                   :enable_sse_resumability,
                   :sse_event_retention_period,
@@ -38,10 +40,10 @@ module ActionMCP
       @resources_subscribe = false
       @active_profile = :primary
       @profiles = default_profiles
-
       @sse_heartbeat_interval = 30
       @post_response_preference = :json
       @protocol_version = "2025-03-26"
+      @vibed_ignore_version = false
 
       # Resumability defaults
       @enable_sse_resumability = true

data/lib/action_mcp/content/audio.rb

@@ -12,8 +12,9 @@ module ActionMCP
       #
       # @param data [String] The base64-encoded audio data.
       # @param mime_type [String] The MIME type of the audio data.
-      def initialize(data, mime_type)
-        super("audio")
+      # @param annotations [Hash, nil] Optional annotations for the audio content.
+      def initialize(data, mime_type, annotations: nil)
+        super("audio", annotations: annotations)
         @data = data
         @mime_type = mime_type
       end

data/lib/action_mcp/content/base.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Content
+    # Base class for all content types, supporting annotations.
+    class Base
+      attr_reader :type, :annotations
+
+      # Initializes a new content base.
+      #
+      # @param type [String] The type of the content (e.g., "text", "image", etc.)
+      # @param annotations [Hash, nil] Optional annotations for the content.
+      def initialize(type, annotations: nil)
+        @type = type
+        @annotations = annotations
+      end
+
+      # Returns a hash representation of the base content.
+      #
+      # @return [Hash] The hash representation of the base content.
+      def to_h
+        h = { type: @type }
+        h[:annotations] = @annotations if @annotations
+        h
+      end
+    end
+  end
+end

data/lib/action_mcp/content/image.rb

@@ -12,8 +12,9 @@ module ActionMCP
       #
       # @param data [String] The base64-encoded image data.
       # @param mime_type [String] The MIME type of the image data.
-      def initialize(data, mime_type)
-        super("image")
+      # @param annotations [Hash, nil] Optional annotations for the image content.
+      def initialize(data, mime_type, annotations: nil)
+        super("image", annotations: annotations)
         @data = data
         @mime_type = mime_type
       end
@@ -22,7 +23,8 @@ module ActionMCP
       #
       # @return [Hash] The hash representation of the image content.
       def to_h
-        super.merge(data: @data, mimeType: @mime_type)
+        h = super.merge(data: @data, mimeType: @mime_type)
+        h
       end
     end
   end

data/lib/action_mcp/content/resource.rb

@@ -9,7 +9,7 @@ module ActionMCP
       # @return [String] The MIME type of the resource.
       # @return [String, nil] The text content of the resource (optional).
       # @return [String, nil] The base64-encoded blob of the resource (optional).
-      attr_reader :uri, :mime_type, :text, :blob
+      attr_reader :uri, :mime_type, :text, :blob, :annotations
 
       # Initializes a new Resource content.
       #
@@ -17,22 +17,23 @@ module ActionMCP
       # @param mime_type [String] The MIME type of the resource.
       # @param text [String, nil] The text content of the resource (optional).
       # @param blob [String, nil] The base64-encoded blob of the resource (optional).
-      def initialize(uri, mime_type = "text/plain", text: nil, blob: nil)
-        super("resource")
+      # @param annotations [Hash, nil] Optional annotations for the resource.
+      def initialize(uri, mime_type = "text/plain", text: nil, blob: nil, annotations: nil)
+        super("resource", annotations: annotations)
         @uri = uri
         @mime_type = mime_type
         @text = text
         @blob = blob
+        @annotations = annotations
       end
 
       # Returns a hash representation of the resource content.
       #
       # @return [Hash] The hash representation of the resource content.
       def to_h
-        resource_data = { uri: @uri, mimeType: @mime_type }
+        resource_data = super.merge(uri: @uri, mimeType: @mime_type)
         resource_data[:text] = @text if @text
         resource_data[:blob] = @blob if @blob
-
         resource_data
       end
     end

data/lib/action_mcp/content/text.rb

@@ -10,8 +10,9 @@ module ActionMCP
       # Initializes a new Text content.
       #
       # @param text [String] The text content.
-      def initialize(text)
-        super("text")
+      # @param annotations [Hash, nil] Optional annotations for the content.
+      def initialize(text, annotations: nil)
+        super("text", annotations: annotations)
         @text = text.to_s
       end
 

data/lib/action_mcp/content.rb

@@ -6,20 +6,25 @@ module ActionMCP
     # Base class for MCP content items.
     class Base
       # @return [Symbol] The type of content.
-      attr_reader :type
+      # @return [Hash, nil] Optional annotations for the content.
+      attr_reader :type, :annotations
 
       # Initializes a new content item.
       #
       # @param type [Symbol] The type of content.
-      def initialize(type)
+      # @param annotations [Hash, nil] Optional annotations for the content.
+      def initialize(type, annotations: nil)
         @type = type
+        @annotations = annotations
       end
 
       # Returns a hash representation of the content.
       #
       # @return [Hash] The hash representation.
       def to_h
-        { type: @type }
+        h = { type: @type }
+        h[:annotations] = @annotations if @annotations
+        h
       end
 
       # Returns a JSON representation of the content.

data/lib/action_mcp/renderable.rb

@@ -22,13 +22,13 @@ module ActionMCP
     #
     def render(text: nil, audio: nil, image: nil, resource: nil, mime_type: nil, blob: nil)
       if text
-        Content::Text.new(text)
+        Content::Text.new(text, annotations: nil)
       elsif audio && mime_type
-        Content::Audio.new(audio, mime_type)
+        Content::Audio.new(audio, mime_type, annotations: nil)
       elsif image && mime_type
-        Content::Image.new(image, mime_type)
+        Content::Image.new(image, mime_type, annotations: nil)
       elsif resource && mime_type
-        Content::Resource.new(resource, mime_type, text: text, blob: blob)
+        Content::Resource.new(resource, mime_type, text: text, blob: blob, annotations: nil)
       else
         raise ArgumentError, "No content to render"
       end

data/lib/action_mcp/server/capabilities.rb

@@ -20,7 +20,7 @@ module ActionMCP
                    payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'protocolVersion'" } } }
         end
         # Check if the protocol version is supported
-        unless ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
+        unless ActionMCP.configuration.vibed_ignore_version || ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
           error_data = {
             supported: ActionMCP::SUPPORTED_VERSIONS,
             requested: client_protocol_version
@@ -53,9 +53,15 @@ module ActionMCP
                    payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_603, message: "Failed to initialize session" } } }
         end
 
-        # Send the successful response with the protocol version the client requested
+        # Send the successful response with the correct protocol version
         capabilities_payload = session.server_capabilities_payload
-        capabilities_payload[:protocolVersion] = client_protocol_version # Use the client's requested version
+        # If vibed_ignore_version is true, always use the latest supported version in the response
+        # Otherwise, use the client's requested version
+        if ActionMCP.configuration.vibed_ignore_version
+          capabilities_payload[:protocolVersion] = PROTOCOL_VERSION
+        else
+          capabilities_payload[:protocolVersion] = client_protocol_version
+        end
 
         send_jsonrpc_response(request_id, result: capabilities_payload)
         { type: :responses, id: request_id, payload: { jsonrpc: "2.0", id: request_id, result: capabilities_payload } }

data/lib/action_mcp/server/sampling_request.rb

@@ -92,7 +92,7 @@ module ActionMCP
         if content.is_a?(Content::Base) || (content.respond_to?(:to_h) && !content.is_a?(Hash))
           @messages << { role: role, content: content.to_h }
         else
-          content = Content::Text.new(content).to_h if content.is_a?(String)
+          content = Content::Text.new(content, annotations: nil).to_h if content.is_a?(String)
           @messages << { role: role, content: content }
         end
       end

data/lib/action_mcp/version.rb

@@ -2,7 +2,7 @@
 
 require_relative "gem_version"
 module ActionMCP
-  VERSION = "0.50.4"
+  VERSION = "0.50.5"
 
   class << self
     alias version gem_version

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.4
+  version: 0.50.5
 platform: ruby
 authors:
 - Abdelkader Boudih
+autorequire:
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2025-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -143,6 +144,7 @@ files:
 - lib/action_mcp/console_detector.rb
 - lib/action_mcp/content.rb
 - lib/action_mcp/content/audio.rb
+- lib/action_mcp/content/base.rb
 - lib/action_mcp/content/image.rb
 - lib/action_mcp/content/resource.rb
 - lib/action_mcp/content/text.rb
@@ -213,6 +215,7 @@ metadata:
   source_code_uri: https://github.com/seuros/action_mcp
   changelog_uri: https://github.com/seuros/action_mcp/blob/master/CHANGELOG.md
   rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -227,7 +230,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Provides essential tooling for building Model Context Protocol (MCP) capable
   servers