model-context-protocol-rb 0.3.4 → 0.5.0

data/lib/model_context_protocol/server/progressable.rb

@@ -0,0 +1,72 @@
+require "concurrent-ruby"
+
+module ModelContextProtocol
+  module Server::Progressable
+    # Execute a block with automatic time-based progress reporting.
+    # Uses Concurrent::TimerTask to send progress notifications at regular intervals.
+    #
+    # @param max_duration [Numeric] Expected duration in seconds
+    # @param message [String, nil] Optional custom progress message
+    # @yield block to execute with progress tracking
+    # @return [Object] the result of the block
+    #
+    # @example
+    #   progressable(max_duration: 30) do  # 30 seconds
+    #     perform_long_operation
+    #   end
+    def progressable(max_duration:, message: nil, &block)
+      context = Thread.current[:mcp_context]
+
+      return yield unless context && context[:progress_token] && context[:transport]
+
+      progress_token = context[:progress_token]
+      transport = context[:transport]
+      start_time = Time.now
+      update_interval = [1.0, max_duration * 0.05].max
+
+      timer_task = Concurrent::TimerTask.new(execution_interval: update_interval) do
+        elapsed_seconds = Time.now - start_time
+        progress_pct = [(elapsed_seconds / max_duration) * 100, 99].min
+
+        progress_message = if message
+          "#{message} (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
+        else
+          "Processing... (#{elapsed_seconds.round(1)}s / ~#{max_duration}s)"
+        end
+
+        begin
+          transport.send_notification("notifications/progress", {
+            progressToken: progress_token,
+            progress: progress_pct.round(1),
+            total: 100,
+            message: progress_message
+          })
+        rescue
+          nil
+        end
+
+        timer_task.shutdown if elapsed_seconds >= max_duration
+      end
+
+      begin
+        timer_task.execute
+        result = yield
+
+        begin
+          transport.send_notification("notifications/progress", {
+            progressToken: progress_token,
+            progress: 100,
+            total: 100,
+            message: "Completed"
+          })
+        rescue
+          nil
+        end
+
+        result
+      ensure
+        timer_task&.shutdown if timer_task&.running?
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/prompt.rb

@@ -1,5 +1,9 @@
 module ModelContextProtocol
   class Server::Prompt
+    include ModelContextProtocol::Server::Cancellable
+    include ModelContextProtocol::Server::ContentHelpers
+    include ModelContextProtocol::Server::Progressable
+
     attr_reader :arguments, :context, :logger
 
     def initialize(arguments, logger, context = {})
@@ -13,15 +17,23 @@ module ModelContextProtocol
       raise NotImplementedError, "Subclasses must implement the call method"
     end
 
-    Response = Data.define(:messages, :description) do
+    Response = Data.define(:messages, :description, :title) do
       def serialized
-        {description:, messages:}
+        result = {description:, messages:}
+        result[:title] = title if title
+        result
       end
     end
     private_constant :Response
 
+    def message_history(&block)
+      builder = MessageHistoryBuilder.new(self)
+      builder.instance_eval(&block)
+      builder.messages
+    end
+
     private def respond_with(messages:)
-      Response[messages:, description: self.class.description]
+      Response[messages:, description: self.class.description, title: self.class.title]
     end
 
     private def validate!(arguments = {})
@@ -43,16 +55,18 @@ module ModelContextProtocol
     end
 
     class << self
-      attr_reader :name, :description, :defined_arguments
+      attr_reader :name, :description, :title, :defined_arguments
 
-      def with_metadata(&block)
+      def define(&block)
         @defined_arguments ||= []
 
-        metadata_dsl = MetadataDSL.new
-        metadata_dsl.instance_eval(&block)
+        definition_dsl = DefinitionDSL.new
+        definition_dsl.instance_eval(&block)
 
-        @name = metadata_dsl.name
-        @description = metadata_dsl.description
+        @name = definition_dsl.name
+        @description = definition_dsl.description
+        @title = definition_dsl.title
+        @defined_arguments.concat(definition_dsl.arguments)
       end
 
       def with_argument(&block)
@@ -72,6 +86,7 @@ module ModelContextProtocol
       def inherited(subclass)
         subclass.instance_variable_set(:@name, @name)
         subclass.instance_variable_set(:@description, @description)
+        subclass.instance_variable_set(:@title, @title)
         subclass.instance_variable_set(:@defined_arguments, @defined_arguments&.dup)
       end
 
@@ -81,8 +96,10 @@ module ModelContextProtocol
         raise ModelContextProtocol::Server::ParameterValidationError, error.message
       end
 
-      def metadata
-        {name: @name, description: @description, arguments: @defined_arguments}
+      def definition
+        result = {name: @name, description: @description, arguments: @defined_arguments}
+        result[:title] = @title if @title
+        result
       end
 
       def complete_for(arg_name, value)
@@ -92,7 +109,52 @@ module ModelContextProtocol
       end
     end
 
