actionmcp 0.104.1 → 0.106.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6cfb5ce2385d840e5a70a47707ff2a684b2b1129ab19e55869832cff57286619
-  data.tar.gz: aedeccd60db4263d29eee4da2d051d5910978c50951765dc7ec6b83cb1c2c6c9
+  metadata.gz: 277441f068f32aec18d72c2db1df9990ea805fa4f32c0ca1447ff368740c6644
+  data.tar.gz: 8572d668e2f38444a9c6dd5162599901122e2eb03676f5334b32b359c4e29a34
 SHA512:
-  metadata.gz: c6fe8f1b667633f25e566df67f6c8da36d652ef993eb568b8c73b23fd46bb85c3c096560b91c62056bc00325fd1daa23aba789d960697007b5d28881ce02d292
-  data.tar.gz: dc9a41f5f340b09e11c551d64857239501341602731136686f508e3f8fa22558e9f10392941887c20f2ae6cbd7f1174d87fa4b371142e90bcbd3e0bfe8b90353
+  metadata.gz: cf603eaffd1eca7723b2c4cc0e47e1342c4adb31e51be395a072178550f90595aa9aac1eeb53298abf609c2bbc088a796c221150abe960f5b99d15a17d1fbec5
+  data.tar.gz: 418c3fa2ef01218372b6477f5df63e0d50fd063e21af6b883d391fc5dbb78e1fbe8fa1a73e41214d88b2d0d2a118ce5dd602dcccee6c8015c99cff33b99dcde9

data/README.md

@@ -337,33 +337,50 @@ Poll task status with `tasks/get` or fetch the result when finished with `tasks/
 `ActionMCP::ResourceTemplate` facilitates the creation of URI templates for dynamic resources that LLMs can access.
 This allows models to request specific data using parameterized URIs.
 
+Templates support two MCP resource surfaces:
+- **`resources/templates/list`** — parameterized URI patterns (existing behavior)
+- **`resources/list`** — concrete resources with known URIs (via `self.list`)
+
+> **Note:** Not all MCP clients support both resource endpoints. Claude Code (as of v2.1.50) only calls `resources/list`, and Codex stubs resource methods entirely. Implement `self.list` on your templates to ensure resources are visible to all clients. Crush and VS Code support both endpoints.
+
 **Example:**
 
 ```ruby
-
 class ProductResourceTemplate < ApplicationMCPResTemplate
   uri_template "product/{id}"
   description "Access product information by ID"
+  mime_type "application/json"
 
   parameter :id, description: "Product identifier", required: true
 
   validates :id, format: { with: /\A\d+\z/, message: "must be numeric" }
 
+  # Optional: enumerate concrete resources for resources/list
+  def self.list(session: nil)
+    Product.limit(50).map do |product|
+      build_resource(
+        uri: "product/#{product.id}",
+        name: product.name,
+        title: "Product ##{product.id}"
+      )
+    end
+  end
+
+  # Resolve a specific resource for resources/read
   def resolve
     product = Product.find_by(id: id)
     return unless product
