active_mcp 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1891356bb19d256dcbd11f7d441fb9c5f668fc9cc0b115ea17eec44aef99ee54
-  data.tar.gz: 8031f7e13bfd5a837cf84ff3ca069bd5c56b46901e7e04c861d6c15eabcf2c94
+  metadata.gz: 33e83423b0e7e4bdf722b5473ec742e92efe3af946270f3fc1edf2ee9806c8d2
+  data.tar.gz: a9fe38a30a53fbdc4810b2c5d08884730f71cd4ace372188c69916f6db61742a
 SHA512:
-  metadata.gz: 20438f69b5a08fa089187a1eb11c0f0e8ccc5525809439e45da36105411b7c62187a981f0a73deda52fdb292ede1ffc429aaa26d0a21f2a5a369b9601bd2306d
-  data.tar.gz: cf9c750474af01cc72c1a8480c568c36a29d271b7c7a9f5a2bf5ecdec8cc42e1fc0fe70493ae6e9a82d3f431445aca068a881fc89c71c6181f976384c8b0e2ca
+  metadata.gz: b20d1f9baf3a7b48cab071135ca15fc182fb3d1cdc3570bcd0b0fb337906dd9e5fa0dc1f646823b281a9600911e3ef9ef7d5cf67eaab80a19a2cad27304f04bb
+  data.tar.gz: 5036f8e8b6056255e81b693cb5fc436d78bf04b8f0546c186110eb4774e6b7b7fe36d4e755c30e84884cadb75a4455af469fbe27d869b502a5ee5d0c79c9d167

data/README.md

