vector_mcp 0.3.1 → 0.3.2

data/lib/vector_mcp/server.rb

@@ -19,6 +19,7 @@ require_relative "security/session_context"
 require_relative "security/strategies/api_key"
 require_relative "security/strategies/jwt_token"
 require_relative "security/strategies/custom"
+require_relative "middleware"
 
 module VectorMCP
   # The `Server` class is the central component for an MCP server implementation.
@@ -70,7 +71,7 @@ module VectorMCP
     PROTOCOL_VERSION = "2024-11-05"
 
     attr_reader :logger, :name, :version, :protocol_version, :tools, :resources, :prompts, :roots, :in_flight_requests,
-                :auth_manager, :authorization, :security_middleware
+                :auth_manager, :authorization, :security_middleware, :middleware_manager
     attr_accessor :transport
 
     # Initializes a new VectorMCP server.
@@ -98,8 +99,8 @@ module VectorMCP
       @name = name_pos || name || "UnnamedServer"
       @version = version
       @protocol_version = options[:protocol_version] || PROTOCOL_VERSION
-      @logger = VectorMCP.logger
-      @logger.level = options[:log_level] if options[:log_level]
+      @logger = VectorMCP.logger_for("server")
+      # NOTE: log level should be configured via VectorMCP.configure_logging instead
 
       @transport = nil
       @tools = {}
@@ -121,6 +122,9 @@ module VectorMCP
       @authorization = Security::Authorization.new
       @security_middleware = Security::Middleware.new(@auth_manager, @authorization)
 
+      # Initialize middleware manager
+      @middleware_manager = Middleware::Manager.new
+
       setup_default_handlers
 
       @logger.info("Server instance '#{@name}' v#{@version} (MCP Protocol: #{@protocol_version}, Gem: v#{VectorMCP::VERSION}) initialized.")
@@ -133,7 +137,7 @@ module VectorMCP
     # @param transport [:stdio, :sse, VectorMCP::Transport::Base] The transport to use.
     #   Can be a symbol (`:stdio`, `:sse`) or an initialized transport instance.
     #   If a symbol is provided, the method will instantiate the corresponding transport class.
-    #   If `:sse` is chosen, ensure `async` and `falcon` gems are available.
+    #   If `:sse` is chosen, it uses Puma as the HTTP server.
     # @param options [Hash] Transport-specific options (e.g., `:host`, `:port` for SSE).
     #   These are passed to the transport's constructor if a symbol is provided for `transport`.
     # @return [void]
@@ -148,7 +152,7 @@ module VectorMCP
                              require_relative "transport/sse"
                              VectorMCP::Transport::SSE.new(self, **options)
                            rescue LoadError => e
-                             logger.fatal("SSE transport requires additional dependencies. Install the 'async' and 'falcon' gems.")
+                             logger.fatal("SSE transport requires additional dependencies.")
                              raise NotImplementedError, "SSE transport dependencies not available: #{e.message}"
                            end
                          when VectorMCP::Transport::Base # Allow passing an initialized transport instance
@@ -202,9 +206,9 @@ module VectorMCP
     # Enable authorization with optional policy configuration block
     # @param block [Proc] optional block for configuring authorization policies
     # @return [void]
-    def enable_authorization!(&)
+    def enable_authorization!(&block)
       @authorization.enable!
-      instance_eval(&) if block_given?
+      instance_eval(&block) if block_given?
       @logger.info("Authorization enabled")
     end
 
@@ -218,29 +222,29 @@ module VectorMCP
     # Add authorization policy for tools
     # @param block [Proc] policy block that receives (user, action, tool)
     # @return [void]
-    def authorize_tools(&)
-      @authorization.add_policy(:tool, &)
+    def authorize_tools(&block)
+      @authorization.add_policy(:tool, &block)
     end
 
     # Add authorization policy for resources
     # @param block [Proc] policy block that receives (user, action, resource)
     # @return [void]
-    def authorize_resources(&)
-      @authorization.add_policy(:resource, &)
+    def authorize_resources(&block)
+      @authorization.add_policy(:resource, &block)
     end
 
     # Add authorization policy for prompts
     # @param block [Proc] policy block that receives (user, action, prompt)
     # @return [void]