-    ActionMCP::Resource.new(
-      uri: "ecommerce://products/#{product_id}",
-      name: "Product #{product_id}",
-      description: "Product information for product #{product_id}",
-      mime_type: "application/json",
-      size: product.to_json.length
+
+    ActionMCP::Content::Resource.new(
+      "product/#{id}",
+      mime_type,
+      text: product.to_json
     )
   end
 end
 ```
 
-# Example of callbacks:
+**Callbacks:**
 
 ```ruby
 before_resolve do |template|
@@ -376,21 +393,13 @@ end
 
 around_resolve do |template, block|
   start_time = Time.current
-  # Starting resolution for product: #{template.product_id}
-
   resource = block.call
-
-  if resource
-    # Product #{template.product_id} resolved successfully in #{Time.current - start_time}s
-  else
-    # Product #{template.product_id} not found
-  end
-
   resource
 end
 ```
 
 Resource templates are automatically registered and used when LLMs request resources matching their patterns.
+See [RESOURCE_TEMPLATES.md](RESOURCE_TEMPLATES.md) for the full API reference including pagination, deduplication, and read contract details.
 
 ## 📚 Documentation
 
@@ -763,7 +772,7 @@ This ensures all thread pools are properly terminated and tasks are completed.
 
 ## Engine and Mounting
 
-**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 (`/`).
+**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 available at the root path (`/`) by default and can be configured via `config.action_mcp.base_path`.
 
 ### Installing ActionMCP
 
@@ -916,7 +925,7 @@ In production, **MCPS0** (the MCP server) is a standard Rack application. You ca
 
 > **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:
+You have several main options for exposing the server:
 
 ### 1. Dedicated Port
 
@@ -932,6 +941,11 @@ bundle exec falcon serve --bind http://0.0.0.0:62770 --config mcp.ru
 bundle exec rails s -c mcp.ru -p 62770
 ```
 
+**With Passenger:**
+```bash
+passenger start --rackup mcp.ru --port 62770
+```
+
 Then, use your web server (Nginx, Apache, etc.) to reverse proxy requests to this port.
 
 ### 2. Unix Socket
@@ -948,6 +962,11 @@ bundle exec falcon serve --bind unix:/tmp/mcps0.sock mcp.ru
 bundle exec puma -C config/puma.rb -b unix:///tmp/mcps0.sock -c mcp.ru
 ```
 
+**With Passenger:**
+```bash
+passenger start --rackup mcp.ru --socket /tmp/mcps0.sock
+```
+
 And configure your web server to proxy to the socket:
 
 ```nginx
@@ -958,6 +977,30 @@ location /mcp/ {
 }
 ```
 
+### 3. Nginx With Passenger
+
+You can run both the main app and the MCP app using Passenger processes within Nginx.
+
+```nginx
+location / {
+  root /path/to/current/public;
+  passenger_app_root /path/to/current;
+  passenger_enabled on;
+
+   # ... additional configuration for the main Rails app
+}
+
+location ~* ^/mcp {
+  root /path/to/current/public;
+  passenger_app_root /path/to/current;
+  passenger_enabled on;
+  passenger_startup_file mcp.ru;
+  passenger_app_group_name mcp;
+}
+```
+
+You must set the `config.action_mcp.base_path` to match the above Nginx configuration, i.e. `config.action_mcp.base_path = '/mcp'`.
+
 **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.

data/config/routes.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 ActionMCP::Engine.routes.draw do
-  get "/up", to: "/rails/health#show", as: :action_mcp_health_check
+  get "#{ActionMCP.configuration.base_path}}/up", to: "/rails/health#show", as: :action_mcp_health_check
 
   # MCP 2025-03-26 Spec routes
-  get "/", to: "application#show", as: :mcp_get
-  post "/", to: "application#create", as: :mcp_post
-  delete "/", to: "application#destroy", as: :mcp_delete
+  get ActionMCP.configuration.base_path, to: "application#show", as: :mcp_get
+  post ActionMCP.configuration.base_path, to: "application#create", as: :mcp_post
+  delete ActionMCP.configuration.base_path, to: "application#destroy", as: :mcp_delete
 end

data/lib/action_mcp/configuration.rb

@@ -51,7 +51,9 @@ module ActionMCP
                   # --- Schema Validation Options ---
                   :validate_structured_content,
                   # --- Allowed identity keys for gateway ---
-                  :allowed_identity_keys
+                  :allowed_identity_keys,
+                  # --- JSON-RPC Path ---
+                  :base_path
 
     def initialize
       @logging_enabled = false
@@ -91,6 +93,9 @@ module ActionMCP
       # and unauthorized attribute assignment. Extend this list if you use custom
       # identifier names in your GatewayIdentifier implementations.
       @allowed_identity_keys = %w[user api_key jwt bearer token account session].freeze
+
+      # Path for JSON-RPC endpoint
+      @base_path = "/"
     end
 
     def name

data/lib/action_mcp/engine.rb

@@ -45,7 +45,9 @@ module ActionMCP
       ActionMCP.configuration.eager_load_if_needed
     end
 
-    config.middleware.use JSONRPC_Rails::Middleware::Validator, [ "/" ]
+    initializer "action_mcp.insert_middleware" do |app|
+      config.middleware.use JSONRPC_Rails::Middleware::Validator, [ ActionMCP.configuration.base_path ].compact.freeze
+    end
 
     # Load MCP profiles during initialization
     initializer "action_mcp.load_profiles" do

data/lib/action_mcp/resource.rb

@@ -2,21 +2,56 @@
 
 module ActionMCP
   # Represents a resource with its metadata.
-  Resource = Data.define(:uri, :name, :description, :mime_type, :size) do
+  # Used by resources/list to describe concrete resources.
+  class Resource
+    attr_reader :uri, :name, :title, :description, :mime_type, :size, :annotations
+
+    # @param uri [String] The URI of the resource
+    # @param name [String] Display name of the resource
+    # @param title [String, nil] Human-readable title
+    # @param description [String, nil] Description of the resource
+    # @param mime_type [String, nil] MIME type of the resource content
+    # @param size [Integer, nil] Size of the resource in bytes
+    # @param annotations [Hash, nil] Optional annotations
+    def initialize(uri:, name:, title: nil, description: nil, mime_type: nil, size: nil, annotations: nil)
+      @uri = uri
+      @name = name
+      @title = title
+      @description = description
+      @mime_type = mime_type
+      @size = size
+      @annotations = annotations
+      freeze
+    end
+
     # Convert the resource to a hash with the keys expected by MCP.
     # Note: The key for mime_type is converted to 'mimeType' as specified.
     #
     # @return [Hash] A hash representation of the resource.
     def to_h
       hash = { uri: uri, name: name }
+      hash[:title] = title if title
       hash[:description] = description if description
-      hash[:mimeType]   = mime_type if mime_type
-      hash[:size]       = size if size
+      hash[:mimeType] = mime_type if mime_type
+      hash[:size] = size if size
+      hash[:annotations] = annotations if annotations
       hash
     end
 
     def to_json(*)
       MultiJson.dump(to_h, *)
     end
+
+    def ==(other)
+      other.is_a?(Resource) && uri == other.uri && name == other.name &&
+        title == other.title && description == other.description &&
+        mime_type == other.mime_type && size == other.size &&
+        annotations == other.annotations
+    end
+    alias eql? ==
+
+    def hash
+      [ uri, name, title, description, mime_type, size, annotations ].hash
+    end
   end
 end

data/lib/action_mcp/resource_response.rb

@@ -73,12 +73,22 @@ module ActionMCP
     end
 
     def mark_as_not_found!(uri)
-      # Use method_not_found for resource not found (closest standard JSON-RPC error)
-      mark_as_error!(
-        :method_not_found, # -32601 - closest standard error for "not found"
-        message: "Resource not found",
-        data: { uri: uri }
-      )
+      @is_error = true
+      @symbol = nil
+      @error_message = "Resource not found"
+      @error_data = { uri: uri }
+      self
+    end
+
+    # Override to_h to use -32002 for resource not found (consistent with send_resource_read)
+    def to_h(_options = nil)
+      if @is_error && @symbol.nil?
+        { code: -32_002, message: @error_message, data: @error_data }
+      elsif @is_error
+        JSON_RPC::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
+      else
+        build_success_hash
+      end
     end
 
     # Implementation of build_success_hash for ResourceResponse

data/lib/action_mcp/resource_template.rb

@@ -13,7 +13,10 @@ module ActionMCP
 
     # Track all registered templates
     @registered_templates = []
-    attr_reader :execution_context, :description, :uri_template, :mime_type
+    attr_reader :execution_context
+
+    # Delegate to class-level DSL values so instances see template metadata.
+    delegate :description, :uri_template, :mime_type, to: :class
 
     class << self
       attr_reader :registered_templates, :description, :uri_template,
@@ -128,6 +131,60 @@ module ActionMCP
         @capability_name ||= name.demodulize.underscore.sub(/_template$/, "")
       end
 
+      # --- Static resource listing API ---
+
+      # Override in subclasses to enumerate concrete resources.
+      # Returns Array<ActionMCP::Resource>.
+      #
+      # @param session [Object, nil] The current MCP session
+      # @return [Array<ActionMCP::Resource>]
+      def list(session: nil)
+        []
+      end
+
+      # Returns true if this template subclass overrides +list+.
+      def lists_resources?
+        method(:list).owner != ActionMCP::ResourceTemplate.singleton_class
+      end
+
+      # Factory helper that fills in template-level defaults.
+      #
+      # @param uri [String] The concrete resource URI
+      # @param name [String] Display name
+      # @param title [String, nil] Human-readable title
+      # @param description [String, nil] Falls back to template description
+      # @param mime_type [String, nil] Falls back to template mime_type
+      # @param size [Integer, nil] Size in bytes
+      # @param annotations [Hash, nil] Optional annotations
+      # @return [ActionMCP::Resource]
+      def build_resource(uri:, name:, title: nil, description: nil, mime_type: nil, size: nil, annotations: nil)
+        ActionMCP::Resource.new(
+          uri: uri,
+          name: name,
+          title: title,
+          description: description || @description,
+          mime_type: mime_type || @mime_type,
+          size: size,
+          annotations: annotations
+        )
+      end
+
+      # Check if a concrete URI is readable by this template.
+      # Returns false if the URI doesn't match the template pattern.
+      #
+      # @param uri [String] A concrete URI to check
+      # @return [Boolean]
+      def readable_uri?(uri)
+        return false unless @uri_template
+
+        params = extract_params_from_uri(uri)
+        return false if params.nil?
+
+        new(params).valid?
+      rescue StandardError
+        false
+      end
+
       # Process a URI string to create a template instance
       def process(uri_string)
         return nil unless @uri_template

data/lib/action_mcp/resource_templates_registry.rb

@@ -22,7 +22,8 @@ module ActionMCP
         ResourceTemplate
       end
 
-      # Find the most specific template for a given URI
+      # Find the most specific template for a given URI.
+      # Uses registry-backed source (not ResourceTemplate.registered_templates class array).
       def find_template_for_uri(uri)
         parse_result = parse_uri(uri)
         return nil unless parse_result
@@ -31,7 +32,7 @@ module ActionMCP
         path = parse_result[:path]
         path_segments = path.split("/")
 
-        matching_templates = ResourceTemplate.registered_templates.select do |template|
+        matching_templates = resource_templates.values.select do |template|
           next unless template.uri_template
 
           # Parse the template

data/lib/action_mcp/server/handlers/resource_handler.rb

@@ -32,12 +32,12 @@ module ActionMCP
           }
         end
 
-        def handle_resources_list(id, _params)
-          transport.send_resources_list(id)
+        def handle_resources_list(id, params)
+          transport.send_resources_list(id, params)
         end
 
-        def handle_resources_templates_list(id, _params)
-          transport.send_resource_templates_list(id)
+        def handle_resources_templates_list(id, params)
+          transport.send_resource_templates_list(id, params)
         end
 
         def handle_resources_read(id, params)

data/lib/action_mcp/server/resources.rb

@@ -3,59 +3,112 @@
 module ActionMCP
   module Server
     module Resources
-      # Send list of available resources to the client
+      # Default page size for cursor-based pagination
+      RESOURCES_PAGE_SIZE = 100
+
+      # Send list of concrete resources to the client.
+      # Aggregates resources from templates that implement self.list.
       #
       # @param request_id [String, Integer] The ID of the request to respond to
-      #
-      # @example Input:
-      #   request_id = "req-123"
-      #
-      # @example Output:
-      #   # Sends: {"jsonrpc":"2.0","id":"req-123","result":{"resources":[]}}
-      def send_resources_list(request_id)
-        send_jsonrpc_response(request_id, result: { resources: [] })
+      # @param params [Hash] Optional params including "cursor" for pagination
+      def send_resources_list(request_id, params = {})
+        templates = session.registered_resource_templates
+
+        # Collect resources from templates that implement list
+        all_resources = []
+        seen_uris = {}
+
+        templates.each do |template_class|
+          next unless template_class.lists_resources?
+
+          begin
+            listed = template_class.list(session: session)
+          rescue StandardError => e
+            Rails.logger.error "[MCP] Error listing resources from #{template_class.name}: #{e.message}"
+            next
+          end
+
+          unless listed.is_a?(Array)
+            Rails.logger.warn "[MCP] #{template_class.name}.list returned #{listed.class}, expected Array; skipping"
+            next
+          end
+
+          listed.each do |resource|
+            unless resource.is_a?(ActionMCP::Resource)
+              Rails.logger.warn "[MCP] #{template_class.name}.list returned non-Resource: #{resource.class}"
+              next
+            end
+
+            # Validate the listed URI is readable by the declaring template
+            unless template_class.readable_uri?(resource.uri)
+              Rails.logger.warn "[MCP] #{template_class.name}.list returned URI not readable by its own template: #{resource.uri}"
+              next
+            end
+
+            # Deduplicate by URI
+            if (existing = seen_uris[resource.uri])
+              if existing == resource
+                # Identical duplicate, skip silently
+                next
+              else
+                # Conflicting metadata for same URI
+                send_jsonrpc_error(request_id, :invalid_params,
+                  "Resource URI collision: '#{resource.uri}' listed by multiple templates with conflicting metadata")
+                return
+              end
+            end
+
+            seen_uris[resource.uri] = resource
+            all_resources << resource
+          end
+        end
+
+        # Apply cursor-based pagination
+        result = paginate_resources(all_resources, params["cursor"])
+        if result == :invalid_cursor
+          send_jsonrpc_error(request_id, :invalid_params, "Invalid cursor value")
+          return
+        end
+        send_jsonrpc_response(request_id, result: result)
       end
 
       # Send list of resource templates to the client
       #
       # @param request_id [String, Integer] The ID of the request to respond to
-      #
-      # @example Input:
-      #   request_id = "req-456"
-      #
-      # @example Output:
-      #   # Sends: {"jsonrpc":"2.0","id":"req-456","result":{"resourceTemplates":[{"uriTemplate":"db://{table}","name":"Database Table"}]}}
-      def send_resource_templates_list(request_id)
-        templates = ActionMCP::ResourceTemplatesRegistry.resource_templates.values.map(&:to_h)
-        # TODO: add pagination support
-        # TODO add autocomplete
+      # @param params [Hash] Optional params including "cursor" for pagination
+      def send_resource_templates_list(request_id, params = {})
+        templates = session.registered_resource_templates.map(&:to_h)
         log_resource_templates
-        send_jsonrpc_response(request_id, result: { resourceTemplates: templates })
+
+        # Apply cursor-based pagination
+        result = paginate_templates(templates, params["cursor"])
+        if result == :invalid_cursor
+          send_jsonrpc_error(request_id, :invalid_params, "Invalid cursor value")
+          return
+        end
+        send_jsonrpc_response(request_id, result: result)
       end
 
       # Read and return the contents of a resource
       #
       # @param id [String, Integer] The ID of the request to respond to
       # @param params [Hash] Parameters specifying which resource to read
-      #
-      # @example Input:
-      #   id = "req-789"
-      #   params = { uri: "file:///example.txt" }
-      #
-      # @example Output:
-      #   # Sends: {"jsonrpc":"2.0","id":"req-789","result":{"contents":[{"uri":"file:///example.txt","text":"Example content"}]}}
       def send_resource_read(id, params)
         uri = params["uri"]
         template = ResourceTemplatesRegistry.find_template_for_uri(uri)
 
         unless template
-          send_jsonrpc_error(id, :method_not_found, "No resource template found for URI: '#{uri}'")
+          error = {
+            code: -32_002,
+            message: "Resource not found",
+            data: { uri: uri }
+          }
+          send_jsonrpc_response(id, error: error)
           return
         end
 
         # Check if resource requires consent and if consent is granted
         if template.respond_to?(:requires_consent?) && template.requires_consent? && !session.consent_granted_for?("resource:#{template.name}")
-          # Use custom error response for consent required (-32002)
           error = {
             code: -32_002,
             message: "Consent required for resource template '#{template.name}'"
@@ -64,22 +117,41 @@ module ActionMCP
           return
         end
 
+        unless template.readable_uri?(uri)
+          error = {
+            code: -32_002,
+            message: "Resource not found",
+            data: { uri: uri }
+          }
+          send_jsonrpc_response(id, error: error)
+          return
+        end
+
         begin
           # Create template instance and set execution context
           record = template.process(uri)
+          unless record
+            error = {
+              code: -32_002,
+              message: "Resource not found",
+              data: { uri: uri }
+            }
+            send_jsonrpc_response(id, error: error)
+            return
+          end
+
           record.with_context({ session: session })
 
           response = record.call
 
           if response.error?
-            # response.to_h works properly when error? is true:
             send_jsonrpc_response(id, error: response.to_h)
           else
-            # Handle successful response - ResourceResponse.contents is already an array
-            send_jsonrpc_response(id, result: { contents: response.contents.map(&:to_h) })
+            # Normalize contents to MCP ReadResourceResult shape
+            contents = response.contents.map { |c| normalize_read_content(c, uri) }
+            send_jsonrpc_response(id, result: { contents: contents })
           end
         rescue StandardError => e
-          # Should rather `ErrorHandling` module be included here? Then we could use `log_error(e)` directly.
           Rails.logger.error "[MCP Error] #{e.class}: #{e.message}"
           send_jsonrpc_error(id, :internal_error, "Failed to read resource: #{e.message}")
         end
@@ -87,13 +159,83 @@ module ActionMCP
 
       private
 
-      # Log all registered resource templates
+      # Normalize a content object to MCP ReadResourceResult content shape.
+      #
+      # @return [Hash] with keys: uri, mimeType, and text or blob
+      def normalize_read_content(content, _uri)
+        case content
+        when ActionMCP::Content::Resource
+          inner = { uri: content.uri, mimeType: content.mime_type }
+          inner[:text] = content.text if content.text
+          inner[:blob] = content.blob if content.blob
+          inner
+        else
+          content.respond_to?(:to_h) ? content.to_h : content
+        end
+      end
+
+      # Paginate a list of resources with cursor support.
       #
-      # @example Input:
-      #   # No parameters
+      # @param resources [Array<ActionMCP::Resource>] All resources
+      # @param cursor [String, nil] Base64-encoded offset cursor
+      # @return [Hash] Result hash with :resources and optional :nextCursor
+      def paginate_resources(resources, cursor)
+        offset = decode_cursor(cursor)
+        return :invalid_cursor if offset == :invalid
+
+        page = resources[offset, RESOURCES_PAGE_SIZE] || []
+
+        result = { resources: page.map(&:to_h) }
+
+        next_offset = offset + RESOURCES_PAGE_SIZE
+        if next_offset < resources.size
+          result[:nextCursor] = encode_cursor(next_offset)
+        end
+
+        result
+      end
+
+      # Paginate a list of templates with cursor support.
       #
-      # @example Output:
-      #   # Logs: "Registered Resource Templates: ["db://{table}", "file://{path}"]"
+      # @param templates [Array<Hash>] All template hashes
+      # @param cursor [String, nil] Base64-encoded offset cursor
+      # @return [Hash] Result hash with :resourceTemplates and optional :nextCursor
+      def paginate_templates(templates, cursor)
+        offset = decode_cursor(cursor)
+        return :invalid_cursor if offset == :invalid
+
+        page = templates[offset, RESOURCES_PAGE_SIZE] || []
+
+        result = { resourceTemplates: page }
+
+        next_offset = offset + RESOURCES_PAGE_SIZE
+        if next_offset < templates.size
+          result[:nextCursor] = encode_cursor(next_offset)
+        end
+
+        result
+      end
+
+      # Decode a cursor string to a non-negative integer offset.
+      # Returns 0 for nil cursors, :invalid for malformed/negative/non-string values.
+      def decode_cursor(cursor)
+        return 0 if cursor.nil?
+        return :invalid unless cursor.is_a?(String) && !cursor.empty?
+
+        decoded = Base64.strict_decode64(cursor)
+        return :invalid unless decoded.match?(/\A\d+\z/)
+
+        decoded.to_i
+      rescue ArgumentError
+        :invalid
+      end
+
+      # Encode an integer offset as a cursor string.
+      def encode_cursor(offset)
+        Base64.strict_encode64(offset.to_s)
+      end
+
+      # Log all registered resource templates
       def log_resource_templates
         Rails.logger.debug "Registered Resource Templates: #{ActionMCP::ResourceTemplatesRegistry.resource_templates.keys}"
       end

data/lib/action_mcp/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.104.1
+  version: 0.106.0
 platform: ruby
 authors:
 - Abdelkader Boudih
@@ -302,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Lightweight Model Context Protocol (MCP) server toolkit for Ruby/Rails
 test_files: []