actionmcp 0.16.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6794bfeea02de8502aa4b084548a93269149b9376117663d602ecfae54af8014
-  data.tar.gz: 49bca81dc1f59d27fc8d27c1b8978a8def6d3414822f261ce1aee2a4ebfc45b0
+  metadata.gz: cb964a85c5ae8f64c05730e054c3e252c22e8fe3eeea6230496929948ea51f68
+  data.tar.gz: a7cfd82678922926ef8beb28cc0346ebb583f826d1cc9ff9d8d54f55cecd08d7
 SHA512:
-  metadata.gz: 3f94f11e49df2549d1e43c4499f7fedfc9f7000279f6b08d2eb3ffb9e32add617a14277869fa3b34a31bde7aa2e6e66674f2e7b49cd57f5606daebbd060097f7
-  data.tar.gz: 9ce4b731e107c76a1e057ea4ce33a90998d1d5700946f8e056eea3763535e12ca941ba875324914c910d375bbac04c12f4c0da25255d2d7cf5e746b9bd1fa19c
+  metadata.gz: f6c12f6088da3ca4e642fe9aac72d7caeacd9630619c61a1d2c93006e87ab2da7d35eb25467e086d6ecb5e3109546f0f61285e6f9c175183fb8b1365f7cbae96
+  data.tar.gz: 70cbe6bcbf594afcc7558f3c178771c5b2d9c06d00f7474288bfbe59d9da694ccef578c68a0c5cf9a6a571f4ef51f317ed2fa34d57600321364beffb5ba7fe77

data/README.md

@@ -19,7 +19,7 @@ This means an AI (like an LLM) can request information or actions from your appl
 **ActionMCP** is targeted at developers building MCP-enabled applications.
 It simplifies the process of integrating Ruby and Rails apps with the MCP standard by providing a set of base classes and an easy-to-use server interface.
 
-Instead of implementing MCP support from scratch, you can subclass and configure the provided **Prompt**, **Tool**, and **ResourceTemplate** classes to expose your app's functionality to LLMs.
+Instead of implementing MCP support from scratch, you can subclass and configure the provided **Prompt**, **Tool**, and **ResourceTemplate** classes to expose your app's functionality to LLMs. 
 
 ActionMCP handles the underlying MCP message format and routing, so you can adhere to the open standard with minimal effort.
 
@@ -169,6 +169,32 @@ class ProductResourceTemplate < ApplicationMCPResTemplate
     )
   end
 end
+
+# Example of callbacks:
+
+```ruby
+before_resolve do |template|
+  logger.tagged("ProductsTemplate") { logger.info("Starting to resolve product: #{template.product_id}") }
+end
+
+after_resolve do |template|
+  logger.tagged("ProductsTemplate") { logger.info("Finished resolving product resource for product: #{template.product_id}") }
+end
+
+around_resolve do |template, block|
+  start_time = Time.current
+  logger.tagged("ProductsTemplate") { logger.info("Starting resolution for product: #{template.product_id}") }
+
+  resource = block.call
+
+  if resource
+    logger.tagged("ProductsTemplate") { logger.info("Product #{template.product_id} resolved successfully in #{Time.current - start_time}s") }
+  else
+    logger.tagged("ProductsTemplate") { logger.info("Product #{template.product_id} not found") }
+  end
+
+  resource
+end
 ```
 
 Resource templates are automatically registered and used when LLMs request resources matching their patterns.

data/app/models/action_mcp/session/message.rb

@@ -63,13 +63,14 @@ module ActionMCP
           begin
             parsed_json = MultiJson.load(payload)
             self.message_json = parsed_json
+            self.message_text = nil
             process_json_content(parsed_json)
           rescue MultiJson::ParseError
             self.message_type = "text"
           end
         else
           self.message_json = payload
-          self.message_text = MultiJson.dump(payload)
+          self.message_text = nil
           process_json_content(payload)
         end
       end

data/lib/action_mcp/content/resource.rb

@@ -17,7 +17,7 @@ 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: nil, blob: nil)
+      def initialize(uri, mime_type = "text/plain", text: nil, blob: nil)
         super("resource")
         @uri = uri
         @mime_type = mime_type

