actionmcp 0.80.1 → 0.82.0

data/lib/action_mcp/logging/null_logger.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Logging
+    # Null logger that performs no operations when logging is disabled
+    # Provides the same interface as Logger but with zero overhead
+    class NullLogger
+      # Initialize a null logger (no-op)
+      # @param args [Array] Any arguments (ignored)
+      def initialize(*args, **kwargs)
+        # Intentionally empty - no state needed
+      end
+
+      # Log methods - all no-ops that return nil immediately
+      def debug(*args, **kwargs, &block)
+        nil
+      end
+
+      def info(*args, **kwargs, &block)
+        nil
+      end
+
+      def notice(*args, **kwargs, &block)
+        nil
+      end
+
+      def warning(*args, **kwargs, &block)
+        nil
+      end
+      alias_method :warn, :warning
+
+      def error(*args, **kwargs, &block)
+        nil
+      end
+
+      def critical(*args, **kwargs, &block)
+        nil
+      end
+
+      def alert(*args, **kwargs, &block)
+        nil
+      end
+
+      def emergency(*args, **kwargs, &block)
+        nil
+      end
+
+      # Level check methods - all return false (nothing will be logged)
+      def debug?
+        false
+      end
+
+      def info?
+        false
+      end
+
+      def notice?
+        false
+      end
+
+      def warning?
+        false
+      end
+      alias_method :warn?, :warning?
+
+      def error?
+        false
+      end
+
+      def critical?
+        false
+      end
+
+      def alert?
+        false
+      end
+
+      def emergency?
+        false
+      end
+
+      # Implement any other methods that might be called to avoid NoMethodError
+      def method_missing(method_name, *args, **kwargs, &block)
+        # Return nil for any unknown method calls
+        nil
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        # Pretend to respond to any method to avoid issues
+        true
+      end
+    end
+  end
+end

data/lib/action_mcp/logging/state.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "concurrent"
+
+module ActionMCP
+  module Logging
+    # Thread-safe global state for MCP logging
+    class State
+      # Initialize with default values
+      def initialize
+        @enabled = Concurrent::AtomicBoolean.new(false)
+        @global_level = Concurrent::AtomicFixnum.new(Level::LEVELS[:warning])
+      end
+
+      # Check if logging is enabled
+      # @return [Boolean] true if enabled, false otherwise
+      def enabled?
+        @enabled.value
+      end
+
+      # Enable logging
+      # @return [Boolean] true (new value)
+      def enable!
+        @enabled.make_true
+      end
+
+      # Disable logging
+      # @return [Boolean] false (new value)
+      def disable!
+        @enabled.make_false
+      end
+
+      # Set enabled state
+      # @param value [Boolean] true to enable, false to disable
+      # @return [Boolean] the new value
+      def enabled=(value)
+        if value
+          enable!
+        else
+          disable!
+        end
+      end
+
+      # Get current minimum log level as integer
+      # @return [Integer] the current level (0-7)
+      def level
+        @global_level.value
+      end
+
+      # Get current minimum log level as symbol
+      # @return [Symbol] the current level symbol
+      def level_symbol
+        Level.name_for(@global_level.value)
+      end
+
+      # Set minimum log level
+      # @param new_level [String, Symbol, Integer] the new level
+      # @return [Integer] the new level as integer
+      def level=(new_level)
+        level_int = Level.coerce(new_level)
+        @global_level.value = level_int
+        level_int
+      end
+
+      # Check if a message at the given level should be logged
+      # @param message_level [String, Symbol, Integer] the message level
+      # @return [Boolean] true if should be logged, false otherwise
+      def should_log?(message_level)
+        return false unless enabled?
+
+        message_level_int = Level.coerce(message_level)
+        message_level_int >= @global_level.value
+      end
+
+      # Reset to initial state (for testing)
+      # @return [void]
+      def reset!
+        disable!
+        self.level = :warning
+      end
+    end
+  end
+end

data/lib/action_mcp/logging.rb

@@ -5,13 +5,89 @@ require "active_support/logger"
 require "logger"
 
 module ActionMCP
-  # Module for providing logging functionality to ActionMCP transport.
+  # Global MCP logging interface
   module Logging
