actionmcp 0.29.0 → 0.30.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e4c587dbf08153dbc1b3c04a9a65be8accf56959e5f3c1e336c84950ca32936
-  data.tar.gz: c6fd2f8e495eaf00e30cd88a9022ab31cde81a24c90dda056cfc1ba9bc0e6526
+  metadata.gz: 4812289fae53550ca8bdf3912945b3176d3b2e12b4d7c025399b5ba7ae09f5de
+  data.tar.gz: 2dc3ca3cdfb2ca303724534b31904772be67db652ca437af559fcf5f1e39ea5c
 SHA512:
-  metadata.gz: d52f4037a16226d74929dc4bff5a6d5b3dbf5b9f4774b5521dc1dc2e107689e4de6271d3ba327ba124f114b7631f29f8d357f534954b55f996b31f281ae6bfbd
-  data.tar.gz: a08bda7ee781728e75477c1aa943728440ced72b42d71123d596fe6ff13f84893bbec8862071dde69b8452918735329adb4b97a95a55271f458fc578320ebd23
+  metadata.gz: b0dc0aa934e8b3fcc7f359f04f601de09898037820cc302dae0c67542fe74d1a8a1a43623d1156b6d0d7e680e8da5ecac8c64d72a38e97b364b7a6ed1e58ad7e
+  data.tar.gz: b16f4cbbddea8dff1ad52de97f7f0a6510bf0ba0fa65c19ca7ed3f0e017e3053a80d19c30ee600b1172552324acc7590ddaf39c5a161709f4387abd5aed5f4dd

data/app/controllers/action_mcp/mcp_controller.rb

@@ -8,8 +8,76 @@ module ActionMCP
     end
     include Engine.routes.url_helpers
 
+    # Header name for MCP Session ID (as per 2025-03-26 spec)
+    MCP_SESSION_ID_HEADER = "Mcp-Session-Id"
+
+    # Provides the ActionMCP::Session for the current request.
+    # Handles finding existing sessions via header/param or initializing a new one.
+    # Specific controllers/handlers might need to enforce session ID presence based on context.
+    # @return [ActionMCP::Session] The session object (might be unsaved if new)
+    def mcp_session
+      @mcp_session ||= find_or_initialize_session
+    end
+
+    # Provides a unique key for caching or pub/sub based on the session ID.
+    # Ensures mcp_session is called first to establish the session ID.
+    # @return [String] The session key string.
     def session_key
-      @session_key = "action_mcp-sessions-#{session_id}"
+      @session_key ||= "action_mcp-sessions-#{mcp_session.id}"
+    end
+
+    private
+
+    # Finds an existing session based on header or param, or initializes a new one.
+    # Note: This doesn't save the new session; that happens upon first use or explicitly.
+    def find_or_initialize_session
+      session_id = extract_session_id
+      if session_id
+        # Attempt to find the session by ID. Return nil if not found.
+        # Controllers should handle the nil case (e.g., return 404).
+        Session.find_by(id: session_id)
+      else
+        # No session ID provided, initialize a new one (likely for 'initialize' request).
+        Session.new
+      end
+    end
+
+    # Extracts the session ID from the request header or parameters.
+    # Prefers the Mcp-Session-Id header (new spec) over the param (old spec).
+    # @return [String, nil] The extracted session ID or nil if not found.
+    def extract_session_id
+      request.headers[MCP_SESSION_ID_HEADER].presence || params[:session_id].presence
+    end
+
+    # Renders a 400 Bad Request response with a JSON-RPC-like error structure.
+    def render_bad_request(message = "Bad Request")
+      # Using -32600 for Invalid Request based on JSON-RPC spec
+      render json: { jsonrpc: "2.0", error: { code: -32_600, message: message } }, status: :bad_request
+    end
+
+    # Renders a 404 Not Found response with a JSON-RPC-like error structure.
+    def render_not_found(message = "Not Found")
+      # Using a custom code or a generic server error range code might be appropriate.
+      # Let's use -32001 for a generic server error.
+      render json: { jsonrpc: "2.0", error: { code: -32_001, message: message } }, status: :not_found
+    end
+
+    # Renders a 405 Method Not Allowed response.
+    def render_method_not_allowed(message = "Method Not Allowed")
+      # Using -32601 Method not found from JSON-RPC spec seems applicable
+      render json: { jsonrpc: "2.0", error: { code: -32_601, message: message } }, status: :method_not_allowed
+    end
+
+    # Renders a 406 Not Acceptable response.
+    def render_not_acceptable(message = "Not Acceptable")
+      # No direct JSON-RPC equivalent, using a generic server error code.
+      render json: { jsonrpc: "2.0", error: { code: -32_002, message: message } }, status: :not_acceptable
+    end
+
+    # Renders a 501 Not Implemented response.
+    def render_not_implemented(message = "Not Implemented")
+      # No direct JSON-RPC equivalent, using a generic server error code.
+      render json: { jsonrpc: "2.0", error: { code: -32_003, message: message } }, status: :not_implemented
     end
   end
 end