data/lib/action_mcp/instrumentation/controller_runtime.rb

@@ -12,22 +12,21 @@ module ActionMCP
       attr_internal :mcp_runtime
 
       def cleanup_view_runtime
-        mcp_rt_before_render = Instrumentation::LogSubscriber.reset_runtime
+        mcp_rt_before_render = LogSubscriber.reset_runtime
         runtime = super
-        mcp_rt_after_render = Instrumentation::LogSubscriber.reset_runtime
+        mcp_rt_after_render = LogSubscriber.reset_runtime
         self.mcp_runtime = mcp_rt_before_render + mcp_rt_after_render
         runtime - mcp_rt_after_render
       end
 
       def append_info_to_payload(payload)
         super
-        payload[:mcp_runtime] = (mcp_runtime || 0) + Instrumentation::LogSubscriber.reset_runtime
+        payload[:mcp_runtime] = (mcp_runtime || 0) + LogSubscriber.reset_runtime
       end
 
       class_methods do
         def log_process_action(payload)
           messages = super
-          binding.irb
           mcp_runtime = payload[:mcp_runtime]
           messages << ("mcp: %.1fms" % mcp_runtime.to_f) if mcp_runtime
           messages

data/lib/action_mcp/log_subscriber.rb

@@ -1,28 +1,29 @@
-# In log_subscriber.rb
 module ActionMCP
   class LogSubscriber < ActiveSupport::LogSubscriber
-    def tool_call(event)
-      # Try both debug and info to ensure output regardless of logger level
-      debug "Tool: #{event.payload[:tool_name]} (#{event.duration.round(2)}ms)"
-      info "Tool: #{event.payload[:tool_name]} (#{event.duration.round(2)}ms)"
+    def self.reset_runtime
+      # Get the combined runtime from both tool and prompt operations
+      tool_rt = Thread.current[:mcp_tool_runtime] || 0
+      prompt_rt = Thread.current[:mcp_prompt_runtime] || 0
+      total_rt = tool_rt + prompt_rt
 
-      # Track total tool time for summary
-      Thread.current[:tool_runtime] ||= 0
-      Thread.current[:tool_runtime] += event.duration
-    end
+      # Reset both counters
+      Thread.current[:mcp_tool_runtime] = 0
+      Thread.current[:mcp_prompt_runtime] = 0
 
-    def prompt_call(event)
-      # Add debug output to confirm method is called
-      puts "LogSubscriber#prompt_call called with: #{event.name}"
+      # Return the total runtime
+      total_rt
+    end
 
-      # Try both debug and info to ensure output regardless of logger level
-      debug "Prompt: #{event.payload[:prompt_name]} (#{event.duration.round(2)}ms)"
-      info "Prompt: #{event.payload[:prompt_name]} (#{event.duration.round(2)}ms)"
+    def tool_call(event)
+      Thread.current[:mcp_tool_runtime] ||= 0
+      Thread.current[:mcp_tool_runtime] += event.duration
+    end
 
-      # Track total prompt time for summary
-      Thread.current[:prompt_runtime] ||= 0
-      Thread.current[:prompt_runtime] += event.duration
+    def prompt_call(event)
+      Thread.current[:mcp_prompt_runtime] ||= 0
+      Thread.current[:mcp_prompt_runtime] += event.duration
     end
+
     attach_to :action_mcp
   end
 end

data/lib/action_mcp/resource_template.rb

@@ -9,12 +9,14 @@ module ActionMCP
     include ActiveModel::Validations
     include ResourceCallbacks
     include Logging
+    include UriAmbiguityChecker
 
     # Track all registered templates
     @registered_templates = []
 
     class << self
-      attr_reader :registered_templates, :description, :uri_template, :mime_type, :template_name, :parameters
+      attr_reader :registered_templates, :description, :uri_template,
+                  :mime_type, :template_name, :parameters
 
       def abstract?
         @abstract ||= false