-    def authorize_prompts(&)
-      @authorization.add_policy(:prompt, &)
+    def authorize_prompts(&block)
+      @authorization.add_policy(:prompt, &block)
     end
 
     # Add authorization policy for roots
     # @param block [Proc] policy block that receives (user, action, root)
     # @return [void]
-    def authorize_roots(&)
-      @authorization.add_policy(:root, &)
+    def authorize_roots(&block)
+      @authorization.add_policy(:root, &block)
     end
 
     # Check if security features are enabled
@@ -255,6 +259,46 @@ module VectorMCP
       @security_middleware.security_status
     end
 
+    # --- Middleware Management ---
+
+    # Register middleware for specific hook types
+    # @param middleware_class [Class] Middleware class inheriting from VectorMCP::Middleware::Base
+    # @param hooks [Symbol, Array<Symbol>] Hook types to register for (e.g., :before_tool_call, [:before_tool_call, :after_tool_call])
+    # @param priority [Integer] Execution priority (lower numbers execute first, default: 100)
+    # @param conditions [Hash] Conditions for when middleware should run
+    # @option conditions [Array<String>] :only_operations Only run for these operations
+    # @option conditions [Array<String>] :except_operations Don't run for these operations
+    # @option conditions [Array<String>] :only_users Only run for these user IDs
+    # @option conditions [Array<String>] :except_users Don't run for these user IDs
+    # @option conditions [Boolean] :critical If true, errors in this middleware stop execution
+    # @example
+    #   server.use_middleware(MyMiddleware, :before_tool_call)
+    #   server.use_middleware(AuthMiddleware, [:before_request, :after_response], priority: 10)
+    #   server.use_middleware(LoggingMiddleware, :after_tool_call, conditions: { only_operations: ['important_tool'] })
+    def use_middleware(middleware_class, hooks, priority: Middleware::Hook::DEFAULT_PRIORITY, conditions: {})
+      @middleware_manager.register(middleware_class, hooks, priority: priority, conditions: conditions)
+      @logger.info("Registered middleware: #{middleware_class.name}")
+    end
+
+    # Remove all middleware hooks for a specific class
+    # @param middleware_class [Class] Middleware class to remove
+    def remove_middleware(middleware_class)
+      @middleware_manager.unregister(middleware_class)
+      @logger.info("Removed middleware: #{middleware_class.name}")
+    end
+
+    # Get middleware statistics
+    # @return [Hash] Statistics about registered middleware
+    def middleware_stats
+      @middleware_manager.stats
+    end
+
+    # Clear all middleware (useful for testing)
+    def clear_middleware!
+      @middleware_manager.clear!
+      @logger.info("Cleared all middleware")
+    end
+
     private
 
     # Add API key authentication strategy
@@ -276,8 +320,8 @@ module VectorMCP
     # Add custom authentication strategy
     # @param handler [Proc] custom authentication handler block
     # @return [void]
-    def add_custom_auth(&)
-      strategy = Security::Strategies::Custom.new(&)
+    def add_custom_auth(&block)
+      strategy = Security::Strategies::Custom.new(&block)
       @auth_manager.add_strategy(:custom, strategy)
     end
 

data/lib/vector_mcp/session.rb

@@ -95,10 +95,43 @@ module VectorMCP
     def sample(request_params, timeout: nil)
       validate_sampling_preconditions
 
-      sampling_req_obj = VectorMCP::Sampling::Request.new(request_params)
-      @logger.info("[Session #{@id}] Sending sampling/createMessage request to client.")
-
-      send_sampling_request(sampling_req_obj, timeout)
+      # Create middleware context for sampling
+      context = VectorMCP::Middleware::Context.new(
+        operation_type: :sampling,
+        operation_name: "createMessage",
+        params: request_params,
+        session: self,
+        server: @server,
+        metadata: { start_time: Time.now, timeout: timeout }
+      )
+
+      # Execute before_sampling_request hooks
+      context = @server.middleware_manager.execute_hooks(:before_sampling_request, context)
+      raise context.error if context.error?
+
+      begin
+        sampling_req_obj = VectorMCP::Sampling::Request.new(request_params)
+        @logger.info("[Session #{@id}] Sending sampling/createMessage request to client.")
+
+        result = send_sampling_request(sampling_req_obj, timeout)
+
+        # Set result in context
+        context.result = result
+
+        # Execute after_sampling_response hooks
+        context = @server.middleware_manager.execute_hooks(:after_sampling_response, context)
+
+        context.result
+      rescue StandardError => e
+        # Set error in context and execute error hooks
+        context.error = e
+        context = @server.middleware_manager.execute_hooks(:on_sampling_error, context)
+
+        # Re-raise unless middleware handled the error
+        raise e unless context.result
+
+        context.result
+      end
     end
 
     private