data/app/controllers/action_mcp/sse_controller.rb

@@ -61,16 +61,20 @@ module ActionMCP
 
         # Setup recurring heartbeat using ScheduledTask with proper cancellation
         heartbeat_task = nil
-        heartbeat_sender = -> do
+        heartbeat_sender = lambda do
           if connection_active.true? && !response.stream.closed?
             begin
               # Try to send heartbeat with a controlled execution time
               future = Concurrent::Promises.future do
-                sse.write({ ping: true })
+                ping_request = JSON_RPC::Request.new(
+                  id: SecureRandom.uuid_v7, # Generate a unique ID for each ping
+                  method: "ping"
+                ).to_h
+                sse.write(ping_request)
               end
 
               # Wait for the heartbeat with timeout
-              result = future.value(5) # 5 second timeout
+              future.value(5) # 5 second timeout
 
               # Schedule the next heartbeat if this one succeeded
               if heartbeat_active.true?
@@ -92,9 +96,7 @@ module ActionMCP
         heartbeat_task = Concurrent::ScheduledTask.execute(HEARTBEAT_INTERVAL, &heartbeat_sender)
 
         # Wait for connection to be closed or cancelled
-        while connection_active.true? && !response.stream.closed?
-          sleep 0.1
-        end
+        sleep 0.1 while connection_active.true? && !response.stream.closed?
       rescue ActionController::Live::ClientDisconnected, IOError => e
         Rails.logger.debug "SSE: Client disconnected: #{e.message}"
       rescue StandardError => e
@@ -115,9 +117,9 @@ module ActionMCP
     private
 
     def build_timeout_error