-    extend ActiveSupport::Concern
+    class << self
+      # Get the global logging state
+      # @return [ActionMCP::Logging::State] The global state
+      def state
+        @state ||= State.new
+      end
 
-    # Included hook to configure the logger.
-    included do
-      cattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
+      # Reset the global state (for testing)
+      # @return [void]
+      def reset!
+        @state = State.new
+      end
+
+      # Check if logging is enabled
+      # @return [Boolean] true if enabled
+      def enabled?
+        ActionMCP.configuration.logging_enabled && state.enabled?
+      end
+
+      # Enable MCP logging
+      # @return [Boolean] true
+      def enable!
+        ActionMCP.configuration.logging_enabled = true
+        state.enable!
+      end
+
+      # Disable MCP logging
+      # @return [Boolean] false
+      def disable!
+        state.disable!
+      end
+
+      # Get the current minimum log level
+      # @return [Symbol] current level
+      def level
+        state.level_symbol
+      end
+
+      # Set the minimum log level
+      # @param new_level [String, Symbol, Integer] the new level
+      # @return [Symbol] the new level as symbol
+      def level=(new_level)
+        state.level = new_level
+        state.level_symbol
+      end
+      alias_method :set_level, :level=
+
+      # Create a logger for the given session
+      # @param name [String, nil] Optional logger name
+      # @param session [ActionMCP::Session] The MCP session
+      # @return [ActionMCP::Logging::Logger, ActionMCP::Logging::NullLogger] logger instance
+      def logger(name: nil, session:)
+        if enabled?
+          Logger.new(name: name, session: session, state: state)
+        else
+          NullLogger.new
+        end
+      end
+
+      # Convenience method to get a logger for the current session context
+      # @param name [String, nil] Optional logger name
+      # @param execution_context [Hash] Context containing session
+      # @return [ActionMCP::Logging::Logger, ActionMCP::Logging::NullLogger] logger instance
+      def logger_for_context(name: nil, execution_context:)
+        session = execution_context[:session]
+        return NullLogger.new unless session
+
+        logger(name: name, session: session)
+      end
+    end
+
+    # Initialize logging state based on configuration
+    def self.initialize_from_config!
+      # Always set the level from configuration
+      state.level = ActionMCP.configuration.logging_level
+
+      if ActionMCP.configuration.logging_enabled
+        state.enable!
+      else
+        state.disable!
+      end
     end
   end
 end

