active_mcp 0.9.1 → 0.9.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de9c4899c65706f1fb1281e3ac52c7eb5399e4ac6e0224dce35e0ef532779df7
-  data.tar.gz: ad0abe6c7af1b985260fbea629302fa5bcb69f1ac1c94455ccb187e771664691
+  metadata.gz: a2bdc655ae59a42ab77ecf1767f4a6717be9586100b51d1f6436da37346be92f
+  data.tar.gz: 682c5b2b9ce9d08983172d3cca17ee0a12c98169c081bbf06bb90ad361d8bd73
 SHA512:
-  metadata.gz: 8416f28a91cfbc836a78e05b5790b70e0236450f6d901f48df2070dae02095f5e8f436cb39f05dc2a4edd57240c5c8bba99e1a7a32b365c04cac6ec5ed32faaa
-  data.tar.gz: b3cacc88a0649c82959aaf7fa9b3f39fc0d9b9f3c2c1135ad82282667c92ecda8ce71ddc84d7133694a790fcb6a69caa3c45c48f7196662d4952e9c56d304aba
+  metadata.gz: 53e87889ab3a2a9dc1a87a97f9c0181ee9d38d57ce332e70c9096da99df0630b6f16ce2d3e6fff16642216bf1cc509121b0ca6817118dd48e811b1bc62db4a04
+  data.tar.gz: edbff3c0e32089eda22d0c6aa90670f7857b31a253142e3f60517e37c509bb46c7ab488ad6577f3dd991c1d3fb29f21984750d6a83b2465e061ff856be90eed6

data/README.md

@@ -344,7 +344,6 @@ Resources are Ruby classes `**Resource`:
 class UserResource < ActiveMcp::Resource::Base
   def initialize(id:)
     @user = User.find(id)
-    @auth_info = auth_info
   end
 
   def resource_name
@@ -411,7 +410,7 @@ class ImageResource < ActiveMcp::Resource::Base
   end
 
   def resource_name
-    "Profile Image"
+    "profile_image"
   end
 
   def uri
@@ -453,7 +452,7 @@ Resources are Ruby classes `**ResourceTemplates`:
 class UserResource < ActiveMcp::Resource::Base
   class << self
     def resource_template_name
-      "Users"
+      "users"
     end
 
     def uri_template