@@ -194,40 +196,6 @@ module ActionMCP
                 "URI template conflict detected: '#{new_template}' conflicts with existing template '#{registered_class.uri_template}' registered by #{registered_class.name}"
         end
       end
-
-      # Determine if two normalized patterns could be ambiguous
-      def are_potentially_ambiguous?(pattern1, pattern2)
-        # If the patterns are exactly the same, they're definitely ambiguous
-        return true if pattern1 == pattern2
-
-        # Split into segments to compare structure
-        segments1 = pattern1.split("/")
-        segments2 = pattern2.split("/")
-
-        # If different number of segments, they can't be ambiguous
-        return false if segments1.size != segments2.size
-
-        # Count parameter segments
-        param_segments1 = segments1.count { |s| s.include?("{param}") }
-        param_segments2 = segments2.count { |s| s.include?("{param}") }
-
-        # If they have different number of parameter segments, they're not ambiguous
-        return false if param_segments1 != param_segments2
-
-        # If we have the same number of segments and same number of parameters,
-        # but the patterns aren't identical, they could be ambiguous
-        # due to parameter position swapping
-        if param_segments1.positive? && param_segments1 == param_segments2
-          # Create pattern maps (P for param, S for static)
-          pattern_map1 = segments1.map { |s| s.include?("{param}") ? "P" : "S" }
-          pattern_map2 = segments2.map { |s| s.include?("{param}") ? "P" : "S" }
-
-          # If pattern maps are different but have same param count, potentially ambiguous
-          return pattern_map1 != pattern_map2
-        end
-
-        false
-      end
     end
 
     # Initialize with attribute values
@@ -249,5 +217,11 @@ module ActionMCP
     end
 
     attr_reader :description, :uri_template, :mime_type
+
+    def call
+      run_callbacks :resolve do
+        resolve
+      end
+    end
   end
 end

data/lib/action_mcp/tool_response.rb

@@ -72,6 +72,14 @@ module ActionMCP
       [ contents, is_error ].hash
     end
 
+    def success?
+      !is_error
+    end
+
+    def error?
+      is_error
+    end
+
     # Pretty print for better debugging
     def inspect
       "#<#{self.class.name} content: #{contents.inspect}, isError: #{is_error}>"

data/lib/action_mcp/transport/resources.rb

@@ -47,7 +47,7 @@ module ActionMCP
       def send_resource_read(id, params)
         if (template = ResourceTemplatesRegistry.find_template_for_uri(params[:uri]))
           record = template.process(params[:uri])
-          if (resource = record.resolve)
+          if (resource = record.call)
             # if resource is a array or a collection, return each item then it ok
             # else wrap it in a array
             resource = [ resource ] unless resource.respond_to?(:each)

data/lib/action_mcp/uri_ambiguity_checker.rb

@@ -0,0 +1,74 @@
+module ActionMCP
+  module UriAmbiguityChecker
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Determines if a segment is a parameter
+      def parameter?(segment)
+        segment =~ /\A\{[a-z0-9_]+\}\z/
+      end
+
+      # Checks if two URI patterns could potentially match the same URI
+      def are_potentially_ambiguous?(pattern1, pattern2)
+        # If the patterns are exactly the same, they're definitely ambiguous
+        return true if pattern1 == pattern2
+
+        segments1 = pattern1.split("/")
+        segments2 = pattern2.split("/")
+
+        # If different number of segments, they can't be ambiguous
+        if segments1.size != segments2.size
+          return false
+        end
+
+        # Extract literals (non-parameters) from each pattern
+        literals1 = []
+        literals2 = []
+
+        segments1.each_with_index do |seg, i|
+          literals1 << [ seg, i ] unless parameter?(seg)
+        end
+
+        segments2.each_with_index do |seg, i|
+          literals2 << [ seg, i ] unless parameter?(seg)
+        end
+
+        # Check each segment for direct literal mismatches
+        segments1.zip(segments2).each_with_index do |(seg1, seg2), index|
+          param1 = parameter?(seg1)
+          param2 = parameter?(seg2)
+
+          # When both segments are literals, they must match exactly
+          if !param1 && !param2 && seg1 != seg2
+            return false
+          end
+        end
+
+        # Check for structural incompatibility in the literals
+        # If the same literals appear in different relative order, the patterns are structurally different
+        if literals1.size >= 2 && literals2.size >= 2
+          # Create arrays of just the literals (without positions)
+          lit_values1 = literals1.map(&:first)
+          lit_values2 = literals2.map(&:first)
+
+          # Find common literals
+          common_literals = lit_values1 & lit_values2
+
+          if common_literals.size >= 2
+            # Check if the relative ordering of common literals differs
+            common_literal_indices1 = common_literals.map { |lit| lit_values1.index(lit) }
+            common_literal_indices2 = common_literals.map { |lit| lit_values2.index(lit) }
+
+            # If the relative ordering is different, patterns are not ambiguous
+            if common_literal_indices1 != common_literal_indices2
+              return false
+            end
+          end
+        end
+
+        # If we got here, the patterns are potentially ambiguous
+        true
+      end
+    end
+  end
+end

