actionmcp 0.50.7 → 0.50.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17696f3f1e92327c6de4d8fa4ae5b6585bf8d9e173acb47beaf713dd9d1f8b07
-  data.tar.gz: 536f24be37c5c2fbc4f440fbf1c977eadee964cd6717be5981d63cbd35081cb7
+  metadata.gz: d09ebd13460c234fc23c4c509ffec0b9cb48ea6607108217be7309aee8dbf617
+  data.tar.gz: b269226676ee4974b7757093e721cca942eb7acb60e47fa72b6999b780a7bf7f
 SHA512:
-  metadata.gz: cf5c45e416e66526ee4550d611e0bbea71a3150b2f8f02af58899450308399c27e3f710348feed1d8478b27acc6701b1d01e9d6e6ab4e6f763f43ede2051d526
-  data.tar.gz: 8a27fae5101d5deb20e5f3b3b7da0a2d3d5bdfdef04681737de63f985a34a7f8cb4e3f8a9f08ae2cf886662f7855c453b19325eb5ae3ce5ec9bca141cc5bcde7
+  metadata.gz: e6300709a72e3d8c54d23c4c2ba23bd751c2bac1b5c25f7b7ba5a8ff6d60f455571ef4b1a8e212b2cb22d05b3e06b803926d5b39d2daf9446b38d6296ea3277a
+  data.tar.gz: a2385c3f8910c27b8b36ce7d8cef73d6cf6db18922c0b6d9a7f51abd43d5a06a35f04e715cbfe32b1dbf7c8793a72f4d94b0142553d94e4360b9b1e5825164f9

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
 
@@ -332,7 +313,6 @@ module ActionMCP
       data = payload.is_a?(String) ? payload : MultiJson.dump(payload)
       sse_event = "id: #{event_id}\ndata: #{data}\n\n"
       sse.write(sse_event)
-      return unless ActionMCP.configuration.enable_sse_resumability
 
       begin
         session.store_sse_event(event_id, payload, session.max_stored_sse_events)
@@ -343,8 +323,6 @@ module ActionMCP
 
     # Helper to clean up old SSE events for a session
     def cleanup_old_sse_events(session)
-      return unless ActionMCP.configuration.enable_sse_resumability
-
       begin
         retention_period = session.sse_event_retention_period
         count = session.cleanup_old_sse_events(retention_period)

data/lib/action_mcp/configuration.rb

@@ -29,7 +29,6 @@ module ActionMCP
                   # --- VibedIgnoreVersion Option ---
                   :vibed_ignore_version,
                   # --- SSE Resumability Options ---
-                  :enable_sse_resumability,
                   :sse_event_retention_period,
                   :max_stored_sse_events
 
@@ -46,7 +45,6 @@ module ActionMCP
       @vibed_ignore_version = false
 
       # Resumability defaults
-      @enable_sse_resumability = true
       @sse_event_retention_period = 15.minutes
       @max_stored_sse_events = 100
     end
@@ -141,9 +139,6 @@ module ActionMCP
 
       capabilities[:resources] = { subscribe: @resources_subscribe } if filtered_resources.any?
 
-      # Add resumability capability if enabled
-      capabilities[:resumability] = { enabled: @enable_sse_resumability } if @enable_sse_resumability
-
       capabilities
     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/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actionmcp
 version: !ruby/object:Gem::Version
-  version: 0.50.7
+  version: 0.50.10
 platform: ruby
 authors:
 - Abdelkader Boudih