@@ -36,6 +36,8 @@ A Ruby on Rails engine for the [Model Context Protocol (MCP)](https://modelconte
   - [📦 MCP Resources](#-mcp-resources)
     - [Creating Resources](#creating-resources)
     - [Resource Types](#resource-types)
+  - [📦 MCP Resource Templates](#-mcp-resource-templates)
+    - [Creating Resource Templates](#creating-resource-templates)
   - [⚙️ Advanced Configuration](#️-advanced-configuration)
     - [Custom Controller](#custom-controller)
   - [💡 Best Practices](#-best-practices)
@@ -311,7 +313,7 @@ MCP Resources allow you to share data and files with AI assistants. Resources ha
 
 ### Creating Resources
 
-Resources are Ruby classes that inherit from `ActiveMcp::Resource`:
+Resources are Ruby classes `**Resource`:
 
 ```ruby
 class UserResource
@@ -348,6 +350,18 @@ class UserResource
 end
 ```
 
+```ruby
+class McpController < ActiveMcp::BaseController
+  private
+
+  def resource_list
+    User.all.map do |user|
+      UserResource.new(id: user.id)
+    end
+  end
+end
+```
+
 ### Resource Types
 
 Resources can return two types of content:
@@ -400,6 +414,46 @@ def visible?
 end
 ```
 
+## 📦 MCP Resource Templates
+
+MCP Resource Teamplates allow you to define template of resources.
+
+### Creating Resource Templates
+
+Resources are Ruby classes `**ResourceTemplates`:
+
+```ruby
+class UserResourceTemplate
+  def name
+    "Users"
+  end
+
+  def uri_template
+    "data://localhost/users/{id}"
+  end
+
+  def mime_type
+    "application/json"
+  end
+
+  def description
+    "This is a test."
+  end
+end
+```
+
+```ruby
+class McpController < ActiveMcp::BaseController
+  private
+
+  def resource_templates_list
+    [
+      UserResourceTemplate.new
+    ]
+  end
+end
+```
+
 ## ⚙️ Advanced Configuration
 
 ### Custom Controller

data/app/controllers/active_mcp/base_controller.rb

@@ -4,5 +4,6 @@ module ActiveMcp
   class BaseController < ActionController::Base
     include RequestHandlable
     include ResourceReadable
+    include ToolExecutable
   end
 end

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

@@ -39,6 +39,10 @@ module ActiveMcp
         @resources = resources_list
         @format = :jsonrpc
         render 'active_mcp/resources_list', formats: :json
+      when Method::RESOURCES_TEMPLATES_LIST
+        @resource_templates = resource_templates_list
+        @format = :jsonrpc
+        render 'active_mcp/resource_templates_list', formats: :json
       when Method::RESOURCES_READ
         @resource = read_resource(params:, auth_info:)
         @format = :jsonrpc
@@ -48,7 +52,7 @@ module ActiveMcp
         @format = :jsonrpc
         render 'active_mcp/tools_list', formats: :json
       when Method::TOOLS_CALL
-        @tool_result = ActiveMcp::ToolExecutor.execute(params: params, auth_info: auth_info)
+        @tool_result = execute_tool(params: params, auth_info: auth_info)
         @format = :jsonrpc
         render 'active_mcp/tools_call', formats: :json
       else
@@ -69,12 +73,16 @@ module ActiveMcp
         @resource = read_resource(params:, auth_info:)
         @format = :json
         render 'active_mcp/resources_read', formats: :json
+      when Method::RESOURCES_TEMPLATES_LIST
+        @resource_templates = resource_templates_list
+        @format = :json
+        render 'active_mcp/resource_templates_list', formats: :json
       when Method::TOOLS_LIST
         @tools = ActiveMcp::Tool.authorized_tools(auth_info)
         @format = :json
         render 'active_mcp/tools_list', formats: :json
       when Method::TOOLS_CALL
-        @tool_result = ActiveMcp::ToolExecutor.execute(params: params, auth_info: auth_info)
+        @tool_result = execute_tool(params: params, auth_info: auth_info)
         @format = :json
         render 'active_mcp/tools_call', formats: :json
       else

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

@@ -4,6 +4,10 @@ module ActiveMcp
 
     private
 
+    def resource_templates_list
+      []
+    end
+
     def resources_list
       []
     end
@@ -41,7 +45,7 @@ module ActiveMcp
       end
 
       begin
-        if content = resource.text
+        if resource.respond_to?(:text) && content = resource.text
           return {
             contents: [
               {

data/app/{models/active_mcp/tool_executor.rb → controllers/concerns/active_mcp/tool_executable.rb}

@@ -1,6 +1,10 @@
 module ActiveMcp
-  class ToolExecutor
-    def self.execute(params:, auth_info:)
+  module ToolExecutable
+    extend ActiveSupport::Concern
+
+    private
+
+    def execute_tool(params:, auth_info:)
       if params[:jsonrpc].present?
         tool_name = params[:params][:name]
         tool_params = params[:params][:arguments]
@@ -105,7 +109,7 @@ module ActiveMcp
       end
     end
     
-    def self.formatted(object)
+    def formatted(object)
       case object
       when String
         object

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

@@ -0,0 +1,24 @@
+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.name
+        json.uriTemplate resource.uri_template
+        json.mimeType resource.mime_type
+        json.description resource.description
+      end
+    end
+  end
+else
+  json.result do
+    json.array!(@resource_templates) do |resource|
+      json.name resource.name
+      json.uriTemplate resource.uri_template
+      json.mimeType resource.mime_type
+      json.description resource.description
+    end
+  end
+end

data/lib/active_mcp/server/fetcher.rb

@@ -0,0 +1,56 @@
+module ActiveMcp
+  class Server
+    class Fetcher
+      def initialize(base_uri: nil, auth: nil)
+        @base_uri = base_uri
+
+        if auth
+          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
+        end
+      end
+
+      def call(params:)
+        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
+          end
+        rescue URI::InvalidURIError => e
+          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"
+        request["Authorization"] = @auth_header
+
+        begin
+          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(request)
+          end
+
+          JSON.parse(response.body, symbolize_names: true)
+        rescue => e
+          Server.log_error("Error fetching resource_templates", e)
+        end
+      end
+    end
+  end
+end

data/lib/active_mcp/server/method.rb

@@ -10,6 +10,6 @@ module ActiveMcp
     TOOLS_CALL = "tools/call"
     RESOURCES_LIST = "resources/list"
     RESOURCES_READ = "resources/read"
-    RESOURCES_TEMPLATES_LIST = "resources/list"
+    RESOURCES_TEMPLATES_LIST = "resources/templates/list"
   end
 end

data/lib/active_mcp/server/protocol_handler.rb

@@ -17,10 +17,10 @@ module ActiveMcp
           request = JSON.parse(message, symbolize_names: true)
           handle_request(request)
         rescue JSON::ParserError => e
-          log_error("JSON parse error", e)
+          Server.log_error("JSON parse error", e)
           error_response(nil, ErrorCode::PARSE_ERROR, "Invalid JSON format")
         rescue => e
-          log_error("Internal error during message processing", e)
+          Server.log_error("Internal error during message processing", e)
           error_response(nil, ErrorCode::INTERNAL_ERROR, "An internal error occurred")
         end
 
@@ -50,10 +50,12 @@ module ActiveMcp
           handle_ping(request)
         when Method::RESOURCES_LIST
           handle_list_resources(request)
+        when Method::RESOURCES_TEMPLATES_LIST
+          handle_list_resource_templates(request)
         when Method::TOOLS_LIST
           handle_list_tools(request)
         when Method::TOOLS_CALL
-          handle_use_tool(request)
+          handle_call_tool(request)
         when Method::RESOURCES_READ
           handle_read_resource(request)
         else
@@ -113,23 +115,63 @@ module ActiveMcp
       end
 
       def handle_list_resources(request)
-        success_response(request[:id], {resources: @server.resource_manager.resources})
+        success_response(
+          request[:id],
+          {
+            resources: @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]
+          }
+        )
       end
 
       def handle_list_tools(request)
-        success_response(request[:id], {tools: @server.tool_manager.tools})
+        success_response(
+          request[:id],
+          {
+            tools: @server.fetch(
+              params: {
+                method: Method::TOOLS_LIST,
+                arguments: {}
+              }
+            )[:result]
+          }
+        )
       end
 
-      def handle_use_tool(request)
+      def handle_call_tool(request)
         name = request.dig(:params, :name)
         arguments = request.dig(:params, :arguments) || {}
 
         begin
-          result = @server.tool_manager.call_tool(name, arguments)
+          result = @server.fetch(
+            params: {
+              method: Method::TOOLS_CALL,
+              name:,
+              arguments:,
+            }
+          )
 
           success_response(request[:id], result)
         rescue => e
-          log_error("Error calling tool #{name}", e)
+          Server.log_error("Error calling tool #{name}", e)
           error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while calling the tool")
         end
       end
@@ -137,11 +179,17 @@ module ActiveMcp
       def handle_read_resource(request)
         uri = request.dig(:params, :uri)
         begin
-          result = @server.resource_manager.read_resource(uri)
+          result = @server.fetch(
+            params: {
+              method: Method::RESOURCES_READ,
+              uri:,
+              arguments: {},
+            }
+          )
 
           success_response(request[:id], result)
         rescue => e
-          log_error("Error reading resource #{uri}", e)
+          Server.("Error reading resource #{uri}", e)
           error_response(request[:id], ErrorCode::INTERNAL_ERROR, "An error occurred while reading the resource")
         end
       end
@@ -166,18 +214,6 @@ module ActiveMcp
         response[:error][:data] = data if data
         response
       end
-      
-      def 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
-          # Fresallback to standard error output if Rails is not available
-          $stderr.puts(error_details)
-        end
-      end
     end
   end
 end

data/lib/active_mcp/server.rb

@@ -3,13 +3,12 @@ require "English"
 require_relative "server/method"
 require_relative "server/error_codes"
 require_relative "server/stdio_connection"
-require_relative "server/resource_manager"
-require_relative "server/tool_manager"
+require_relative "server/fetcher"
 require_relative "server/protocol_handler"
 
 module ActiveMcp
   class Server
-    attr_reader :name, :version, :uri, :tool_manager, :protocol_handler, :resource_manager
+    attr_reader :name, :version, :uri, :protocol_handler, :fetcher
 
     def initialize(
       version: ActiveMcp::VERSION,
@@ -20,11 +19,23 @@ module ActiveMcp
       @name = name
       @version = version
       @uri = uri
-      @resource_manager = ResourceManager.new(uri:, auth:)
-      @tool_manager = ToolManager.new(uri: uri, auth:)
+      @fetcher = Fetcher.new(base_uri: uri, auth:)
       @protocol_handler = ProtocolHandler.new(self)
-      @tool_manager.load_registered_tools
-      @resource_manager.load_registered_resources
+    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
 
     def start

data/lib/active_mcp/version.rb

@@ -1,3 +1,3 @@
 module ActiveMcp
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_mcp
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Moeki Kawakami
@@ -70,11 +70,12 @@ files:
 - app/controllers/active_mcp/base_controller.rb
 - app/controllers/concerns/active_mcp/request_handlable.rb
 - app/controllers/concerns/active_mcp/resource_readable.rb
-- app/models/active_mcp/tool_executor.rb
+- app/controllers/concerns/active_mcp/tool_executable.rb
 - app/views/active_mcp/cancelled.json.jbuilder
 - app/views/active_mcp/initialize.json.jbuilder
 - app/views/active_mcp/initialized.json.jbuilder
 - app/views/active_mcp/no_method.json.jbuilder
+- app/views/active_mcp/resource_templates_list.json.jbuilder
 - app/views/active_mcp/resources_list.json.jbuilder
 - app/views/active_mcp/resources_read.json.jbuilder
 - app/views/active_mcp/tools_call.json.jbuilder
@@ -85,11 +86,10 @@ files:
 - lib/active_mcp/engine.rb
 - lib/active_mcp/server.rb
 - lib/active_mcp/server/error_codes.rb
+- lib/active_mcp/server/fetcher.rb
 - lib/active_mcp/server/method.rb
 - lib/active_mcp/server/protocol_handler.rb
-- lib/active_mcp/server/resource_manager.rb
 - lib/active_mcp/server/stdio_connection.rb
-- lib/active_mcp/server/tool_manager.rb
 - lib/active_mcp/tool.rb
 - lib/active_mcp/version.rb
 - lib/generators/active_mcp/install/install_generator.rb

data/lib/active_mcp/server/resource_manager.rb

@@ -1,150 +0,0 @@
-require "json"
-
-module ActiveMcp
-  class Server
-    class ResourceManager
-      attr_reader :resources
-
-      def initialize(uri: nil, auth: nil)
-        @resources = {}
-        @base_uri = uri
-
-        if auth
-          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
-        end
-      end
-
-      def load_registered_resources
-        fetch_resources
-      end
-
-      def read_resource(uri)
-        require "net/http"
-        
-        unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI configuration"}]
-          }
-        end
-        
-        begin
-          base_uri = URI.parse(@base_uri.to_s)
-          
-          unless base_uri.scheme =~ /\Ahttps?\z/ && !base_uri.host.nil?
-            log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
-            return {
-              isError: true,
-              content: [{type: "text", text: "Invalid URI configuration"}]
-            }
-          end
-          
-          if defined?(Rails) && Rails.env.production? && base_uri.scheme != "https"
-            return {
-              isError: true,
-              content: [{type: "text", text: "HTTPS is required in production environment"}]
-            }
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI format"}]
-          }
-        end
-        
-        request = Net::HTTP::Post.new(base_uri)
-        request.body = JSON.generate({
-          method: Method::RESOURCES_READ,
-          uri:,
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(base_uri.hostname, base_uri.port) do |http|
-            http.request(request)
-          end
-
-          if response.code == "200"
-            JSON.parse(response.body, symbolize_names: true)
-          else
-            $stderr.puts(response.body)
-            {
-              isError: true,
-              contents: []
-            }
-          end
-        rescue => e
-          log_error("Error calling tool", e)
-          {
-            isError: true,
-            contents: []
-          }
-        end
-      end
-
-      private
-
-      def fetch_resources
-        return unless @base_uri
-
-        require "net/http"
-        
-        unless @base_uri.is_a?(URI) || @base_uri.is_a?(String)
-          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?
-            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"
-            log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
-            return
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "resources/list",
-          arguments: "{}"
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          result = JSON.parse(response.body, symbolize_names: true)
-          @resources = result[:result]
-        rescue => e
-          log_error("Error fetching resources", e)
-          @resources = []
-        end
-      end
-      
-      def 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
-    end
-  end
-end

data/lib/active_mcp/server/tool_manager.rb

@@ -1,163 +0,0 @@
-require "json"
-
-module ActiveMcp
-  class Server
-    class ToolManager
-      attr_reader :tools
-
-      def initialize(uri: nil, auth: nil)
-        @tools = {}
-        @uri = uri
-
-        if auth
-          @auth_header = "#{auth[:type] == :bearer ? "Bearer" : "Basic"} #{auth[:token]}"
-        end
-      end
-
-      def call_tool(name, arguments = {})
-        tool_info = @tools.find { _1[:name] == name }
-
-        unless tool_info
-          return {
-            isError: true,
-            content: [{type: "text", text: "Tool not found: #{name}"}]
-          }
-        end
-
-        invoke_tool(name, arguments)
-      end
-
-      def load_registered_tools
-        fetch_tools
-      end
-
-      private
-
-      def invoke_tool(name, arguments)
-        require "net/http"
-        
-        unless @uri.is_a?(URI) || @uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI configuration"}]
-          }
-        end
-        
-        begin
-          uri = URI.parse(@uri.to_s)
-          
-          unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
-            log_error("Invalid URI", StandardError.new("URI must have a valid scheme and host"))
-            return {
-              isError: true,
-              content: [{type: "text", text: "Invalid URI configuration"}]
-            }
-          end
-          
-          if defined?(Rails) && Rails.env.production? && uri.scheme != "https"
-            return {
-              isError: true,
-              content: [{type: "text", text: "HTTPS is required in production environment"}]
-            }
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return {
-            isError: true,
-            content: [{type: "text", text: "Invalid URI format"}]
-          }
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "tools/call",
-          name:,
-          arguments: arguments
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          if response.code == "200"
-            JSON.parse(response.body, symbolize_names: true)
-          else
-            {
-              isError: true,
-              content: [{type: "text", text: "HTTP Error: #{response.code}"}]
-            }
-          end
-        rescue => e
-          log_error("Error calling tool", e)
-          {
-            isError: true,
-            content: [{type: "text", text: "Error calling tool"}]
-          }
-        end
-      end
-
-      def fetch_tools
-        return unless @uri
-
-        require "net/http"
-        
-        unless @uri.is_a?(URI) || @uri.is_a?(String)
-          log_error("Invalid URI type", StandardError.new("URI must be a String or URI object"))
-          return
-        end
-        
-        begin
-          uri = URI.parse(@uri.to_s)
-          
-          unless uri.scheme =~ /\Ahttps?\z/ && !uri.host.nil?
-            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"
-            log_error("HTTPS is required in production environment", StandardError.new("Non-HTTPS URI in production"))
-            return
-          end
-        rescue URI::InvalidURIError => e
-          log_error("Invalid URI format", e)
-          return
-        end
-        
-        request = Net::HTTP::Post.new(uri)
-        request.body = JSON.generate({
-          method: "tools/list",
-          arguments: "{}"
-        })
-        request["Content-Type"] = "application/json"
-        request["Authorization"] = @auth_header
-
-        begin
-          response = Net::HTTP.start(uri.hostname, uri.port) do |http|
-            http.request(request)
-          end
-
-          result = JSON.parse(response.body, symbolize_names: true)
-          @tools = result[:result]
-        rescue => e
-          log_error("Error fetching tools", e)
-          @tools = []
-        end
-      end
-      
-      def 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
-    end
-  end
-end