actionmcp 0.50.8 → 0.50.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 94384a0f8fcb5f0f77bac5d814fea53addbc8732007a3771b843f2bcca24ab47
-  data.tar.gz: 812125b6acf82b418257610ba5b58b3af4cb01c5b3152ac995a1c614df02a263
+  metadata.gz: a500e24390bf32c0e74cba14755f67257c91b69ba6ffe786e3b692efd82c87cc
+  data.tar.gz: d122b12b45799b719f077d742a1a5edd85eac4cbe96e2a85259eb7673c858f36
 SHA512:
-  metadata.gz: 7e693c3b47925b0f1babb7d1912605766851b054f764ba6c0b6270f5f6d34739231300654a3dca83cb3d4a12a00cc29f20400bfdd7e93b4358bd296f9b9881ae
-  data.tar.gz: fba759c19cab4145614ac93b7c14866261f663a41f7539d5741712708136f34c29d43fcedbedbe06834f5989ac6c6d9d2aa2aa6b6a3f7e44b46e891a160bc224
+  metadata.gz: f7878f2188781097208e5a703cdd6b3c6fcffa6cea0fef3db5e13538499bae935eebfc3ec6ffbbb77267f016023abe2c9b1e476b51b1d87910c81d4f44c5f4b7
+  data.tar.gz: 72048e1f3c8d3062bbc17840c14d5abfbc04fe620710d5dde9d3f98ce44a866347b95884fa03fb402d2d2cab078d7f9d6e9eb49690d338f29484b64fcad3caa5

data/app/controllers/action_mcp/application_controller.rb

@@ -160,8 +160,10 @@ module ActionMCP
 
       transport_handler = Server::TransportHandler.new(session)
       json_rpc_handler = Server::JsonRpcHandler.new(transport_handler)
-      handler_results = json_rpc_handler.call(jsonrpc_params)
-      process_handler_results(handler_results, session, session_initially_missing, is_initialize_request)
+
+      result = json_rpc_handler.call(jsonrpc_params)
+
+      process_handler_results(result, session, session_initially_missing, is_initialize_request)
     rescue ActionController::Live::ClientDisconnected, IOError => e
       Rails.logger.debug "Unified SSE (POST): Client disconnected during response: #{e.message}"
       begin
@@ -257,45 +259,24 @@ module ActionMCP
     end
 
     # Processes the results from the JsonRpcHandler.
-    def process_handler_results(results, session, session_initially_missing, is_initialize_request)
-      results ||= {}
-      is_notification = jsonrpc_params.is_a?(JSON_RPC::Notification)
-      request_id = nil
-      if results.is_a?(Hash)
-        request_id = results[:request_id] || results[:id]
-        request_id ||= results[:payload][:id] if results[:payload].is_a?(Hash) && results[:payload][:id]
+    def process_handler_results(result, session, session_initially_missing, is_initialize_request)
+      # Handle empty result (notifications)
+      if result.nil?
+        return head :accepted
       end
-      result_type = results[:type]
-      result_payload = results[:payload] || {}
-      result_payload[:id] = request_id if result_payload.is_a?(Hash) && request_id && !result_payload.key?(:id)
-
-      case result_type
-      when :error
-        error_payload = result_payload
-        error_payload[:id] = request_id if error_payload.is_a?(Hash) && !error_payload.key?(:id) && request_id
-        render json: error_payload, status: results.fetch(:status, :bad_request)
-      when :notifications_only
-        head :accepted
-      when :responses
-        server_preference = ActionMCP.configuration.post_response_preference
-        use_sse = (server_preference == :sse)
-        add_session_header = is_initialize_request && session_initially_missing && session.persisted?
-        if use_sse
-          render_sse_response(result_payload, session, add_session_header)
-        else
-          render_json_response(result_payload, session, add_session_header)
-        end
+
+      # Convert to hash for rendering
+      payload = result.message_json
+
+      # Determine response format
+      server_preference = ActionMCP.configuration.post_response_preference
+      use_sse = (server_preference == :sse)
+      add_session_header = is_initialize_request && session_initially_missing && session.persisted?
+
+      if use_sse
+        render_sse_response(payload, session, add_session_header)
       else