data/lib/vector_mcp/version.rb

@@ -2,5 +2,5 @@
 
 module VectorMCP
   # The current version of the VectorMCP gem.
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end

data/lib/vector_mcp.rb

@@ -11,15 +11,16 @@ require_relative "vector_mcp/util"
 require_relative "vector_mcp/image_util"
 require_relative "vector_mcp/handlers/core"
 require_relative "vector_mcp/transport/stdio"
-# require_relative "vector_mcp/transport/sse" # Load on demand to avoid async dependencies
-require_relative "vector_mcp/logging"
+# require_relative "vector_mcp/transport/sse" # Load on demand
+require_relative "vector_mcp/logger"
+require_relative "vector_mcp/middleware"
 require_relative "vector_mcp/server"
 
 # The VectorMCP module provides a full-featured, opinionated Ruby implementation
 # of the **Model Context Protocol (MCP)**.  It gives developers everything needed
 # to spin up an MCP-compatible server—including:
 #
-# * **Transport adapters** (synchronous `stdio` or asynchronous HTTP + SSE)
+# * **Transport adapters** (synchronous `stdio` or HTTP + SSE)
 # * **High-level abstractions** for *tools*, *resources*, and *prompts*
 # * **JSON-RPC 2.0** message handling with sensible defaults and detailed
 #   error reporting helpers
@@ -45,44 +46,18 @@ require_relative "vector_mcp/server"
 # order to serve multiple concurrent clients over HTTP.
 #
 module VectorMCP
-  # @return [Logger] the shared logger instance for the library.
-  @logger = Logger.new($stderr, level: Logger::INFO, progname: "VectorMCP")
-
-  # @return [VectorMCP::Logging::Core] the new structured logging system
-  @logging_core = nil
-
   class << self
-    # @!attribute [r] logger
-    #   @return [Logger] the shared logger instance for the library (legacy compatibility).
-    def logger
-      if @logging_core
-        @logging_core.legacy_logger
-      else
-        @logger
-      end
-    end
-
-    # Initialize the new structured logging system
-    # @param config [Hash, VectorMCP::Logging::Configuration] logging configuration
-    # @return [VectorMCP::Logging::Core] the logging core instance
-    def setup_logging(config = {})
-      configuration = config.is_a?(Logging::Configuration) ? config : Logging::Configuration.new(config)
-      @logging_core = Logging::Core.new(configuration)
-    end
-
     # Get a component-specific logger
     # @param component [String, Symbol] the component name
-    # @return [VectorMCP::Logging::Component] component logger
+    # @return [VectorMCP::Logger] component logger
     def logger_for(component)
-      setup_logging unless @logging_core
-      @logging_core.logger_for(component)
+      Logger.for(component)
     end
 
-    # Configure the logging system
-    # @yield [VectorMCP::Logging::Configuration] configuration block
-    def configure_logging(&)
-      setup_logging unless @logging_core
-      @logging_core.configure(&)
+    # Get the default logger
+    # @return [VectorMCP::Logger] default logger
+    def logger
+      @logger ||= Logger.for("vectormcp")
     end
 
     # Creates a new {VectorMCP::Server} instance. This is a **thin wrapper** around

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vector_mcp
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: ruby
 authors:
 - Sergio Bayona
@@ -66,47 +66,47 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: puma
+  name: jwt
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.4'
+        version: '2.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.4'
+        version: '2.7'
 - !ruby/object:Gem::Dependency
-  name: rack
+  name: puma
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '6.4'
 - !ruby/object:Gem::Dependency
