vector_mcp 0.3.1 → 0.3.3

data/lib/vector_mcp/transport/stdio_session_manager.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "base_session_manager"
+
+module VectorMCP
+  module Transport
+    # Session manager for Stdio transport with single global session.
+    # Extends BaseSessionManager with stdio-specific functionality.
+    #
+    # The Stdio transport uses a single global session for the entire transport lifetime.
+    class StdioSessionManager < BaseSessionManager
+      GLOBAL_SESSION_ID = "stdio_global_session"
+
+      # Initializes a new Stdio session manager.
+      #
+      # @param transport [Stdio] The parent transport instance
+      # @param session_timeout [Integer] Session timeout in seconds (ignored for stdio)
+      def initialize(transport, session_timeout = 300)
+        super
+
+        # Create the single global session for stdio transport
+        @global_session = create_global_session
+      end
+
+      # Gets the global session for stdio transport.
+      # Stdio uses a single global session for the entire transport lifetime.
+      #
+      # @return [Session] The global session
+      def global_session
+        @global_session&.touch!
+        @global_session
+      end
+
+      # Gets or creates the global session for stdio transport.
+      # This is an alias for global_session for stdio transport.
+      #
+      # @return [Session] The global session
+      def global_session_or_create
+        global_session
+      end
+
+      # Override: Gets session by ID, but always returns the global session for stdio.
+      #
+      # @param session_id [String] The session ID (ignored for stdio)
+      # @return [Session] The global session
+      def session(_session_id = nil)
+        global_session
+      end
+
+      # Override: Always returns the global session for stdio.
+      #
+      # @param session_id [String, nil] The session ID (ignored)
+      # @return [Session] The global session
+      def session_or_create(_session_id = nil)
+        global_session
+      end
+
+      # Override: Cannot create additional sessions in stdio transport.
+      #
+      # @param session_id [String, nil] The session ID (ignored)
+      # @return [Session] The global session
+      def create_session(_session_id = nil)
+        # For stdio, always return the existing global session
+        global_session
+      end
+
+      # Override: Cannot terminate the global session while transport is running.
+      #
+      # @param session_id [String] The session ID (ignored)
+      # @return [Boolean] Always false (session cannot be terminated individually)
+      def session_terminated?(_session_id)
+        # For stdio, the session is only terminated when the transport shuts down
+        false
+      end
+
+      # Override: Always returns 1 for the single global session.
+      #
+      # @return [Integer] Always 1
+      def session_count
+        1
+      end
+
+      # Override: Always returns the global session ID.
+      #
+      # @return [Array<String>] Array containing the global session ID
+      def active_session_ids
+        [GLOBAL_SESSION_ID]
+      end
+
+      # Override: Always returns true for the single session.
+      #
+      # @return [Boolean] Always true
+      def sessions?
+        true
+      end
+
+      # Gets all sessions for stdio transport (just the one global session).
+      #
+      # @return [Array<Session>] Array containing the global session
+      def all_sessions
+        [@global_session].compact
+      end
+
+      # Alias for global_session for compatibility with tests.
+      #
+      # @return [Session] The global session
+      def current_global_session
+        global_session
+      end
+
+      # Alias for global_session_or_create for compatibility with tests.
+      #
+      # @return [Session] The global session
+      def global_session_or_create_current
+        global_session_or_create
+      end
+
+      # Alias for all_sessions for compatibility with tests.
+      #
+      # @return [Array<Session>] Array containing the global session
+      def current_all_sessions
+        all_sessions
+      end
+
+      protected
+
+      # Override: Stdio doesn't need automatic cleanup since it has a single persistent session.
+      def auto_cleanup_enabled?
+        false
+      end
+
+      # Override: Returns metadata for stdio sessions.
+      def create_session_metadata
+        { session_type: :stdio_global, created_via: :transport_startup }
+      end
+
+      # Override: Stdio can always send messages (single session assumption).
+      def can_send_message_to_session?(_session)
+        true
+      end
+
+      # Override: Sends messages via the transport's notification mechanism.
+      def message_sent_to_session?(_session, message)
+        # For stdio, we send notifications directly via the transport
+        @transport.send_notification(message["method"], message["params"])
+        true
+      end
+
+      # Override: Stdio broadcasts to the single session (same as regular send).
+      def broadcast_message(message)
+        message_sent_to_session?(@global_session, message) ? 1 : 0
+      end
+
+      private
+
+      # Creates the single global session for stdio transport.
+      #
+      # @return [BaseSessionManager::Session] The global session
+      def create_global_session
+        now = Time.now
+
+        # Create VectorMCP session context with minimal request context
+        request_context = VectorMCP::RequestContext.minimal("stdio")
+        session_context = VectorMCP::Session.new(@transport.server, @transport, id: GLOBAL_SESSION_ID, request_context: request_context)
+
+        # Create internal session record using base session manager struct
+        session = BaseSessionManager::Session.new(
+          GLOBAL_SESSION_ID,
+          session_context,
+          now,
+          now,
+          create_session_metadata
+        )
+
+        @sessions[GLOBAL_SESSION_ID] = session
+        logger.info { "Global stdio session created: #{GLOBAL_SESSION_ID}" }
+        session
+      end
+    end
+  end
+end