-    class MetadataDSL
+    class MessageHistoryBuilder
+      include Server::ContentHelpers
+
+      attr_reader :messages
+
+      def initialize(prompt_instance)
+        @messages = []
+        @prompt_instance = prompt_instance
+      end
+
+      def arguments
+        @prompt_instance.arguments
+      end
+
+      def context
+        @prompt_instance.context
+      end
+
+      def logger
+        @prompt_instance.logger
+      end
+
+      def user_message(&block)
+        content = instance_eval(&block).serialized
+        @messages << {
+          role: "user",
+          content: content
+        }
+      end
+
+      def assistant_message(&block)
+        content = instance_eval(&block).serialized
+        @messages << {
+          role: "assistant",
+          content: content
+        }
+      end
+    end
+
+    class DefinitionDSL
+      attr_reader :arguments
+
+      def initialize
+        @arguments = []
+      end
+
       def name(value = nil)
         @name = value if value
         @name
@@ -102,6 +164,23 @@ module ModelContextProtocol
         @description = value if value
         @description
       end
+
+      def title(value = nil)
+        @title = value if value
+        @title
+      end
+
+      def argument(&block)
+        argument_dsl = ArgumentDSL.new
+        argument_dsl.instance_eval(&block)
+
+        @arguments << {
+          name: argument_dsl.name,
+          description: argument_dsl.description,
+          required: argument_dsl.required,
+          completion: argument_dsl.completion
+        }
+      end
     end
 
     class ArgumentDSL
@@ -120,10 +199,25 @@ module ModelContextProtocol
         @required
       end
 
-      def completion(klass = nil)
-        @completion = klass unless klass.nil?
+      def completion(klass_or_values = nil)
+        unless klass_or_values.nil?
+          @completion = if klass_or_values.is_a?(Array)
+            create_array_completion(klass_or_values)
+          else
+            klass_or_values
+          end
+        end
         @completion
       end