-  name: jwt
+  name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '3.0'
 description: A Ruby gem implementing the Model Context Protocol (MCP) server-side
   specification. Provides a framework for creating MCP servers that expose tools,
   resources, prompts, and roots to LLM clients with comprehensive security features,
@@ -129,19 +129,12 @@ files:
 - lib/vector_mcp/errors.rb
 - lib/vector_mcp/handlers/core.rb
 - lib/vector_mcp/image_util.rb
-- lib/vector_mcp/logging.rb
-- lib/vector_mcp/logging/component.rb
-- lib/vector_mcp/logging/configuration.rb
-- lib/vector_mcp/logging/constants.rb
-- lib/vector_mcp/logging/core.rb
-- lib/vector_mcp/logging/filters/component.rb
-- lib/vector_mcp/logging/filters/level.rb
-- lib/vector_mcp/logging/formatters/base.rb
-- lib/vector_mcp/logging/formatters/json.rb
-- lib/vector_mcp/logging/formatters/text.rb
-- lib/vector_mcp/logging/outputs/base.rb
-- lib/vector_mcp/logging/outputs/console.rb
-- lib/vector_mcp/logging/outputs/file.rb
+- lib/vector_mcp/logger.rb
+- lib/vector_mcp/middleware.rb
+- lib/vector_mcp/middleware/base.rb
+- lib/vector_mcp/middleware/context.rb
+- lib/vector_mcp/middleware/hook.rb
+- lib/vector_mcp/middleware/manager.rb
 - lib/vector_mcp/sampling/request.rb
 - lib/vector_mcp/sampling/result.rb
 - lib/vector_mcp/security.rb
@@ -180,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.0.6
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/vector_mcp/logging/component.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-module VectorMCP
-  module Logging
-    class Component
-      attr_reader :name, :core, :config
-
-      def initialize(name, core, config = {})
-        @name = name.to_s
-        @core = core
-        @config = config
-        @context = {}
-      end
-
-      def with_context(context)
-        old_context = @context
-        @context = @context.merge(context)
-        yield
-      ensure
-        @context = old_context
-      end
-
-      def add_context(context)
-        @context = @context.merge(context)
-      end
-
-      def clear_context
-        @context = {}
-      end
-
-      def trace(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:TRACE], message, context, &block)
-      end
-
-      def debug(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:DEBUG], message, context, &block)
-      end
-
-      def info(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:INFO], message, context, &block)
-      end
-
-      def warn(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:WARN], message, context, &block)
-      end
-
-      def error(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:ERROR], message, context, &block)
-      end
-
-      def fatal(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:FATAL], message, context, &block)
-      end
-
-      def security(message = nil, context: {}, &block)
-        log_with_block(Logging::LEVELS[:SECURITY], message, context, &block)
-      end
-
-      def level
-        @core.configuration.level_for(@name)
-      end
-
-      def level_enabled?(level)
-        level >= self.level
-      end
-
-      def trace?
-        level_enabled?(Logging::LEVELS[:TRACE])
-      end
-
-      def debug?
-        level_enabled?(Logging::LEVELS[:DEBUG])
-      end
-
-      def info?
-        level_enabled?(Logging::LEVELS[:INFO])
-      end
-
-      def warn?
-        level_enabled?(Logging::LEVELS[:WARN])
-      end
-
-      def error?
-        level_enabled?(Logging::LEVELS[:ERROR])
-      end
-
-      def fatal?
-        level_enabled?(Logging::LEVELS[:FATAL])
-      end
-
-      def security?
-        level_enabled?(Logging::LEVELS[:SECURITY])
-      end
-
-      def measure(message, context: {}, level: :info, &block)
-        start_time = Time.now
-        result = nil
-        error = nil
-
-        begin
-          result = block.call
-        rescue StandardError => e
-          error = e
-          raise
-        ensure
-          duration = Time.now - start_time
-          measure_context = context.merge(
-            duration_ms: (duration * 1000).round(2),
-            success: error.nil?
-          )
-          measure_context[:error] = error.class.name if error
-
-          send(level, "#{message} completed", context: measure_context)
-        end
-
-        result
-      end
-
-      private
-
-      def log_with_block(level, message, context, &block)
-        return unless level_enabled?(level)
-
-        message = block.call if block_given?
-
-        full_context = @context.merge(context)
-        @core.log(level, @name, message, full_context)
-      end
-    end
-  end
-end