data/lib/action_mcp/output_schema_builder.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require_relative "schema_helpers"
+
+module ActionMCP
+  # DSL builder for creating output JSON Schema from Ruby-like syntax
+  # Unlike SchemaBuilder, this preserves nested structure for validation
+  class OutputSchemaBuilder
+    include SchemaHelpers
+
+    attr_reader :properties, :required
+
+    def initialize
+      @properties = {}
+      @required = []
+    end
+
+    # Define a property with specified type
+    # @param name [Symbol] Property name
+    # @param type [String] JSON Schema type
+    # @param required [Boolean] Whether the property is required
+    # @param description [String] Property description
+    # @param options [Hash] Additional JSON Schema options
+    def property(name, type: "string", required: false, description: nil, **options)
+      schema = { "type" => type }
+      schema["description"] = description if description
+      schema.merge!(options) if options.any?
+
+      @properties[name.to_s] = schema
+      @required << name.to_s if required
+
+      name.to_s
+    end
+
+    # Define a string property
+    def string(name = nil, required: false, description: nil, format: nil, enum: nil,
+               default: nil, min_length: nil, max_length: nil)
+      schema = { "type" => "string" }
+      schema["description"] = description if description
+      schema["format"] = format if format
+      schema["enum"] = enum if enum
+      schema["default"] = default if default
+      schema["minLength"] = min_length if min_length
+      schema["maxLength"] = max_length if max_length
+
+      if name
+        @properties[name.to_s] = schema
+        @required << name.to_s if required
+        name.to_s
+      else
+        # Return schema for use in array items or other contexts
+        schema
+      end
+    end
+
+    # Define a number property
+    def number(name, required: false, description: nil, minimum: nil,
+               maximum: nil, default: nil)
+      schema = { "type" => "number" }
+      schema["description"] = description if description
+      schema["minimum"] = minimum if minimum
+      schema["maximum"] = maximum if maximum
+      schema["default"] = default if default
+
+      @properties[name.to_s] = schema
+      @required << name.to_s if required
+
+      name.to_s
+    end
+
+    # Define a boolean property
+    def boolean(name, required: false, description: nil, default: nil)
+      schema = { "type" => "boolean" }
+      schema["description"] = description if description
+      schema["default"] = default unless default.nil?
+
+      @properties[name.to_s] = schema
+      @required << name.to_s if required
+
+      name.to_s
+    end
+
+    # Define an array property
+    # @param name [Symbol] Array property name
+    # @param description [String] Property description
+    # @param min_items [Integer] Minimum number of items
+    # @param max_items [Integer] Maximum number of items
+    # @param items [Hash] Items schema (if not using block)
+    # @param block [Proc] Block defining item schema
+    def array(name, description: nil, min_items: nil, max_items: nil, items: nil, &block)
+      schema = { "type" => "array" }
+      schema["description"] = description if description
+      schema["minItems"] = min_items if min_items
+      schema["maxItems"] = max_items if max_items
+
+      if block_given?
+        # Create nested builder for items
+        item_builder = OutputSchemaBuilder.new
+        result = item_builder.instance_eval(&block)
+
+        # If the block returned a schema directly (e.g., from string()),
+        # use that. Otherwise, build an object schema from properties.
+        if result.is_a?(Hash) && result["type"]
+          schema["items"] = result
+        elsif item_builder.properties.empty?
+          # Block didn't define properties, assume string items
+          schema["items"] = { "type" => "string" }
+        else
+          # Block defined object properties
+          item_schema = {
+            "type" => "object",
+            "properties" => item_builder.properties
+          }
+          item_schema["required"] = item_builder.required if item_builder.required.any?
+          schema["items"] = item_schema
+        end
+      elsif items
+        schema["items"] = items
+      else
+        # Default to string items
+        schema["items"] = { "type" => "string" }
+      end
+
+      @properties[name.to_s] = schema
+
+      name.to_s
+    end
+
+    # Define an object property
+    # @param name [Symbol] Object property name
+    # @param required [Boolean] Whether the object is required
+    # @param description [String] Property description
+    # @param additional_properties [Boolean, Hash] Whether to allow additional properties
+    # @param block [Proc] Block defining object properties
+    def object(name, required: false, description: nil, additional_properties: nil, &block)
+      raise ArgumentError, "Object definition requires a block" unless block_given?
+
+      # Create nested builder for object properties
+      object_builder = OutputSchemaBuilder.new
+      object_builder.instance_eval(&block)
+
+      schema = {
+        "type" => "object",
+        "properties" => object_builder.properties
+      }
+      schema["description"] = description if description
+      schema["required"] = object_builder.required if object_builder.required.any?
+
+      # Add additionalProperties if specified
+      add_additional_properties_to_schema(schema, additional_properties)
+
+      @properties[name.to_s] = schema
+      @required << name.to_s if required
+
+      name.to_s
+    end
+
+    # Set additionalProperties for the root schema
+    # @param enabled [Boolean, Hash] true to allow any additional properties,
+    #   false to disallow them, or a Hash for typed additional properties
+    def additional_properties(enabled = nil)
+      if enabled.nil?
+        @additional_properties
+      else
+        @additional_properties = enabled
+      end
+    end
+
+    # Generate the final JSON Schema
+    def to_json_schema
+      schema = {
+        "type" => "object",
+        "properties" => @properties
+      }
+
+      schema["required"] = @required.uniq if @required.any?
+
+      # Add additionalProperties if configured
+      add_additional_properties_to_schema(schema, @additional_properties)
+
+      schema
+    end
+  end
+end

data/lib/action_mcp/resource_template.rb

@@ -8,7 +8,6 @@ module ActionMCP
     include ActiveModel::Model
     include ActiveModel::Validations
     include ResourceCallbacks
-    include Logging
     include UriAmbiguityChecker
     include CurrentHelpers
 