data/lib/action_mcp/version.rb

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

data/lib/tasks/action_mcp_tasks.rake

@@ -44,7 +44,7 @@ namespace :action_mcp do
     ActionMCP::ResourceTemplate.descendants.each do |resource|
       next if resource.abstract?
 
-      puts "\e[33m#{resource.capability_name}:\e[0m #{resource.description}" # Yellow name
+      puts "\e[33m#{resource.capability_name}:\e[0m #{resource.description} : #{resource.uri_template}" # Yellow name
     end
     puts "\n"
   end

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.16.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Abdelkader Boudih
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-03-20 00:00:00.000000000 Z
+date: 2025-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
@@ -136,7 +137,6 @@ files:
 - lib/action_mcp/gem_version.rb
 - lib/action_mcp/instrumentation/controller_runtime.rb
 - lib/action_mcp/instrumentation/instrumentation.rb
-- lib/action_mcp/instrumentation/log_subscriber.rb
 - lib/action_mcp/instrumentation/resource_instrumentation.rb
 - lib/action_mcp/integer_array.rb
 - lib/action_mcp/json_rpc.rb
@@ -177,6 +177,7 @@ files:
 - lib/action_mcp/transport/tools.rb
 - lib/action_mcp/transport/transport_base.rb
 - lib/action_mcp/transport_handler.rb
+- lib/action_mcp/uri_ambiguity_checker.rb
 - lib/action_mcp/version.rb
 - lib/actionmcp.rb
 - lib/generators/action_mcp/install/install_generator.rb
@@ -198,6 +199,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
@@ -212,7 +214,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.5.22
+signing_key:
 specification_version: 4
 summary: Provides essential tooling for building Model Context Protocol (MCP) capable
   servers

data/lib/action_mcp/instrumentation/log_subscriber.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module ActionMCP
-  module Instrumentation
-    # A log subscriber to attach to Elasticsearch related events
-    #
-    # @see https://github.com/rails/rails/blob/master/activerecord/lib/active_record/log_subscriber.rb
-    #
-    class LogSubscriber < ActiveSupport::LogSubscriber
-      def self.runtime=(value)
-        Thread.current["elasticsearch_runtime"] = value
-      end
-
-      def self.runtime
-        Thread.current["elasticsearch_runtime"] ||= 0
-      end
-
-      def self.reset_runtime
-        rt = runtime
-        self.runtime = 0
-        rt
-      end
-
-      # Intercept `search.elasticsearch` events, and display them in the Rails log
-      #
-      def search(event)
-        self.class.runtime += event.duration
-        return unless logger.debug?
-
-        payload = event.payload
-        name    = "#{payload[:klass]} #{payload[:name]} (#{event.duration.round(1)}ms)"
-        search  = payload[:search].inspect.gsub(/:(\w+)=>/, '\1: ')
-
-        debug %(  #{color(name, GREEN, bold: true)} #{colorize_logging ? "\e[2m#{search}\e[0m" : search})
-      end
-    end
-  end
-  Instrumentation::LogSubscriber.attach_to :elasticsearch
-end