@@ -593,7 +592,7 @@ end
 Always validate and sanitize inputs in your tool implementations:
 
 ```ruby
-def call(user_id:, **args, context: {})
+def call(user_id:, context: {})
   # Validate input
   unless user_id.is_a?(Integer) || user_id.to_s.match?(/^\d+$/)
     raise "Invalid user ID format"

data/app/controllers/concerns/active_mcp/request_handlable.rb

@@ -12,50 +12,50 @@ module ActiveMcp
 
     def handle_mcp_client_request
       @id = params[:id]
-      
+
       case params[:method]
       when Method::INITIALIZE
-        render 'active_mcp/initialize', formats: :json
+        render "active_mcp/initialize", formats: :json
       when Method::INITIALIZED
-        render 'active_mcp/initialized', formats: :json
+        render "active_mcp/initialized", formats: :json
       when Method::CANCELLED
-        render 'active_mcp/cancelled', formats: :json
+        render "active_mcp/cancelled", formats: :json
       when Method::RESOURCES_LIST
         @resources = schema.resources
         @format = :jsonrpc
-        render 'active_mcp/resources_list', formats: :json
+        render "active_mcp/resources_list", formats: :json
       when Method::RESOURCES_TEMPLATES_LIST
         @resource_templates = schema.resource_templates
         @format = :jsonrpc
-        render 'active_mcp/resource_templates_list', formats: :json
+        render "active_mcp/resource_templates_list", formats: :json
       when Method::RESOURCES_READ
         @resource = read_resource(params:, context:)
         @format = :jsonrpc
-        render 'active_mcp/resources_read', formats: :json
+        render "active_mcp/resources_read", formats: :json
       when Method::TOOLS_LIST
         @tools = schema.tools
         @format = :jsonrpc
-        render 'active_mcp/tools_list', formats: :json
+        render "active_mcp/tools_list", formats: :json
       when Method::TOOLS_CALL
         @tool_result = execute_tool(params:, context:)
         @format = :jsonrpc
-        render 'active_mcp/tools_call', formats: :json
+        render "active_mcp/tools_call", formats: :json
       when Method::COMPLETION_COMPLETE
         type = params.dig(:params, :ref, :type)
-        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: type === "ref/resource" ? schema.resource_templates : schema.prompts)
+        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: (type === "ref/resource") ? schema.resource_templates : schema.prompts)
         @format = :jsonrpc
         render "active_mcp/completion_complete", formats: :json
       when Method::PROMPTS_LIST
         @prompts = schema.prompts
         @format = :jsonrpc
-        render 'active_mcp/prompts_list', formats: :json
+        render "active_mcp/prompts_list", formats: :json
       when Method::PROMPTS_GET
         @prompt = schema.prompts.find { _1.prompt_name == params[:params][:name] }.new(**params[:params][:arguments].permit!.to_h.symbolize_keys)
         @format = :jsonrpc
-        render 'active_mcp/prompts_get', formats: :json
+        render "active_mcp/prompts_get", formats: :json
       else
         @format = :jsonrpc
-        render 'active_mcp/no_method', formats: :json
+        render "active_mcp/no_method", formats: :json
       end
     end
 
@@ -64,39 +64,39 @@ module ActiveMcp
       when Method::RESOURCES_LIST
         @resources = schema.resources
         @format = :json
-        render 'active_mcp/resources_list', formats: :json
+        render "active_mcp/resources_list", formats: :json
       when Method::RESOURCES_READ
         @resource = read_resource(params:, context:)
         @format = :json
-        render 'active_mcp/resources_read', formats: :json
+        render "active_mcp/resources_read", formats: :json
       when Method::RESOURCES_TEMPLATES_LIST
         @resource_templates = schema.resource_templates
         @format = :json
-        render 'active_mcp/resource_templates_list', formats: :json
+        render "active_mcp/resource_templates_list", formats: :json
       when Method::TOOLS_LIST
         @tools = schema.tools
         @format = :json
-        render 'active_mcp/tools_list', formats: :json
+        render "active_mcp/tools_list", formats: :json
       when Method::TOOLS_CALL
         @tool_result = execute_tool(params:, context:)
         @format = :json
-        render 'active_mcp/tools_call', formats: :json
+        render "active_mcp/tools_call", formats: :json
       when Method::COMPLETION_COMPLETE
         type = params.dig(:params, :ref, :type)
-        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: type == "ref/resource" ? schema.resource_templates : schema.prompts)
+        @completion = ActiveMcp::Completion.new.complete(params: params[:params], context:, refs: (type == "ref/resource") ? schema.resource_templates : schema.prompts)
         @format = :json
         render "active_mcp/completion_complete", formats: :json
       when Method::PROMPTS_LIST
         @prompts = schema.prompts
         @format = :json
-        render 'active_mcp/prompts_list', formats: :json
+        render "active_mcp/prompts_list", formats: :json
       when Method::PROMPTS_GET
-        @prompt = schema.prompts&.find { _1.prompt_name == params[:params][:name] }.new(**params[:params][:arguments].permit!.to_h.symbolize_keys)
+        @prompt = schema.prompts&.find { _1.prompt_name == params[:params][:name] }&.new(**params[:params][:arguments].permit!.to_h.symbolize_keys)
         @format = :json
-        render 'active_mcp/prompts_get', formats: :json
+        render "active_mcp/prompts_get", formats: :json
       else
         @format = :json
-        render 'active_mcp/no_method', formats: :json
+        render "active_mcp/no_method", formats: :json
       end
     end
 

data/app/controllers/concerns/active_mcp/resource_readable.rb

@@ -5,10 +5,10 @@ module ActiveMcp
     private
 
     def read_resource(params:, context:)
-      if params[:jsonrpc].present?
-        uri = params[:params][:uri]
+      uri = if params[:jsonrpc].present?
+        params[:params][:uri]
       else
-        uri = params[:uri]
+        params[:uri]
       end
 
       unless uri
@@ -37,8 +37,8 @@ module ActiveMcp
       end
 
       begin
-        if resource.respond_to?(:text) && content = resource.content
-          return {
+        if resource.respond_to?(:text) && (content = resource.content)
+          {
             contents: [
               {
                 uri:,
@@ -47,8 +47,8 @@ module ActiveMcp
               }
             ]
           }
-        elsif content = resource.blob
-          return {
+        elsif (content = resource.blob)
+          {
             contents: [
               {
                 uri:,
@@ -59,7 +59,7 @@ module ActiveMcp
           }
         end
       rescue
-        return {
+        {
           isError: true,
           contents: []
         }

data/app/controllers/concerns/active_mcp/tool_executable.rb

@@ -12,14 +12,14 @@ module ActiveMcp
         tool_name = params[:name]
         tool_params = params[:arguments]
       end
-      
+
       unless tool_name
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: "Invalid params: missing tool name",
+              text: "Invalid params: missing tool name"
             }
           ]
         }
@@ -28,44 +28,44 @@ module ActiveMcp
       tool = schema.tools.find do |tc|
         tc.tool_name == tool_name
       end
-      
+
       unless tool
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: "Tool not found: #{tool_name}",
+              text: "Tool not found: #{tool_name}"
             }
           ]
         }
       end
-      
+
       unless tool.visible?(context:)
         return {
           isError: true,
           content: [
             {
               type: "text",
-              text: "Unauthorized: Access to tool '#{tool_name}' denied",
+              text: "Unauthorized: Access to tool '#{tool_name}' denied"
             }
           ]
         }
       end
 
-      if tool_params.is_a?(String)
-        arguments = JSON.parse(tool_params).symbolize_keys
+      arguments = if tool_params.is_a?(String)
+        JSON.parse(tool_params).symbolize_keys
       elsif tool_params
-        arguments = tool_params.permit!.to_hash.symbolize_keys
+        tool_params.permit!.to_hash.symbolize_keys
       else
-        arguments = {}
+        {}
       end
 
       arguments = arguments.transform_values do |value|
         if !value.is_a?(String)
           value
         else
-          value.match(/^\d+$/) ? value.to_i : value
+          /^\d+$/.match?(value) ? value.to_i : value
         end
       end
 
@@ -77,15 +77,15 @@ module ActiveMcp
           content: [
             {
               type: "text",
-              text: validation_result[:error],
+              text: validation_result[:error]
             }
           ]
         }
       end
-      
+
       # Execute the tool
       begin
-        return {
+        {
           content: [
             {
               type: "text",
@@ -94,18 +94,18 @@ module ActiveMcp
           ]
         }
       rescue => e
-        return {
+        {
           isError: true,
           content: [
             {
               type: "text",
-              text: "Error: #{e.message}",
+              text: "Error: #{e.message}"
             }
           ]
         }
       end
     end
-    
+
     def formatted(object)
       case object
       when String

data/app/views/active_mcp/completion_complete.json.jbuilder

@@ -1,15 +1,8 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.completion do
-      json.values @completion[:values]
-      json.total @completion[:total]
-    end
-  end
-else
-  json.result do
+json.result do
+  json.completion do
     json.values @completion[:values]
     json.total @completion[:total]
   end

data/app/views/active_mcp/initialize.json.jbuilder

@@ -3,7 +3,7 @@ json.id @id
 json.result do
   json.protocolVersion ActiveMcp::PROTOCOL_VERSION
   json.capabilities do
-    json.logging Hash.new
+    json.logging({})
     json.capabilities do
       json.resources do
         json.subscribe false
@@ -18,4 +18,4 @@ json.result do
     json.name ActiveMcp.config.respond_to?(:server_name) ? ActiveMcp.config.server_name : "Active MCP Server"
     json.version ActiveMcp.config.respond_to?(:server_version) ? ActiveMcp.config.server_version : ActiveMcp::VERSION
   end
-end
+end

data/app/views/active_mcp/prompts_get.json.jbuilder

@@ -1,12 +1,7 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.description @prompt.class.description
-    json.messages @prompt.messages.map(&:to_h)
-  end
-else
+json.result do
   json.description @prompt.class.description
   json.messages @prompt.messages.map(&:to_h)
 end

data/app/views/active_mcp/prompts_list.json.jbuilder

@@ -1,18 +1,8 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.prompts do
-      json.array!(@prompts) do |prompt|
-        json.name prompt.prompt_name
-        json.description prompt.description
-        json.arguments prompt.arguments.map { _1.except(:complete) }
-      end
-    end
-  end
-else
-  json.result do
+json.result do
+  json.prompts do
     json.array!(@prompts) do |prompt|
       json.name prompt.prompt_name
       json.description prompt.description

data/app/views/active_mcp/resource_templates_list.json.jbuilder

@@ -1,19 +1,8 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.resourceTemplates do
-      json.array!(@resource_templates) do |resource|
-        json.name resource.resource_template_name
-        json.uriTemplate resource.uri_template
-        json.mimeType resource.mime_type
-        json.description resource.description
-      end
-    end
-  end
-else
-  json.result do
+json.result do
+  json.resourceTemplates do
     json.array!(@resource_templates) do |resource|
       json.name resource.resource_template_name
       json.uriTemplate resource.uri_template

data/app/views/active_mcp/resources_list.json.jbuilder

@@ -1,19 +1,8 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.resources do
-      json.array!(@resources) do |resource|
-        json.name resource.resource_name
-        json.uri resource.uri
-        json.mimeType resource.class.mime_type
-        json.description resource.description
-      end
-    end
-  end
-else
-  json.result do
+json.result do
+  json.resources do
     json.array!(@resources) do |resource|
       json.name resource.resource_name
       json.uri resource.uri

data/app/views/active_mcp/resources_read.json.jbuilder

@@ -1,16 +1,12 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result @resource
-else
-  json.isError @resource[:isError] if @resource[:isError]
-  json.contents do
-    json.array!(@resource[:contents]) do |content|
-      json.uri content[:uri]
-      json.mimeType raw content[:mimeType]
-      json.text raw content[:text] if content[:text]
-      json.blob content[:blob] if content[:blob]
-    end
+json.isError @resource[:isError] if @resource[:isError]
+json.contents do
+  json.array!(@resource[:contents]) do |content|
+    json.uri content[:uri]
+    json.mimeType raw content[:mimeType]
+    json.text raw content[:text] if content[:text]
+    json.blob content[:blob] if content[:blob]
   end
 end

data/app/views/active_mcp/tools_call.json.jbuilder

@@ -1,9 +1,7 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result @tool_result
-else
+json.result do
   json.isError @tool_result[:isError] if @tool_result[:isError]
   json.content do
     json.array!(@tool_result[:content]) do |content|

data/app/views/active_mcp/tools_list.json.jbuilder

@@ -1,18 +1,8 @@
 json.jsonrpc ActiveMcp::JSON_RPC_VERSION if @format == :jsonrpc
 json.id @id if @format == :jsonrpc && @id.present?
 
-if @format == :jsonrpc
-  json.result do
-    json.tools do
-      json.array!(@tools) do |tool|
-        json.name tool.tool_name
-        json.description tool.description
-        json.inputSchema tool.class.schema
-      end
-    end
-  end
-else
-  json.result do
+json.result do
+  json.tools do
     json.array!(@tools) do |tool|
       json.name tool.tool_name
       json.description tool.description

data/lib/active_mcp/completion.rb

@@ -9,11 +9,11 @@ module ActiveMcp
       if uri_template
         resource_class = refs.find { _1.uri_template == uri_template }
         values = resource_class.arguments[arg_name.to_sym].call(value)
-        { values:, total: values.length }
+        {values:, total: values.length}
       elsif ref_name
         prompt_class = refs.find { _1.prompt_name == ref_name }
         values = prompt_class.arguments.find { _1[:name] == arg_name.to_sym }[:complete].call(value)
-        { values:, total: values.length }
+        {values:, total: values.length}
       end
     end
   end

data/lib/active_mcp/message/resource.rb

@@ -14,7 +14,7 @@ module ActiveMcp
             resource: {
               uri: @resource.uri,
               mimeType: @resource.class.mime_type,
-              text: @resource.content,
+              text: @resource.content
             }
           }
         }

data/lib/active_mcp/prompt/base.rb

@@ -4,7 +4,7 @@ module ActiveMcp
       class << self
         attr_reader :arguments
 
-        def argument(name, required: false, description: nil, complete: ->(){})
+        def argument(name, required: false, description: nil, complete: -> {})
           @arguments ||= []
 
           @arguments << {

data/lib/active_mcp/resource/base.rb

@@ -8,7 +8,7 @@ module ActiveMcp
 
         def resource_template_name
         end
-  
+
         def description
         end
 

data/lib/active_mcp/server/fetcher.rb

@@ -5,7 +5,7 @@ module ActiveMcp
         @base_uri = base_uri
 
         if auth
-          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
+          @auth_header = "#{(auth[:type] == :bearer) ? "Bearer" : "Basic"} #{auth[:token]}"
         end
       end
 
@@ -13,20 +13,20 @@ module ActiveMcp
         return unless @base_uri
 
         require "net/http"
-        
+
         unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
           Server.log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
           return
         end
-        
+
         begin
           uri = URI.parse(@base_uri.to_s)
-          
+
           unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
             Server.log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
             return
           end
-          
+
           if defined?(Rails) && Rails.env.production? && uri.scheme != "https"
             Server.log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
             return
@@ -35,7 +35,7 @@ module ActiveMcp
           Server.log_error("Invalid URI format", e)
           return
         end
-        
+
         request = Net::HTTP::Post.new(uri)
         request.body = JSON.generate(params)
         request["Content-Type"] = "application/json"
@@ -49,6 +49,7 @@ module ActiveMcp
           JSON.parse(response.body, symbolize_names: true)
         rescue => e
           Server.log_error("Error fetching resource_templates", e)
+          nil
         end
       end
     end

data/lib/active_mcp/server/protocol_handler.rb

@@ -15,7 +15,11 @@ module ActiveMcp
         message = message.to_s.force_encoding("UTF-8")
         result = begin
           request = JSON.parse(message, symbolize_names: true)
-          handle_request(request)
+          if !request[:jsonrpc] || !request[:method]
+            error_response(nil, ErrorCode::INVALID_REQUEST, "Invalid JSON-RPC format")
+          else
+            handle_request(request)
+          end
         rescue JSON::ParserError => e
           Server.log_error("JSON parse error", e)
           error_response(nil, ErrorCode::PARSE_ERROR, "Invalid JSON format")
@@ -57,6 +61,9 @@ module ActiveMcp
         else
           error_response(request[:id], ErrorCode::METHOD_NOT_FOUND, "Unknown method: #{request[:method]}")
         end
+      rescue => e
+        Server.log_error("Error #{name}", e)
+        error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred")
       end
 
       def handle_initialize(request)
@@ -84,7 +91,7 @@ module ActiveMcp
             capabilities: {
               resources: {},
               tools: {},
-              prompts: {},
+              prompts: {}
             },
             serverInfo: {
               name: @server.name,
@@ -109,134 +116,72 @@ module ActiveMcp
       def handle_list_resources(request)
         success_response(
           request[:id],
-          {
-            resources: @server.fetch(
-              params: {
-                method: Method::RESOURCES_LIST,
-                arguments: {}
-              }
-            )[:result]
-          }
+          @server.fetch(
+            params: {
+              method: Method::RESOURCES_LIST,
+              arguments: {}
+            }
+          )[:result]
         )
       end
 
       def handle_list_resource_templates(request)
         success_response(
           request[:id],
-          {
-            resourceTemplates: @server.fetch(
-              params: {
-                method: Method::RESOURCES_TEMPLATES_LIST,
-                arguments: {}
-              }
-            )[:result]
-          }
+          @server.fetch(
+            params: {
+              method: Method::RESOURCES_TEMPLATES_LIST,
+              arguments: {}
+            }
+          )[:result]
         )
       end
 
       def handle_list_tools(request)
         success_response(
           request[:id],
-          {
-            tools: @server.fetch(
-              params: {
-                method: Method::TOOLS_LIST,
-                arguments: {}
-              }
-            )[:result]
-          }
+          @server.fetch(params: {method: Method::TOOLS_LIST, arguments: {}})[:result]
         )
       end
 
       def handle_call_tool(request)
         name = request.dig(:params, :name)
         arguments = request.dig(:params, :arguments) || {}
+        result = @server.fetch(params: {method: Method::TOOLS_CALL, name:, arguments:})
 
-        begin
-          result = @server.fetch(
-            params: {
-              method: Method::TOOLS_CALL,
-              name:,
-              arguments:,
-            }
-          )
-
-          success_response(request[:id], result)
-        rescue => e
-          Server.log_error("Error calling tool #{name}", e)
-          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while calling the tool")
-        end
+        success_response(request[:id], result[:result])
       end
 
       def handle_read_resource(request)
         uri = request.dig(:params, :uri)
-        begin
-          result = @server.fetch(
-            params: {
-              method: Method::RESOURCES_READ,
-              uri:,
-              arguments: {},
-            }
-          )
+        result = @server.fetch(params: {method: Method::RESOURCES_READ, uri:, arguments: {}})
 
-          success_response(request[:id], result)
-        rescue => e
-          Server.log_error("Error reading resource #{uri}", e)
-          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
-        end
+        success_response(request[:id], result[:result])
       end
 
       def handle_complete(request)
-        begin
-          result = @server.fetch(
-            params: {
-              method: Method::COMPLETION_COMPLETE,
-              params: request[:params],
-            }
-          )
-          success_response(request[:id], { completion: result[:result] })
-        rescue => e
-          Server.log_error("Error reading resource #{uri}", e)
-          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
-        end
+        result = @server.fetch(params: {method: Method::COMPLETION_COMPLETE, params: request[:params]})
+        success_response(request[:id], result[:result])
       end
 
       def handle_list_prompts(request)
-        begin
-          result = @server.fetch(params: { method: Method::PROMPTS_LIST })
-          success_response(request[:id], { prompts: result[:result] })
-        rescue => e
-          Server.log_error("Error reading resource #{uri}", e)
-          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
-        end
+        result = @server.fetch(params: {method: Method::PROMPTS_LIST})
+        success_response(request[:id], result[:result])
       end
 
       def handle_get_prompt(request)
         name = request.dig(:params, :name)
         arguments = request.dig(:params, :arguments)
-        begin
-          result = @server.fetch(
-            params: {
-              method: Method::PROMPTS_GET,
-              params: {
-                name:,
-                arguments:,
-              }
-            }
-          )
+        result = @server.fetch(params: {method: Method::PROMPTS_GET, params: {name:, arguments:}})
 
-          success_response(request[:id], result)
-        rescue => e
-          Server.log_error("Error reading resource #{uri}", e)
-          error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
-        end
+        success_response(request[:id], result)
       end
 
       def success_response(id, result)
         {
           jsonrpc: JSON_RPC_VERSION,
           id: id,
-          result: result
+          result:
         }
       end
 
@@ -245,8 +190,8 @@ module ActiveMcp
           jsonrpc: JSON_RPC_VERSION,
           id: id || 0,
           error: {
-            code: code,
-            message: message
+            code:,
+            message:
           }
         }
         response[:error][:data] = data if data

data/lib/active_mcp/server/stdio_connection.rb

@@ -8,11 +8,11 @@ module ActiveMcp
 
     def read_next_message
       message = $stdin.gets&.chomp
-      message.to_s.force_encoding("UTF-8")
+      message.to_s.dup.force_encoding("UTF-8")
     end
 
     def send_message(message)
-      message = message.to_s.force_encoding("UTF-8")
+      message = message.to_s.dup.force_encoding("UTF-8")
       $stdout.binmode
       $stdout.write(message + "\n")
       $stdout.flush

data/lib/active_mcp/server.rb

@@ -1,13 +1,40 @@
 require "json"
 require "English"
 require_relative "server/method"
-require_relative "server/error_codes"
+require_relative "server/error_code"
 require_relative "server/stdio_connection"
 require_relative "server/fetcher"
 require_relative "server/protocol_handler"
 
 module ActiveMcp
   class Server
+    class Logger
+      attr_reader :messages
+
+      def initialize
+        @messages = []
+      end
+
+      def log(message, error = nil)
+        @messages << {message: message, error: error}
+        if defined?(Rails)
+          Rails.logger.error("#{message}: #{error&.message}")
+        else
+          warn("#{message}: #{error&.message}")
+        end
+      end
+    end
+
+    class << self
+      def logger
+        @logger ||= Logger.new
+      end
+
+      def log_error(message, error)
+        logger.log(message, error)
+      end
+    end
+
     attr_reader :name, :version, :uri, :protocol_handler, :fetcher
 
     def initialize(
@@ -23,17 +50,6 @@ module ActiveMcp
       @protocol_handler = ProtocolHandler.new(self)
     end
 
-    def self.log_error(message, error)
-      error_details = "#{message}: #{error.message}\n"
-      error_details += error.backtrace.join("\n") if error.backtrace
-      
-      if defined?(Rails)
-        Rails.logger.error(error_details)
-      else
-        $stderr.puts(error_details)
-      end
-    end
-
     def fetch(params:)
       @fetcher.call(params:)
     end

data/lib/active_mcp/version.rb

@@ -1,3 +1,3 @@
 module ActiveMcp
-  VERSION = "0.9.1"
+  VERSION = "0.9.2"
 end

data/lib/generators/active_mcp/install/install_generator.rb

@@ -1,7 +1,7 @@
 module ActiveMcp
   module Generators
     class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path('templates', __dir__)
+      source_root File.expand_path("templates", __dir__)
 
       desc "Creates an Active MCP initializer"
 

data/lib/generators/active_mcp/install/templates/initializer.rb

@@ -1,5 +1,5 @@
 # Active MCP configuration
 ActiveMcp.configure do |config|
-  config.server_name = 'MCP Server'
-  config.server_version = '1.0.0'
+  config.server_name = "MCP Server"
+  config.server_version = "1.0.0"
 end

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

@@ -1,6 +1,6 @@
 class <%= class_name %> < ActiveMcp::Tool::Base
   def tool_name
-    "<%= file_name.humanize %>"
+    "<%= file_name %>"
   end
 
   def description

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: active_mcp
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.2
 platform: ruby
 authors:
 - Moeki Kawakami
+autorequire:
 bindir: exe
 cert_chain: []
 date: 2025-04-08 00:00:00.000000000 Z
@@ -97,7 +98,7 @@ files:
 - lib/active_mcp/resource/base.rb
 - lib/active_mcp/schema/base.rb
 - lib/active_mcp/server.rb
-- lib/active_mcp/server/error_codes.rb
+- lib/active_mcp/server/error_code.rb
 - lib/active_mcp/server/fetcher.rb
 - lib/active_mcp/server/method.rb
 - lib/active_mcp/server/protocol_handler.rb
@@ -114,6 +115,7 @@ homepage: https://github.com/moekiorg/active_mcp
 licenses:
 - MIT
 metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,7 +130,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: Rails engine for the Model Context Protocol (MCP)
 test_files: []