data/lib/vector_mcp/logging/configuration.rb

@@ -1,156 +0,0 @@
-# frozen_string_literal: true
-
-require "yaml"
-
-module VectorMCP
-  module Logging
-    class Configuration
-      DEFAULT_CONFIG = {
-        level: "INFO",
-        format: "text",
-        output: "console",
-        components: {},
-        console: {
-          colorize: true,
-          include_timestamp: true,
-          include_thread: false
-        },
-        file: {
-          path: nil,
-          rotation: "daily",
-          max_size: "100MB",
-          max_files: 7
-        }
-      }.freeze
-
-      attr_reader :config
-
-      def initialize(config = {})
-        @config = deep_merge(DEFAULT_CONFIG, normalize_config(config))
-        validate_config!
-      end
-
-      def self.from_file(path)
-        config = YAML.load_file(path)
-        new(config["logging"] || config)
-      rescue StandardError => e
-        raise ConfigurationError, "Failed to load configuration from #{path}: #{e.message}"
-      end
-
-      def self.from_env
-        config = {}
-
-        config[:level] = ENV["VECTORMCP_LOG_LEVEL"] if ENV["VECTORMCP_LOG_LEVEL"]
-        config[:format] = ENV["VECTORMCP_LOG_FORMAT"] if ENV["VECTORMCP_LOG_FORMAT"]
-        config[:output] = ENV["VECTORMCP_LOG_OUTPUT"] if ENV["VECTORMCP_LOG_OUTPUT"]
-
-        config[:file] = { path: ENV["VECTORMCP_LOG_FILE_PATH"] } if ENV["VECTORMCP_LOG_FILE_PATH"]
-
-        new(config)
-      end
-
-      def level_for(component)
-        component_level = @config[:components][component.to_s]
-        level_value = component_level || @config[:level]
-        Logging.level_value(level_value)
-      end
-
-      def set_component_level(component, level)
-        @config[:components][component.to_s] = if level.is_a?(Integer)
-                                                 Logging.level_name(level)
-                                               else
-                                                 level.to_s.upcase
-                                               end
-      end
-
-      def component_config(component_name)
-        @config[:components][component_name.to_s] || {}
-      end
-
-      def console_config
-        @config[:console]
-      end
-
-      def file_config
-        @config[:file]
-      end
-
-      def format
-        @config[:format]
-      end
-
-      def output
-        @config[:output]
-      end
-
-      def configure(&)
-        instance_eval(&) if block_given?
-        validate_config!
-      end
-
-      def level(new_level)
-        @config[:level] = new_level.to_s.upcase
-      end
-
-      def component(name, level:)
-        @config[:components][name.to_s] = level.to_s.upcase
-      end
-
-      def console(options = {})
-        @config[:console].merge!(options)
-      end
-
-      def file(options = {})
-        @config[:file].merge!(options)
-      end
-
-      def to_h
-        @config.dup
-      end
-
-      private
-
-      def normalize_config(config)
-        case config
-        when Hash
-          config.transform_keys(&:to_sym)
-        when String
-          { level: config }
-        else
-          {}
-        end
-      end
-
-      def deep_merge(hash1, hash2)
-        result = hash1.dup
-        hash2.each do |key, value|
-          result[key] = if result[key].is_a?(Hash) && value.is_a?(Hash)
-                          deep_merge(result[key], value)
-                        else
-                          value
-                        end
-        end
-        result
-      end
-
-      def validate_config!
-        validate_level!(@config[:level])
-        @config[:components].each_value do |level|
-          validate_level!(level)
-        end
-
-        raise ConfigurationError, "Invalid format: #{@config[:format]}" unless %w[text json].include?(@config[:format])
-
-        return if %w[console file both].include?(@config[:output])
-
-        raise ConfigurationError, "Invalid output: #{@config[:output]}"
-      end
-
-      def validate_level!(level)
-        return if Logging::LEVELS.key?(level.to_s.upcase.to_sym)
-
-        raise ConfigurationError, "Invalid log level: #{level}"
-      end
-    end
-  end
-end