data/lib/vector_mcp/util.rb

@@ -231,8 +231,46 @@ module VectorMCP
       content
     end
 
+    # Extracts HTTP headers from a Rack environment hash.
+    # Converts Rack's HTTP_* environment variables to proper HTTP header names.
+    # @param env [Hash] The Rack environment hash.
+    # @return [Hash] Normalized headers with proper casing.
+    def extract_headers_from_rack_env(env)
+      headers = {}
+      return headers if env.nil?
+
+      env.each do |key, value|
+        next unless key.start_with?("HTTP_")
+
+        # Convert HTTP_X_API_KEY to X-API-Key format
+        header_name = key[5..].split("_").map do |part|
+          case part.upcase
+          when "API" then "API" # Keep API in all caps
+          else part.capitalize
+          end
+        end.join("-")
+        headers[header_name] = value
+      end
+
+      # Add special headers
+      headers["Authorization"] = env["HTTP_AUTHORIZATION"] if env["HTTP_AUTHORIZATION"]
+      headers["Content-Type"] = env["CONTENT_TYPE"] if env["CONTENT_TYPE"]
+      headers
+    end
+
+    # Extracts query parameters from a Rack environment hash.
+    # Parses the QUERY_STRING into a hash of parameters.
+    # @param env [Hash] The Rack environment hash.
+    # @return [Hash] Normalized parameters as key-value pairs.
+    def extract_params_from_rack_env(env)
+      params = {}
+      params = URI.decode_www_form(env["QUERY_STRING"]).to_h if env && env["QUERY_STRING"]
+      params
+    end
+
     module_function :looks_like_image_file_path?, :binary_image_data?,
                     :file_path_to_image_content, :binary_image_to_content,
-                    :validate_and_enhance_image_content
+                    :validate_and_enhance_image_content, :extract_headers_from_rack_env,
+                    :extract_params_from_rack_env
   end
 end

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.3"
 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.3
 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,13 @@ 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/request_context.rb
 - lib/vector_mcp/sampling/request.rb
 - lib/vector_mcp/sampling/result.rb
 - lib/vector_mcp/security.rb
@@ -157,12 +151,19 @@ files:
 - lib/vector_mcp/server/message_handling.rb
 - lib/vector_mcp/server/registry.rb
 - lib/vector_mcp/session.rb
+- lib/vector_mcp/transport/base_session_manager.rb
+- lib/vector_mcp/transport/http_stream.rb
+- lib/vector_mcp/transport/http_stream/event_store.rb
+- lib/vector_mcp/transport/http_stream/session_manager.rb
+- lib/vector_mcp/transport/http_stream/stream_handler.rb
 - lib/vector_mcp/transport/sse.rb
 - lib/vector_mcp/transport/sse/client_connection.rb
 - lib/vector_mcp/transport/sse/message_handler.rb
 - lib/vector_mcp/transport/sse/puma_config.rb
 - lib/vector_mcp/transport/sse/stream_manager.rb
+- lib/vector_mcp/transport/sse_session_manager.rb
 - lib/vector_mcp/transport/stdio.rb
+- lib/vector_mcp/transport/stdio_session_manager.rb
 - lib/vector_mcp/util.rb
 - lib/vector_mcp/version.rb
 homepage: https://github.com/sergiobayona/vector_mcp
@@ -180,7 +181,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