-        Rails.logger.error "Unknown handler result type: #{result_type.inspect}"
-        if is_notification
-          head :accepted
-        else
-          render json: {
-            jsonrpc: "2.0",
-            id: request_id,
-            result: result_payload
-          }, status: :ok
-        end
+        render_json_response(payload, session, add_session_header)
       end
     end
 

data/lib/action_mcp/json_rpc_handler_base.rb

@@ -56,12 +56,8 @@ module ActionMCP
       case rpc_method
       when Methods::PING
         transport.send_pong(id)
-        true
       when %r{^notifications/}
         process_notifications(rpc_method, params)
-        true
-      else
-        false
       end
     end
 

data/lib/action_mcp/server/capabilities.rb

@@ -15,48 +15,32 @@ module ActionMCP
         client_capabilities = params["capabilities"]
 
         unless client_protocol_version.is_a?(String) && client_protocol_version.present?
-          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
-          return { type: :error, id: request_id,
-                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'protocolVersion'" } } }
+          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'protocolVersion'")
         end
-        # Check if the protocol version is supported
         unless ActionMCP.configuration.vibed_ignore_version || ActionMCP::SUPPORTED_VERSIONS.include?(client_protocol_version)
           error_data = {
             supported: ActionMCP::SUPPORTED_VERSIONS,
             requested: client_protocol_version
           }
-          send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
-          return { type: :error, id: request_id,
-                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Unsupported protocol version", data: error_data } } }
+          return send_jsonrpc_error(request_id, :invalid_params, "Unsupported protocol version", error_data)
         end
 
         unless client_info.is_a?(Hash)
-          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
-          return { type: :error, id: request_id,
-                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'clientInfo'" } } }
+          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'clientInfo'")
         end
         unless client_capabilities.is_a?(Hash)
-          send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
-          return { type: :error, id: request_id,
-                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_602, message: "Missing or invalid 'capabilities'" } } }
+          return send_jsonrpc_error(request_id, :invalid_params, "Missing or invalid 'capabilities'")
         end
 
-        # Store client information
         session.store_client_info(client_info)
         session.store_client_capabilities(client_capabilities)
         session.set_protocol_version(client_protocol_version)
 
-        # Initialize the session
         unless session.initialize!
-          send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
-          return { type: :error, id: request_id,
-                   payload: { jsonrpc: "2.0", id: request_id, error: { code: -32_603, message: "Failed to initialize session" } } }
+          return send_jsonrpc_error(request_id, :internal_error, "Failed to initialize session")
         end
 
-        # Send the successful response with the correct protocol version
         capabilities_payload = session.server_capabilities_payload
-        # If vibed_ignore_version is true, always use the latest supported version in the response
-        # Otherwise, use the client's requested version
         capabilities_payload[:protocolVersion] = if ActionMCP.configuration.vibed_ignore_version
                                                    PROTOCOL_VERSION
         else
@@ -64,7 +48,6 @@ module ActionMCP
         end
 
         send_jsonrpc_response(request_id, result: capabilities_payload)
-        { type: :responses, id: request_id, payload: { jsonrpc: "2.0", id: request_id, result: capabilities_payload } }
       end
     end
   end

data/lib/action_mcp/server/error_handling.rb

@@ -12,19 +12,10 @@ module ActionMCP
         when Symbol
                            JSON_RPC::JsonRpcError.new(error_or_symbol, message: message, data: data)
         else
-                           # If it's already an error hash
                            error_or_symbol
         end
 
-        {
-          type: :error,
-          request_id: id,
-          payload: {
-            jsonrpc: "2.0",
-            id: id,
-            error: json_rpc_error.to_h
-          }
-        }
+        JSON_RPC::Response.new(id: id, error: json_rpc_error)
       end
 
       # Helper method to create error response from any exception

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

@@ -32,14 +32,11 @@ module ActionMCP
         def handle_prompts_get(id, params)
           name = extract_name(params)
           arguments = extract_arguments(params)
-
-          message = transport.send_prompts_get(id, name, arguments)
-          extract_message_payload(message, id)
+          transport.send_prompts_get(id, name, arguments)
         end
 
         def handle_prompts_list(id, _params)
-          message = transport.send_prompts_list(id)
-          extract_message_payload(message, id)
+          transport.send_prompts_list(id)
         end
 
         def extract_name(params)

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

@@ -33,20 +33,16 @@ module ActionMCP
         end
 
         def handle_resources_list(id, _params)
-          message = transport.send_resources_list(id)
-          extract_message_payload(message, id)
+          transport.send_resources_list(id)
         end
 
         def handle_resources_templates_list(id, _params)
-          message = transport.send_resource_templates_list(id)
-          extract_message_payload(message, id)
+          transport.send_resource_templates_list(id)
         end
 
         def handle_resources_read(id, params)
           validate_params_present(params, "Resource URI is required")
-
-          message = transport.send_resource_read(id, params)
-          extract_message_payload(message, id)
+          transport.send_resource_read(id, params)
         end
 
         def handle_resources_subscribe(id, params)

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

@@ -30,16 +30,13 @@ module ActionMCP
         end
 
         def handle_tools_list(id, params)
-          message = transport.send_tools_list(id, params)
-          extract_message_payload(message, id)
+          transport.send_tools_list(id, params)
         end
 
         def handle_tools_call(id, params)
           name = validate_required_param(params, "name", "Tool name is required")
           arguments = extract_arguments(params)
-
-          message = transport.send_tools_call(id, name, arguments)
-          extract_message_payload(message, id)
+          transport.send_tools_call(id, name, arguments)
         end
 
         def extract_arguments(params)

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -32,10 +32,8 @@ module ActionMCP
         params = request.params
 
         with_error_handling(id) do
-          # Try to handle common methods first (like ping)
-          return if handle_common_methods(rpc_method, id, params)
-
-          # Route to appropriate handler
+          common_method = handle_common_methods(rpc_method, id, params)
+          return common_method if common_method
           route_to_handler(rpc_method, id, params)
         end
       end
@@ -58,8 +56,7 @@ module ActionMCP
       end
 
       def handle_initialize(id, params)
-        message = transport.send_capabilities(id, params)
-        extract_message_payload(message, id)
+        transport.send_capabilities(id, params)
       end
 
       def handle_notification(notification)
@@ -67,29 +64,17 @@ module ActionMCP
         params = notification.params || {}
 
         process_notifications(method_name, params)
-        { type: :notifications_only }
+        nil
       end
 
       def handle_response(response)
         Rails.logger.debug("Received response: #{response.inspect}")
-
-        {
-          type: :responses,
-          request_id: response.id,
-          payload: build_response_payload(response)
-        }
+        response
       end
 
-      def process_completion_complete(id, params)
-        params ||= {}
 
-        result = transport.send_jsonrpc_response(id, result: build_completion_result)
-
-        if result.is_a?(ActionMCP::Session::Message)
-          extract_message_payload(result, id)
-        else
-          wrap_transport_result(result, id)
-        end
+      def process_completion_complete(id, params)
+        transport.send_jsonrpc_response(id, result: build_completion_result)
       end
 
       def process_notifications(rpc_method, params)
@@ -101,30 +86,6 @@ module ActionMCP
         end
       end
 
-      def extract_message_payload(message, id)
-        if message.is_a?(ActionMCP::Session::Message)
-          {
-            type: :responses,
-            request_id: id,
-            payload: message.message_json
-          }
-        else
-          message
-        end
-      end
-
-      def wrap_transport_result(transport_result, id)
-        if transport_result.is_a?(Hash) && transport_result[:type]
-          transport_result
-        else
-          {
-            type: :responses,
-            request_id: id,
-            payload: transport_result
-          }
-        end
-      end
-
       def build_response_payload(response)
         {
           jsonrpc: "2.0",

data/lib/action_mcp/sse_listener.rb

@@ -56,22 +56,6 @@ module ActionMCP
         if raw_message.is_a?(String) && valid_json_format?(raw_message)
           message = MultiJson.load(raw_message)
           callback&.call(message)
-        elsif raw_message.respond_to?(:message) && raw_message.message.is_a?(String) && valid_json_format?(raw_message.message)
-          message = MultiJson.load(raw_message.message)
-          callback&.call(message)
-        elsif raw_message.respond_to?(:to_json)
-          # Try to serialize the message object to JSON if it responds to to_json
-          message_json = raw_message.to_json
-          if valid_json_format?(message_json)
-            message = MultiJson.load(message_json)
-            callback&.call(message)
-          else
-            Rails.logger.warn "SSEListener: Message cannot be converted to valid JSON"
-          end
-        else
-          # Log that we received an invalid message format
-          display_message = raw_message.to_s[0..100]
-          Rails.logger.warn "SSEListener: Received invalid JSON format: #{display_message}..."
         end
       rescue StandardError => e
         Rails.logger.error "SSEListener: Error processing message: #{e.message}"

data/lib/action_mcp/tool.rb

@@ -52,12 +52,28 @@ module ActionMCP
       end
 
       # Convenience methods for common annotations
+      def title(value = nil)
+        if value
+          annotate(:title, value)
+        else
+          _annotations["title"]
+        end
+      end
+
       def destructive(enabled = true)
-        annotate(:destructive, enabled)
+        annotate(:destructiveHint, enabled)
       end
 
       def read_only(enabled = true)
-        annotate(:readOnly, enabled)
+        annotate(:readOnlyHint, enabled)
+      end
+
+      def idempotent(enabled = true)
+        annotate(:idempotentHint, enabled)
+      end
+
+      def open_world(enabled = true)
+        annotate(:openWorldHint, enabled)
       end
 
       # Return annotations for the tool

data/lib/action_mcp/version.rb

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

data/lib/generators/action_mcp/prompt/templates/prompt.rb.erb

@@ -6,16 +6,20 @@ class <%= class_name %> < ApplicationMCPPrompt
   prompt_name "<%= prompt_name %>"
 
   # Provide a user-facing description for your prompt.
-  description "Analyze code for potential improvements"
+  description "<%= description || 'Describe what this prompt does' %>"
 
-  # Configure arguments via the new DSL
-  argument :language, description: "Programming language", default: "Ruby"
-  argument :code, description: "Code to explain", required: true
+  # Configure arguments (example structure — override as needed)
+  argument :input, description: "Main input", required: true
 
-  # Add validations (note: "Ruby" is not allowed per the validation)
-  validates :language, inclusion: { in: %w[Ruby C Cobol FORTRAN] }
+  # Optional: add more arguments if needed
+  # argument :context, description: "Context for the input", default: ""
 
-  # Implement your prompt's behavior here
-  def call
+  # Optional: validations can be added as needed
+  # validates :input, presence: true
+  # validates :context, length: { maximum: 500 }
+
+  # Main logic for prompt
+  def perform
+    # Implement behavior here
   end
 end

data/lib/generators/action_mcp/tool/templates/tool.rb.erb

@@ -1,17 +1,46 @@
 # frozen_string_literal: true
 
-# Template for generating new tools.
 class <%= class_name %> < ApplicationMCPTool
-  # Set the tool name.
   tool_name "<%= tool_name %>"
-  description "Calculate the sum of two numbers"
+  description "<%= description %>"
+<% if options[:title] %>
+  title "<%= options[:title] %>"
+<% end %>
+<% if options[:read_only] %>
+  read_only
+<% end %>
+<% if options[:destructive] %>
+  destructive
+<% end %>
+<% if options[:idempotent] %>
+  idempotent
+<% end %>
+<% if options[:open_world] %>
+  open_world
+<% end %>
+<% annotations.each do |k, v| %>
+  <% unless [:read_only, :destructive, :idempotent, :open_world, :title].include?(k) %>
+  annotate(:<%= k %>, <%= v.inspect %>)
+  <% end %>
+<% end %>
 
-  # Define input properties.
-  property :a, type: "number", description: "First number", required: true
-  property :b, type: "number", description: "Second number", required: true
+    <% if properties.empty? %>
+  property :input, type: "string", description: "Input", required: true
+    <% else %>
+    <% properties.each do |prop| %>
+  property :<%= prop[:name] %>, type: "<%= prop[:type] %>", description: "<%= prop[:description] %>"<%= ", required: true" if prop[:required] %>
+    <% end %>
+    <% end %>
 
-  # Implement the tool's logic here.
-  def call
-    render(text: a + b)
+  def perform
+    render(text: "Processing <%= properties.map { |p| p[:name] }.join(', ') %>")
+
+    # Optional outputs:
+    # render(audio: "<base64_data>", mime_type: "audio/mpeg")
+    # render(image: "<base64_data>", mime_type: "image/png")
+    # render(resource: "file://path", mime_type: "application/json", text: "{}")
+    # render(resource: "file://path", mime_type: "application/octet-stream", blob: "<base64_data>")
+  rescue => e
+    render(error: ["Error: #{e.message}"])
   end
 end

data/lib/generators/action_mcp/tool/tool_generator.rb

@@ -7,32 +7,58 @@ module ActionMCP
       source_root File.expand_path("templates", __dir__)
       desc "Creates a Tool (in app/mcp/tools) that inherits from ApplicationMCPTool"
 
-      # The generator takes one argument, e.g. "CalculateSum"
       argument :name, type: :string, required: true, banner: "ToolName"
 
+      class_option :description, type: :string, default: "Describe what this tool does"
+      class_option :read_only, type: :boolean, default: false
+      class_option :destructive, type: :boolean, default: false
+      class_option :category, type: :string, default: nil
+      class_option :properties, type: :array, default: [], banner: "name:type:description:required"
+
       def create_tool_file
         template "tool.rb.erb", "app/mcp/tools/#{file_name}.rb"
       end
 
       private
 
-      # Compute the class name ensuring it ends with "Tool"
       def class_name
         "#{name.camelize}#{name.camelize.end_with?('Tool') ? '' : 'Tool'}"
       end
 
-      # Compute the file name ensuring it ends with _tool.rb
       def file_name
         base = name.underscore
         base.end_with?("_tool") ? base : "#{base}_tool"
       end
 
-      # Compute the DSL tool name (a dashed version, without the "Tool" suffix)
       def tool_name
         base = name.to_s
-        base = base[0...-4] if base.end_with?("Tool")
+        base = base.end_with?("Tool") ? base[0..-5] : base
         base.underscore.dasherize
       end
+
+      def description
+        options[:description]
+      end
+
+      def annotations
+        ann = {}
+        ann[:read_only] = true if options[:read_only]
+        ann[:destructive] = true if options[:destructive]
+        ann[:category] = options[:category] if options[:category]
+        ann
+      end
+
+      def properties
+        options[:properties].map do |prop|
+          parts = prop.split(":")
+          {
+            name: parts[0],
+            type: parts[1] || "string",
+            description: parts[2] || "No description provided",
+            required: parts[3] == "true"
+          }
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.8
+  version: 0.50.11
 platform: ruby
 authors:
 - Abdelkader Boudih
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-15 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -220,7 +219,6 @@ 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
@@ -235,8 +233,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Provides essential tooling for building Model Context Protocol (MCP) capable
   servers