data/lib/action_mcp/schema_helpers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  # Shared utilities for JSON Schema manipulation
+  module SchemaHelpers
+    private
+
+    # Helper method to add additionalProperties to a schema hash
+    # @param schema [Hash] The schema hash to modify
+    # @param additional_properties_value [Boolean, Hash, nil] The additionalProperties configuration
+    # @return [Hash] The modified schema hash
+    def add_additional_properties_to_schema(schema, additional_properties_value)
+      return schema if additional_properties_value.nil?
+
+      # Use HashWithIndifferentAccess for checking, but modify original schema
+      indifferent_schema = schema.with_indifferent_access
+
+      # Only add additionalProperties if this is a typed schema
+      return schema unless indifferent_schema[:type]
+
+      additional_props = case additional_properties_value
+      when true then {}
+      when false then false
+      when Hash then additional_properties_value
+      end
+
+      # Add to original schema using its key style (symbol or string)
+      if schema.key?(:type) || schema.key?("type")
+        key = schema.key?(:type) ? :additionalProperties : "additionalProperties"
+        schema[key] = additional_props
+      end
+
+      schema
+    end
+  end
+end

data/lib/action_mcp/server/handlers/logging_handler.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module ActionMCP
+  module Server
+    module Handlers
+      # Handler for MCP logging/setLevel requests
+      module LoggingHandler
+        # Handle logging/setLevel request
+        # @param id [String] The request ID
+        # @param params [Hash] Request parameters containing level
+        # @return [Hash] Empty hash on success
+        def handle_logging_set_level(id, params)
+          # Check if logging is enabled
+          unless ActionMCP.configuration.logging_enabled
+            transport.send_jsonrpc_error(id, :method_not_found, "Logging not enabled")
+            return
+          end
+
+          # Extract and validate level parameter
+          level = params[:level] || params["level"]
+          unless level
+            transport.send_jsonrpc_error(id, :invalid_params, "Missing required parameter: level")
+            return
+          end
+
+          begin
+            # Validate and set the new level
+            ActionMCP::Logging.set_level(level)
+
+            # Send successful response (empty object per MCP spec)
+            transport.send_jsonrpc_response(id, result: {})
+          rescue ArgumentError => e
+            # Invalid level
+            transport.send_jsonrpc_error(id, :invalid_params, "Invalid log level: #{e.message}")
+          rescue StandardError => e
+            # Internal error
+            transport.send_jsonrpc_error(id, :internal_error, "Internal error: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/action_mcp/server/json_rpc_handler.rb

@@ -6,6 +6,7 @@ module ActionMCP
       include Handlers::ResourceHandler
       include Handlers::ToolHandler
       include Handlers::PromptHandler
+      include Handlers::LoggingHandler
       include ErrorHandling
       include ErrorAware
 
@@ -55,6 +56,8 @@ module ActionMCP
           process_tools(rpc_method, id, params)
         when Methods::COMPLETION_COMPLETE
           process_completion_complete(id, params)
+        when Methods::LOGGING_SET_LEVEL
+          handle_logging_set_level(id, params)
         else
           raise JSON_RPC::JsonRpcError.new(:method_not_found, message: "Method not found: #{rpc_method}")
         end

data/lib/action_mcp/server/tools.rb

@@ -89,12 +89,11 @@ module ActionMCP
           end
 
           if result.is_error
-            # Convert ToolResponse error to proper JSON-RPC error format
-            # Pass the error hash directly - the Response class will handle it
-            error_hash = result.to_h
-            send_jsonrpc_response(request_id, error: error_hash)
+            # Protocol error
+            send_jsonrpc_response(request_id, error: result.to_h)
           else
-            send_jsonrpc_response(request_id, result: result)
+            # Success OR tool execution error - both are valid JSON-RPC responses
+            send_jsonrpc_response(request_id, result: result.to_h)
           end
         rescue ArgumentError => e
           # Handle parameter validation errors

data/lib/action_mcp/server/transport_handler.rb

@@ -10,7 +10,6 @@ module ActionMCP
 
       delegate :initialize!, :initialized?, to: :session
       delegate :read, :write, to: :session
-      include Logging
 
       include  MessagingService
       include  Capabilities