+
+      private
+
+      def create_array_completion(values)
+        ModelContextProtocol::Server::Completion.define do
+          filtered_values = values.grep(/#{argument_value}/)
+          respond_with values: filtered_values
+        end
+      end
     end
   end
 end

data/lib/model_context_protocol/server/redis_client_proxy.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module ModelContextProtocol
+  class Server
+    class RedisClientProxy
+      def initialize(pool)
+        @pool = pool
+      end
+
+      def get(key)
+        with_connection { |redis| redis.get(key) }
+      end
+
+      def set(key, value, **options)
+        with_connection { |redis| redis.set(key, value, **options) }
+      end
+
+      def del(*keys)
+        with_connection { |redis| redis.del(*keys) }
+      end
+
+      def exists(*keys)
+        with_connection { |redis| redis.exists(*keys) }
+      end
+
+      def expire(key, seconds)
+        with_connection { |redis| redis.expire(key, seconds) }
+      end
+
+      def ttl(key)
+        with_connection { |redis| redis.ttl(key) }
+      end
+
+      def hget(key, field)
+        with_connection { |redis| redis.hget(key, field) }
+      end
+
+      def hset(key, *args)
+        with_connection { |redis| redis.hset(key, *args) }
+      end
+
+      def hgetall(key)
+        with_connection { |redis| redis.hgetall(key) }
+      end
+
+      def lpush(key, *values)
+        with_connection { |redis| redis.lpush(key, *values) }
+      end
+
+      def rpop(key)
+        with_connection { |redis| redis.rpop(key) }
+      end
+
+      def lrange(key, start, stop)
+        with_connection { |redis| redis.lrange(key, start, stop) }
+      end
+
+      def llen(key)
+        with_connection { |redis| redis.llen(key) }
+      end
+
+      def ltrim(key, start, stop)
+        with_connection { |redis| redis.ltrim(key, start, stop) }
+      end
+
+      def incr(key)
+        with_connection { |redis| redis.incr(key) }
+      end
+
+      def decr(key)
+        with_connection { |redis| redis.decr(key) }
+      end
+
+      def keys(pattern)
+        with_connection { |redis| redis.keys(pattern) }
+      end
+
+      def multi(&block)
+        with_connection do |redis|
+          redis.multi do |multi|
+            multi_wrapper = RedisMultiWrapper.new(multi)
+            block.call(multi_wrapper)
+          end
+        end
+      end
+
+      def pipelined(&block)
+        with_connection do |redis|
+          redis.pipelined do |pipeline|
+            pipeline_wrapper = RedisMultiWrapper.new(pipeline)
+            block.call(pipeline_wrapper)
+          end
+        end
+      end
+
+      def mget(*keys)
+        with_connection { |redis| redis.mget(*keys) }
+      end
+
+      def eval(script, keys: [], argv: [])
+        with_connection { |redis| redis.eval(script, keys: keys, argv: argv) }
+      end
+
+      def ping
+        with_connection { |redis| redis.ping }
+      end
+
+      def flushdb
+        with_connection { |redis| redis.flushdb }
+      end
+
+      private
+
+      def with_connection(&block)
+        @pool.with(&block)
+      end
+
+      # Wrapper for Redis multi/pipeline operations
+      class RedisMultiWrapper
+        def initialize(multi)
+          @multi = multi
+        end
+
+        def method_missing(method, *args, **kwargs, &block)
+          @multi.send(method, *args, **kwargs, &block)
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          @multi.respond_to?(method, include_private)
+        end
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/redis_config.rb

@@ -0,0 +1,108 @@
+require "singleton"
+
+module ModelContextProtocol
+  class Server::RedisConfig
+    include Singleton
+
+    class NotConfiguredError < StandardError
+      def initialize
+        super("Redis not configured. Call ModelContextProtocol::Server.configure_redis first")
+      end
+    end
+
+    attr_reader :manager
+
+    def self.configure(&block)
+      instance.configure(&block)
+    end
+
+    def self.configured?
+      instance.configured?
+    end
+
+    def self.pool
+      instance.pool
+    end
+
+    def self.shutdown!
+      instance.shutdown!
+    end
+
+    def self.reset!
+      instance.reset!
+    end
+
+    def self.stats
+      instance.stats
+    end
+
+    def self.pool_manager
+      instance.manager
+    end
+
+    def initialize
+      reset!
+    end
+
+    def configure(&block)
+      shutdown! if configured?
+
+      config = Configuration.new
+      yield(config) if block_given?
+
+      @manager = Server::RedisPoolManager.new(
+        redis_url: config.redis_url,
+        pool_size: config.pool_size,
+        pool_timeout: config.pool_timeout
+      )
+
+      if config.enable_reaper
+        @manager.configure_reaper(
+          enabled: true,
+          interval: config.reaper_interval,
+          idle_timeout: config.idle_timeout
+        )
+      end
+
+      @manager.start
+    end
+
+    def configured?
+      !@manager.nil? && !@manager.pool.nil?
+    end
+
+    def pool
+      raise NotConfiguredError unless configured?
+      @manager.pool
+    end
+
+    def shutdown!
+      @manager&.shutdown
+      @manager = nil
+    end
+
+    def reset!
+      shutdown!
+      @manager = nil
+    end
+
+    def stats
+      return {} unless configured?
+      @manager.stats
+    end
+
+    class Configuration
+      attr_accessor :redis_url, :pool_size, :pool_timeout,
+        :enable_reaper, :reaper_interval, :idle_timeout
+
+      def initialize
+        @redis_url = nil
+        @pool_size = 20
+        @pool_timeout = 5
+        @enable_reaper = true
+        @reaper_interval = 60
+        @idle_timeout = 300
+      end
+    end
+  end
+end

data/lib/model_context_protocol/server/redis_pool_manager.rb

@@ -0,0 +1,110 @@
+module ModelContextProtocol
+  class Server::RedisPoolManager
+    attr_reader :pool, :reaper_thread
+
+    def initialize(redis_url:, pool_size: 20, pool_timeout: 5)
+      @redis_url = redis_url
+      @pool_size = pool_size
+      @pool_timeout = pool_timeout
+      @pool = nil
+      @reaper_thread = nil
+      @reaper_config = {
+        enabled: false,
+        interval: 60,
+        idle_timeout: 300
+      }
+    end
+
+    def configure_reaper(enabled:, interval: 60, idle_timeout: 300)
+      @reaper_config = {
+        enabled: enabled,
+        interval: interval,
+        idle_timeout: idle_timeout
+      }
+    end
+
+    def start
+      validate!
+      create_pool
+      start_reaper if @reaper_config[:enabled]
+      true
+    end
+
+    def shutdown
+      stop_reaper
+      close_pool
+    end
+
+    def healthy?
+      return false unless @pool
+
+      @pool.with do |conn|
+        conn.ping == "PONG"
+      end
+    rescue
+      false
+    end
+
+    def reap_now
+      return unless @pool
+
+      @pool.reap(@reaper_config[:idle_timeout]) do |conn|
+        conn.close
+      end
+    end
+
+    def stats
+      return {} unless @pool
+
+      {
+        size: @pool.size,
+        available: @pool.available,
+        idle: @pool.instance_variable_get(:@idle_since)&.size || 0
+      }
+    end
+
+    private
+
+    def validate!
+      raise ArgumentError, "redis_url is required" if @redis_url.nil? || @redis_url.empty?
+      raise ArgumentError, "pool_size must be positive" if @pool_size <= 0
+      raise ArgumentError, "pool_timeout must be positive" if @pool_timeout <= 0
+    end
+
+    def create_pool
+      @pool = ConnectionPool.new(size: @pool_size, timeout: @pool_timeout) do
+        Redis.new(url: @redis_url)
+      end
+    end
+
+    def close_pool
+      @pool&.shutdown { |conn| conn.close }
+      @pool = nil
+    end
+
+    def start_reaper
+      return if @reaper_thread&.alive?
+
+      @reaper_thread = Thread.new do
+        loop do
+          sleep @reaper_config[:interval]
+          begin
+            reap_now
+          rescue => e
+            warn "Redis reaper error: #{e.message}"
+          end
+        end
+      end
+
+      @reaper_thread.name = "MCP-Redis-Reaper"
+    end
+
+    def stop_reaper
+      return unless @reaper_thread&.alive?
+
+      @reaper_thread.kill
+      @reaper_thread.join(5)
+      @reaper_thread = nil
+    end
+  end
+end