-      JsonRpc::Response.new(
+      JSON_RPC::Response.new(
         id: SecureRandom.uuid_v7,
-        error: JsonRpc::JsonRpcError.new(
+        error: JSON_RPC::JsonRpcError.new(
           :server_error,
           message: "No message received within initial connection timeout"
         ).to_h
@@ -125,9 +127,9 @@ module ActionMCP
     end
 
     def build_listener_error
-      JsonRpc::Response.new(
+      JSON_RPC::Response.new(
         id: SecureRandom.uuid_v7,
-        error: JsonRpc::JsonRpcError.new(
+        error: JSON_RPC::JsonRpcError.new(
           :server_error,
           message: "Failed to establish server connection"
         ).to_h
@@ -155,71 +157,4 @@ module ActionMCP
       mcp_session.session_key
     end
   end
-
-  class SSEListener
-    attr_reader :session_key, :adapter
-
-    delegate :session_key, :adapter, to: :@session
-
-    # @param session [ActionMCP::Session]
-    def initialize(session)
-      @session = session
-      @stopped = Concurrent::AtomicBoolean.new(false)
-      @subscription_active = Concurrent::AtomicBoolean.new(false)
-    end
-
-    # Start listening using ActionCable's adapter
-    def start(&callback)
-      Rails.logger.debug "Starting listener for channel: #{session_key}"
-
-      success_callback = lambda {
-        Rails.logger.info "Successfully subscribed to channel: #{session_key}"
-        @subscription_active.make_true
-      }
-
-      # Set up message callback
-      message_callback = lambda { |raw_message|
-        return if @stopped.true?
-
-        begin
-          # Try to parse the message if it's JSON
-          message = MultiJson.load(raw_message)
-          # Send the message to the callback
-          callback.call(message) if callback
-        rescue StandardError => e
-          Rails.logger.error "Error processing message: #{e.message}"
-          # Still try to send the raw message as a fallback
-          callback.call(raw_message) if callback
-        end
-      }
-
-      # Subscribe using the ActionCable adapter
-      adapter.subscribe(session_key, message_callback, success_callback)
-
-      # Use a future with timeout to check subscription status
-      subscription_future = Concurrent::Promises.future do
-        while !@subscription_active.true? && !@stopped.true?
-          sleep 0.1
-        end
-        @subscription_active.true?
-      end
-
-      # Wait up to 1 second for subscription to be established
-      begin
-        subscription_result = subscription_future.value(1)
-        subscription_result || @subscription_active.true?
-      rescue Concurrent::TimeoutError
-        Rails.logger.warn "Timed out waiting for subscription activation"
-        false
-      end
-    end
-
-    def stop
-      @stopped.make_true
-      if (mcp_session = Session.find_by(id: session_key))
-        mcp_session.close
-      end
-      Rails.logger.debug "Unsubscribed from: #{session_key}"
-    end
-  end
-end
+end

data/app/controllers/action_mcp/unified_controller.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Handles the unified MCP endpoint for the 2025-03-26 specification.
+  # Supports GET for server-initiated SSE streams, POST for client messages
+  # (responding with JSON or SSE), and optionally DELETE for session termination.
+  class UnifiedController < MCPController
+    include ActionController::Live
+    # TODO: Include Instrumentation::ControllerRuntime if needed for metrics
+
+    # Handles GET requests for establishing server-initiated SSE streams (2025-03-26 spec).
+    # @route GET /mcp
+    def handle_get
+      # 1. Check Accept Header
+      unless request.accepts.any? { |type| type.to_s == "text/event-stream" }
+        return render_not_acceptable("Client must accept 'text/event-stream' for GET requests.")
+      end
+
+      # 2. Check Session (Must exist and be initialized)
+      session_id_from_header = extract_session_id
+      return render_bad_request("Mcp-Session-Id header is required for GET requests.") unless session_id_from_header
+
+      session = mcp_session # Finds based on header
+      if session.nil? || session.new_record?
+        return render_not_found("Session not found.")
+      elsif !session.initialized?
+        # Spec doesn't explicitly forbid GET before initialized, but it seems logical
+        return render_bad_request("Session is not fully initialized.")
+      elsif session.status == "closed"
+        return render_not_found("Session has been terminated.")
+      end
+
+      # TODO: Handle Last-Event-ID header for stream resumption
+
+      # 3. Set SSE Headers
+      response.headers["Content-Type"] = "text/event-stream"
+      response.headers["X-Accel-Buffering"] = "no"
+      response.headers["Cache-Control"] = "no-cache"
+      response.headers["Connection"] = "keep-alive"
+
+      Rails.logger.info "Unified SSE (GET): Starting stream for session: #{session.id}"
+
+      # 4. Setup Stream, Listener, and Heartbeat
+      sse = SSE.new(response.stream)
+      listener = SSEListener.new(session) # Use the listener class (defined below or moved)
+      connection_active = Concurrent::AtomicBoolean.new(true)
+      heartbeat_active = Concurrent::AtomicBoolean.new(true)
+      heartbeat_task = nil
+
+      # Start listener
+      listener_started = listener.start do |message|
+        # Write message using helper to include event ID
+        write_sse_event(sse, session, message)
+      end
+
+      unless listener_started
+        Rails.logger.error "Unified SSE (GET): Listener failed to activate for session: #{session.id}"
+        # Don't write error to stream as per spec for GET, just close
+        connection_active.make_false
+        return # Error logged, connection will close in ensure block
+      end
+
+      # Heartbeat sender proc
+      heartbeat_sender = lambda do
+        if connection_active.true? && !response.stream.closed?
+          begin
+            # Use helper to send ping with event ID
+            future = Concurrent::Promises.future { write_sse_event(sse, session, { type: "ping" }) }
+            future.value!(5) # 5 second timeout for write
+            if heartbeat_active.true?
+              heartbeat_task = Concurrent::ScheduledTask.execute(ActionMCP.configuration.sse_heartbeat_interval,
+                                                                 &heartbeat_sender)
+            end
+          rescue Concurrent::TimeoutError
+            Rails.logger.warn "Unified SSE (GET): Heartbeat timed out for session: #{session.id}, closing."
+            connection_active.make_false
+          rescue StandardError => e
+            Rails.logger.debug "Unified SSE (GET): Heartbeat error for session: #{session.id}: #{e.message}"
+            connection_active.make_false
+          end
+        else
+          heartbeat_active.make_false
+        end
+      end
+
+      # Start first heartbeat
+      heartbeat_task = Concurrent::ScheduledTask.execute(HEARTBEAT_INTERVAL, &heartbeat_sender)
+
+      # Keep connection alive while active
+      sleep 0.1 while connection_active.true? && !response.stream.closed?
+    rescue ActionController::Live::ClientDisconnected, IOError => e
+      Rails.logger.debug "Unified SSE (GET): Client disconnected for session: #{session&.id}: #{e.message}"
+    rescue StandardError => e
+      Rails.logger.error "Unified SSE (GET): Unexpected error for session: #{session&.id}: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+    ensure
+      # Cleanup
+      Rails.logger.debug "Unified SSE (GET): Cleaning up connection for session: #{session&.id}"
+      heartbeat_active&.make_false
+      heartbeat_task&.cancel
+      listener&.stop
+      # Don't close the session itself here, it might be used by other connections/requests
+      sse&.close
+      begin
+        response.stream&.close
+      rescue StandardError
+        nil
+      end
+    end
+
+    # Handles POST requests containing client JSON-RPC messages according to 2025-03-26 spec.
+    # @route POST /mcp
+    def handle_post
+      # 1. Check Accept Header
+      unless accepts_valid_content_types?
+        return render_not_acceptable("Client must accept 'application/json' and 'text/event-stream'")
+      end
+
+      # 2. Parse Request Body
+      parsed_body = parse_request_body
+      return unless parsed_body # Error rendered in parse_request_body
+
+      # Determine if this is an initialize request (before session check)
+      is_initialize_request = check_if_initialize_request(parsed_body)
+
+      # 3. Check Session (unless it's an initialize request)
+      session_initially_missing = extract_session_id.nil?
+      session = mcp_session # This finds or initializes
+      unless is_initialize_request
+        if session_initially_missing
+          return render_bad_request("Mcp-Session-Id header is required for this request.")
+        elsif session.nil? || session.new_record? # Should be found if ID was provided
+          return render_not_found("Session not found.")
+        elsif session.status == "closed"
+          return render_not_found("Session has been terminated.")
+        end
+      end
+
+      # 4. Instantiate Handlers
+      transport_handler = Server::TransportHandler.new(session)
+      json_rpc_handler = Server::JsonRpcHandler.new(transport_handler)
+
+      # 5. Call Handler
+      handler_results = json_rpc_handler.call(parsed_body)
+
+      # 6. Process Results
+      process_handler_results(handler_results, session, session_initially_missing, is_initialize_request)
+    rescue ActionController::Live::ClientDisconnected, IOError => e
+      # Ensure stream is closed if SSE response was attempted and client disconnected
+      Rails.logger.debug "Unified SSE (POST): Client disconnected during response: #{e.message}"
+      # Ensure stream is closed, cleanup might happen in ensure block if needed
+      begin
+        response.stream&.close
+      rescue StandardError
+        nil
+      end
+    rescue StandardError => e
+      Rails.logger.error "Unified POST Error: #{e.class} - #{e.message}\n#{e.backtrace.join("\n")}"
+      render_internal_server_error("An unexpected error occurred.") unless performed?
+    end
+
+    # Handles DELETE requests for session termination (2025-03-26 spec).
+    # @route DELETE /mcp
+    def handle_delete
+      allow_termination = ActionMCP.configuration.allow_client_session_termination
+
+      unless allow_termination
+        return render_method_not_allowed("Session termination via DELETE is not supported by this server.")
+      end
+
+      # 1. Check Session Header
+      session_id_from_header = extract_session_id
+      return render_bad_request("Mcp-Session-Id header is required for DELETE requests.") unless session_id_from_header
+
+      # 2. Find Session
+      # Note: mcp_session helper finds based on header, but doesn't raise error if not found
+      session = Session.find_by(id: session_id_from_header)
+
+      if session.nil?
+        return render_not_found("Session not found.")
+      elsif session.status == "closed"
+        # Session already closed, treat as success (idempotent)
+        return head :no_content
+      end
+
+      # 3. Terminate Session
+      begin
+        session.close! # This should handle cleanup like unsubscribing etc.
+        Rails.logger.info "Unified DELETE: Terminated session: #{session.id}"
+        head :no_content
+      rescue StandardError => e
+        Rails.logger.error "Unified DELETE: Error terminating session #{session.id}: #{e.class} - #{e.message}"
+        render_internal_server_error("Failed to terminate session.")
+      end
+    end
+
+    private
+
+    # Checks if the client's Accept header includes the required types.
+    def accepts_valid_content_types?
+      request.accepts.any? { |type| type.to_s == "application/json" } &&
+        request.accepts.any? { |type| type.to_s == "text/event-stream" }
+    end
+
+    # Parses the JSON request body. Renders error if invalid.
+    def parse_request_body
+      body = request.body.read
+      MultiJson.load(body)
+    rescue MultiJson::ParseError => e
+      render_bad_request("Invalid JSON in request body: #{e.message}")
+      nil # Indicate failure
+    end
+
+    # Checks if the parsed body represents an 'initialize' request.
+    def check_if_initialize_request(parsed_body)
+      if parsed_body.is_a?(Hash) && parsed_body["method"] == "initialize"
+        true
+      elsif parsed_body.is_a?(Array) # Cannot be in a batch
+        false
+      else
+        false
+      end
+    end
+
+    # Processes the results from the JsonRpcHandler.
+    def process_handler_results(results, session, session_initially_missing, is_initialize_request)
+      case results[:type]
+      when :error
+        # Handle handler-level errors (e.g., batch parse error)
+        render json: results[:payload], status: results.fetch(:status, :bad_request)
+      when :notifications_only
+        # No response needed, just accept
+        head :accepted
+      when :responses
+        # Determine response format based on server preference and client acceptance.
+        # Client MUST accept both 'application/json' and 'text/event-stream' (checked earlier).
+        server_preference = ActionMCP.configuration.post_response_preference # :json or :sse
+        use_sse = (server_preference == :sse)
+
+        # Add session ID header if this was a successful initialize request that created the session
+        add_session_header = is_initialize_request && session_initially_missing && session.persisted?
+
+        if use_sse
+          render_sse_response(results[:payload], session, add_session_header)
+        else
+          render_json_response(results[:payload], session, add_session_header)
+        end
+      else
+        # Should not happen
+        render_internal_server_error("Unknown handler result type: #{results[:type]}")
+      end
+    end
+
+    # Renders the JSON-RPC response(s) as a direct JSON HTTP response.
+    def render_json_response(payload, session, add_session_header)
+      response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
+      response.headers["Content-Type"] = "application/json"
+      render json: payload, status: :ok
+    end
+
+    # Renders the JSON-RPC response(s) as an SSE stream.
+    def render_sse_response(payload, session, add_session_header)
+      response.headers[MCP_SESSION_ID_HEADER] = session.id if add_session_header
+      response.headers["Content-Type"] = "text/event-stream"
+      response.headers["X-Accel-Buffering"] = "no"
+      response.headers["Cache-Control"] = "no-cache"
+      response.headers["Connection"] = "keep-alive"
+
+      sse = SSE.new(response.stream)
+      # TODO: Add logic for sending related server requests/notifications before/after response?
+
+      if payload.is_a?(Array)
+        # Send batched responses as separate events or one event? Spec allows batching.
+        # Let's send as one event for now, using one ID for the batch.
+      end
+      write_sse_event(sse, session, payload)
+    ensure
+      # Close the stream after sending the response(s)
+      sse&.close
+      begin
+        response.stream&.close
+      rescue StandardError
+        nil
+      end
+      Rails.logger.debug "Unified SSE (POST): Response stream closed."
+    end
+
+    # Renders a 500 Internal Server Error response.
+    def render_internal_server_error(message = "Internal Server Error")
+      # Using -32000 for generic server error
+      render json: { jsonrpc: "2.0", error: { code: -32_000, message: message } }, status: :internal_server_error
+    end
+
+    # Helper to write a JSON payload as an SSE event with a unique ID.
+    def write_sse_event(sse, session, payload)
+      event_id = session.increment_sse_counter!
+      # Manually format the SSE event string including the ID
+      data = MultiJson.dump(payload)
+      sse.stream.write("id: #{event_id}\ndata: #{data}\n\n")
+    end
+
+    # TODO: Add methods for handle_get (SSE setup, listener, heartbeat) - Partially Done
+    # TODO: Add method for handle_delete (session termination) - DONE (Basic)
+  end
+end

data/app/models/action_mcp/session.rb

@@ -14,6 +14,7 @@
 #  role(The role of the session)                       :string           default("server"), not null
 #  server_capabilities(The capabilities of the server) :jsonb
 #  server_info(The information about the server)       :jsonb
+#  sse_event_counter                                   :integer          default(0), not null
 #  status                                              :string           default("pre_initialize"), not null
 #  created_at                                          :datetime         not null
 #  updated_at                                          :datetime         not null
@@ -63,7 +64,7 @@ module ActionMCP
 
     # MESSAGING dispatch
     def write(data)
-      if data.is_a?(JsonRpc::Request) || data.is_a?(JsonRpc::Response) || data.is_a?(JsonRpc::Notification)
+      if data.is_a?(JSON_RPC::Request) || data.is_a?(JSON_RPC::Response) || data.is_a?(JSON_RPC::Notification)
         data = data.to_json
       end
       data = MultiJson.dump(data) if data.is_a?(Hash)
@@ -124,7 +125,7 @@ module ActionMCP
 
     def send_ping!
       Session.logger.silence do
-        write(JsonRpc::Request.new(id: Time.now.to_i, method: "ping"))
+        write(JSON_RPC::Request.new(id: Time.now.to_i, method: "ping"))
       end
     end
 
@@ -136,6 +137,16 @@ module ActionMCP
       subscriptions.find_by(uri: uri)&.destroy
     end
 
+    # Atomically increments the SSE event counter and returns the new value.
+    # This ensures unique, sequential IDs for SSE events within the session.
+    # @return [Integer] The new value of the counter.
+    def increment_sse_counter!
+      # Use update_counters for an atomic increment operation
+      self.class.update_counters(id, sse_event_counter: 1)
+      # Reload to get the updated value (update_counters doesn't update the instance)
+      reload.sse_event_counter
+    end
+
     private
 
     # if this session is from a server, the writer is the client

data/config/routes.rb

@@ -1,6 +1,13 @@
 # frozen_string_literal: true
 
 ActionMCP::Engine.routes.draw do
+  # --- Routes for 2024-11-05 Spec (HTTP+SSE) ---
+  # Kept for backward compatibility
   get "/", to: "sse#events", as: :sse_out
   post "/", to: "messages#create", as: :sse_in, defaults: { format: "json" }
+
+  # --- Routes for 2025-03-26 Spec (Streamable HTTP) ---
+  mcp_endpoint = ActionMCP.configuration.mcp_endpoint_path
+  get mcp_endpoint, to: "unified#handle_get", as: :mcp_get
+  post mcp_endpoint, to: "unified#handle_post", as: :mcp_post
 end

data/db/migrate/20250327124131_add_sse_event_counter_to_action_mcp_sessions.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddSSEEventCounterToActionMCPSessions < ActiveRecord::Migration[8.0]
+  def change
+    add_column :action_mcp_sessions, :sse_event_counter, :integer, default: 0, null: false
+  end
+end

data/exe/actionmcp_cli

@@ -92,7 +92,7 @@ def parse_command(input)
       arguments[key] = parsed_value
     end
 
-    ActionMCP::JsonRpc::Request.new(
+    JSON_RPC::Request.new(
       id: generate_request_id,
       method: 'tools/get',
       params: {
@@ -101,12 +101,12 @@ def parse_command(input)
       }
     )
   when 'list_tools'
-    ActionMCP::JsonRpc::Request.new(
+    JSON_RPC::Request.new(
       id: generate_request_id,
       method: 'tools/list'
     )
   when 'list_prompts'
-    ActionMCP::JsonRpc::Request.new(
+    JSON_RPC::Request.new(
       id: generate_request_id,
       method: 'prompts/list'
     )
@@ -188,7 +188,7 @@ loop do
           json = MultiJson.load(input)
           # Validate that the parsed JSON has the required fields
           if json['method']
-            request = ActionMCP::JsonRpc::Request.new(
+            request = JSON_RPC::Request.new(
               id: json['id'] || generate_request_id,
               method: json['method'],
               params: json['params']
@@ -200,7 +200,7 @@ loop do
         rescue MultiJson::ParseError => e
           puts "Invalid input: not a valid command or JSON. #{e.message}"
           next
-        rescue ActionMCP::JsonRpc::JsonRpcError => e
+        rescue JSON_RPC::JsonRpcError => e
           puts "Invalid JSON-RPC request: #{e.message}"
           next
         end

data/lib/action_mcp/base_response.rb

@@ -21,7 +21,7 @@ module ActionMCP
     # Convert to hash format expected by MCP protocol
     def to_h
       if @is_error
-        JsonRpc::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
+        JSON_RPC::JsonRpcError.new(@symbol, message: @error_message, data: @error_data).to_h
       else
         build_success_hash
       end

data/lib/action_mcp/client/messaging.rb

@@ -4,23 +4,23 @@ module ActionMCP
   module Client
     module Messaging
       def send_jsonrpc_request(method, params: nil, id: SecureRandom.uuid_v7)
-        request = JsonRpc::Request.new(id: id, method: method, params: params)
+        request = JSON_RPC::Request.new(id: id, method: method, params: params)
         write_message(request)
       end
 
       def send_jsonrpc_response(request_id, result: nil, error: nil)
-        response = JsonRpc::Response.new(id: request_id, result: result, error: error)
+        response = JSON_RPC::Response.new(id: request_id, result: result, error: error)
         write_message(response)
       end
 
       def send_jsonrpc_notification(method, params = nil)
-        notification = JsonRpc::Notification.new(method: method, params: params)
+        notification = JSON_RPC::Notification.new(method: method, params: params)
         write_message(notification)
       end
 
       def send_jsonrpc_error(request_id, symbol, message, data = nil)
-        error = JsonRpc::JsonRpcError.new(symbol, message:, data:)
-        response = JsonRpc::Response.new(id: request_id, error:)
+        error = JSON_RPC::JsonRpcError.new(symbol, message:, data:)
+        response = JSON_RPC::Response.new(id: request_id, error:)
         write_message(response)
       end
     end