actionmodelcontext 2026.11.02.161253

data/lib/action_model_context/railtie.rb

@@ -0,0 +1,35 @@
+module ActionModelContext
+  # Autoloads `app/mcp`, reports failures through {ErrorReporter} and sets up `config.action_model_context.oauth`.
+  #
+  # @api private
+  class Railtie < Rails::Railtie
+    config.action_model_context = ActiveSupport::OrderedOptions.new
+    config.action_model_context.oauth = ActiveSupport::OrderedOptions.new
+
+    initializer 'action_model_context.autoload' do |app|
+      Rails.autoloaders.main.collapse(*%w[tools resources prompts].map { |dir| app.root.join('app/mcp', dir).to_s })
+    end
+
+    initializer 'action_model_context.exception_reporter' do
+      MCP.configure { |config| config.exception_reporter = ErrorReporter }
+    end
+
+    initializer 'action_model_context.oauth', after: :load_config_initializers do |app|
+      oauth = app.config.action_model_context.oauth
+      raise ArgumentError, 'config.action_model_context.oauth.token_verifier requires oauth.resource' if oauth.token_verifier && !oauth.resource
+      next unless oauth.resource
+
+      oauth.metadata = MCP::Server::OAuth::ProtectedResourceMetadata.new(
+        resource: oauth.resource, authorization_servers: oauth.authorization_servers, scopes_supported: oauth.scopes,
+        resource_name: oauth.resource_name, resource_documentation: oauth.resource_documentation, extra: oauth.extra || {},
+      )
+      app.middleware.use ProtectedResourceMetadataMiddleware, oauth.metadata
+    end
+
+    # The verifier may name an app class, which cannot autoload while initializers run: DoorkeeperTokenVerifier in app/mcp.
+    config.to_prepare do
+      oauth = Rails.application.config.action_model_context.oauth
+      oauth.verifier = oauth.token_verifier&.call(oauth.metadata)
+    end
+  end
+end

data/lib/action_model_context/resource.rb

@@ -0,0 +1,133 @@
+require 'active_support/core_ext/class/attribute'
+
+module ActionModelContext
+  # Base class of the resources. An application subclasses it through `ApplicationResource`, under `app/mcp/resources`.
+  #
+  # @example
+  #   class UserResource < ApplicationResource
+  #     uri 'users://{id}'
+  #
+  #     def read(id:) = { id:, viewer: context[:user] }
+  #   end
+  #
+  # @api public
+  class Resource
+    include Primitive
+
+    primitive kind: :resources, suffix: 'Resource'
+
+    # @api private
+    URI_VARIABLE = /\{([A-Za-z_]\w*)\}/
+
+    class_attribute :declared_mime_type, instance_accessor: false, instance_predicate: false
+
+    class << self
+      # Declares the URI, or reads it. A `{variable}` makes the resource a template, and subclasses do not inherit it.
+      #
+      # @param value [String, nil] the URI to declare
+      # @return [String, nil] nil when the class declares none
+      def uri(value = nil)
+        return @declared_uri = value if value
+
+        @declared_uri
+      end
+
+      # Declares the MIME type, or reads it. Subclasses inherit it, and it overrides the one derived from {#read}.
+      #
+      # @param value [String, nil] the MIME type to declare
+      # @return [String, nil] nil when none is declared
+      def mime_type(value = nil)
+        return self.declared_mime_type = value if value
+
+        declared_mime_type
+      end
+
+      # Declares the name, or reads it.
+      #
+      # @param name [String, nil] the name to declare
+      # @return [String, nil] the declared name, else the underscored class name without its `Resource` suffix
+      def resource_name(name = nil) = primitive_name(name)
+
+      # Tells whether the resource is exposed, which takes its own {uri} and a `read` below this class.
+      #
+      # @return [Boolean]
+      # @api private
+      def concrete? = !uri.nil? && instance_method(:read).owner != Resource
+
+      # Tells whether the URI holds variables.
+      #
+      # @return [Boolean]
+      # @api private
+      def template? = uri.include?('{')
+
+      # Lists the variables of the URI.
+      #
+      # @return [Array<Symbol>]
+      # @api private
+      def uri_variables = uri.scan(URI_VARIABLE).flatten.map(&:to_sym)
+
+      # Builds the SDK resource or resource template for a request.
+      #
+      # @param context [Object] the context of the request
+      # @return [Class<MCP::Resource>, Class<MCP::ResourceTemplate>]
+      # @api private
+      def to_mcp(context:)
+        resource = self
+        if template?
+          MCP::ResourceTemplate.define(uri_template: uri, **definition) do |**params|
+            resource.new(context:).read_mcp(params.except(:server_context))
+          end
+        else
+          MCP::Resource.define(uri:, **definition) { |**| resource.new(context:).read_mcp({}) }
+        end
+      end
+
+      private
+
+      # Lists the fields common to a resource and a resource template.
+      #
+      # @return [Hash]
+      # @api private
+      def definition = { name: resource_name, title:, description:, mime_type: }
+    end
+
+    # Reads the resource. A subclass defines it, with one keyword per variable of the URI.
+    #
+    # @return [String, Hash, Array] the contents: a `String` goes out as `text/plain`, the others as `application/json`
+    # @raise [Error] to answer an `invalid_params` JSON-RPC error
+    # @raise [NotImplementedError] when no subclass defines it
+    def read(**) = raise(NotImplementedError, "#{self.class.name}#read is not implemented")
+
+    # Reads the resource for the SDK.
+    #
+    # @param params [Hash] the variables of the requested URI
+    # @return [MCP::Resource::TextContents]
+    # @raise [MCP::Server::RequestHandlerError] when the resource raises {Error}
+    # @api private
+    def read_mcp(params)
+      params = params.slice(*self.class.uri_variables)
+      to_contents(with_rescue { read(**params) }, params)
+    rescue Error => e
+      raise_invalid_params(e)
+    end
+
+    private
+
+    # Converts the value of {#read}.
+    #
+    # @param result [String, Hash, Array] that value
+    # @param params [Hash] the variables that expand the URI
+    # @return [MCP::Resource::TextContents]
+    # @raise [TypeError] when the value is of another class
+    # @api private
+    def to_contents(result, params)
+      text, default_mime = case result
+      when String then [ result, 'text/plain' ]
+      when Hash, Array then [ result.to_json, 'application/json' ]
+      else raise TypeError, "#{self.class.name}#read or its rescue_from handler must return a String, Hash or Array, got #{result.class}"
+      end
+      uri = self.class.uri.gsub(URI_VARIABLE) { params.fetch(Regexp.last_match(1).to_sym) }
+      MCP::Resource::TextContents.new(text:, uri:, mime_type: self.class.mime_type || default_mime)
+    end
+  end
+end

data/lib/action_model_context/server.rb

@@ -0,0 +1,166 @@
+require 'active_support/concern'
+
+module ActionModelContext
+  # Controller concern that serves MCP over the SDK's Streamable HTTP transport, stateless with JSON responses.
+  # It discovers the primitives through `ApplicationTool`, `ApplicationResource` and `ApplicationPrompt`.
+  #
+  # @example
+  #   class McpController < ApplicationController
+  #     include ActionModelContext::Server
+  #     before_action :authenticate_user!
+  #
+  #     private
+  #
+  #     def mcp_context = { user: current_user }
+  #   end
+  #
+  # @api public
+  module Server
+    extend ActiveSupport::Concern
+
+    included do
+      skip_forgery_protection only: %i[show create destroy] if respond_to?(:skip_forgery_protection)
+      before_action :verify_mcp_access_token, only: %i[show create destroy], if: -> { mcp_oauth.verifier }
+    end
+
+    # Loads a family of primitives and lists its concrete classes.
+    #
+    # @param base_name [String] the name of the family's base class
+    # @param dir [String] its directory under `app/mcp`
+    # @return [Array<Class>] empty when the base class does not exist
+    # @api private
+    def self.discover(base_name, dir)
+      path = Rails.root.join('app/mcp', dir)
+      Rails.autoloaders.main.eager_load_dir(path) if path.directory?
+      base_name.safe_constantize&.descendants&.select(&:concrete?) || []
+    end
+
+    # Serves an MCP `GET`.
+    #
+    # @return [void]
+    # @api private
+    def show = serve_mcp
+    # Serves an MCP `POST`.
+    #
+    # @return [void]
+    # @api private
+    def create = serve_mcp
+    # Serves an MCP `DELETE`.
+    #
+    # @return [void]
+    # @api private
+    def destroy = serve_mcp
+
+    private
+
+    # Gives every primitive its `context` for the request: override this private method in the controller.
+    #
+    # @!visibility public
+    # @return [Object] an empty hash by default
+    def mcp_context = {}
+    # Gives the keyword arguments of `MCP::Server.new`: override this private method in the controller.
+    #
+    # @!visibility public
+    # @return [Hash] the underscored module name of the app as `name:` by default
+    def mcp_server_options = { name: Rails.application.class.module_parent_name.underscore }
+    # Gives the keyword arguments of `MCP::Server::Transports::StreamableHTTPTransport.new`: override this private
+    # method in the controller. `stateless`, `enable_json_response` and `serve_subscriptions_listen` stay pinned.
+    #
+    # @!visibility public
+    # @return [Hash] empty by default
+    def mcp_transport_options = {}
+
+    # Answers the SDK's 401 challenge. Call this private method when the app itself rejects a request.
+    #
+    # @example
+    #   before_action { request_mcp_authentication unless user_signed_in? }
+    #
+    # @!visibility public
+    # @return [void]
+    def request_mcp_authentication
+      render_mcp_challenge(MCP::Server::OAuth::Challenge.missing_token_response(scope: mcp_oauth.scopes&.join(' '), resource_metadata: mcp_resource_metadata_url))
+    end
+
+    # Gives the token verified through `config.action_model_context.oauth.token_verifier`.
+    #
+    # @!visibility public
+    # @return [MCP::Server::OAuth::AccessToken, nil] nil when no token was verified
+    def mcp_access_token = request.env[MCP::Server::OAuth::ENV_KEY]
+
+    # Checks the bearer token, and answers the SDK's challenge when it is rejected.
+    #
+    # @return [void]
+    # @api private
+    def verify_mcp_access_token
+      authenticator = MCP::Server::OAuth::Authenticator.new(
+        token_verifier: mcp_oauth.verifier, required_scopes: mcp_oauth.scopes,
+        resource_metadata: mcp_oauth.metadata, resource_metadata_url: mcp_resource_metadata_url,
+      )
+      request.env[MCP::Server::OAuth::ENV_KEY] = authenticator.authenticate(request.env)
+    rescue MCP::Server::OAuth::Error => e
+      render_mcp_challenge(authenticator.challenge_response(e))
+    end
+
+    # Reads `config.action_model_context.oauth`.
+    #
+    # @return [ActiveSupport::OrderedOptions]
+    # @api private
+    def mcp_oauth = Rails.configuration.action_model_context.oauth
+
+    # A proxy can strip the path prefix and pass on only X-Forwarded-Host, leaving SCRIPT_NAME empty:
+    # the public URL declared in resource is then the one place that still holds the prefix.
+    #
+    # @return [String] the URL of the metadata document
+    # @api private
+    def mcp_resource_metadata_url
+      resource = mcp_oauth.resource
+      return "#{resource.delete_suffix(request.path_info)}#{ProtectedResourceMetadataMiddleware::PATH}" if resource&.end_with?(request.path_info)
+
+      "#{request.base_url}#{request.script_name}#{ProtectedResourceMetadataMiddleware::PATH}"
+    end
+
+    # Answers with a challenge built by the SDK.
+    #
+    # @param challenge [Array(Integer, Hash, Array)] the Rack response
+    # @return [void]
+    # @api private
+    def render_mcp_challenge(challenge)
+      self.status, challenge_headers, self.response_body = challenge
+      headers.merge!(challenge_headers)
+    end
+
+    # handle_request, not call(env): Rails already read the body into RAW_POST_DATA to log params, and only
+    # ActionDispatch::Request#body replays it when rack.input cannot rewind (optional since Rack 3).
+    #
+    # @return [void]
+    # @api private
+    def serve_mcp
+      self.status, transport_headers, self.response_body = mcp_transport.handle_request(request)
+      headers.merge!(transport_headers)
+    end
+
+    # Builds the server and its transport for the request.
+    #
+    # @return [MCP::Server::Transports::StreamableHTTPTransport]
+    # @api private
+    def mcp_transport
+      context = mcp_context
+      templates, resources = Server.discover('ApplicationResource', 'resources').partition(&:template?)
+      server = MCP::Server.new(
+        **mcp_server_options,
+        tools: Server.discover('ApplicationTool', 'tools').map { |tool| tool.to_mcp(context:) },
+        resources: resources.map { |resource| resource.to_mcp(context:) },
+        resource_templates: templates.map { |template| template.to_mcp(context:) },
+        prompts: Server.discover('ApplicationPrompt', 'prompts').map { |prompt| prompt.to_mcp(context:) },
+        capabilities: { tools: {}, resources: {}, prompts: {} },
+      )
+      # Host checking is left to Rails' config.hosts: the transport's own check rejects every Host but 127.0.0.1,
+      # ::1 and localhost. The structural options come last because stateless: false starts one session reaper
+      # thread per request that nothing ever closes.
+      MCP::Server::Transports::StreamableHTTPTransport.new(
+        server, dns_rebinding_protection: false, **mcp_transport_options,
+        stateless: true, enable_json_response: true, serve_subscriptions_listen: false,
+      )
+    end
+  end
+end

data/lib/action_model_context/test_helper.rb

@@ -0,0 +1,61 @@
+require 'action_model_context'
+
+module ActionModelContext
+  # Runs a tool in a test through a real `MCP::Server`, so argument validation and error handling behave as in
+  # production.
+  #
+  # @example
+  #   include ActionModelContext::TestHelper
+  #
+  #   result = call_tool(EchoTool, message: 'hi', times: 2)
+  #   result.text #=> 'hihi'
+  #
+  # @api public
+  module TestHelper
+    # What {TestHelper#call_tool} returns.
+    #
+    # @!attribute [r] text
+    #   The text parts of the result, joined.
+    #   @return [String]
+    #   @api public
+    # @!attribute [r] structured_content
+    #   The structured content of the result.
+    #   @return [Hash, nil]
+    #   @api public
+    # @!attribute [r] error
+    #   Whether the tool answered an error result.
+    #   @return [Boolean]
+    #   @api public
+    Result = Data.define(:text, :structured_content, :error) do
+      # Tells whether the tool answered an error result.
+      #
+      # @return [Boolean]
+      def error? = error
+    end
+
+    # Calls a tool. An unexpected exception raised by the tool is raised again here.
+    #
+    # @param tool_class [Class] a subclass of {Tool}
+    # @param context [Object] the context given to the tool
+    # @param arguments [Hash] the arguments of the tool
+    # @return [Result]
+    def call_tool(tool_class, context: {}, **arguments)
+      raised = []
+      server = MCP::Server.new(
+        tools: [ tool_class.to_mcp(context:) ],
+        configuration: MCP::Configuration.new(exception_reporter: ->(exception, _) { raised << exception }),
+      )
+      response = server.handle(
+        { jsonrpc: '2.0', id: 1, method: 'tools/call', params: { name: tool_class.tool_name, arguments: } },
+      )
+      raise raised.first if response[:error] && raised.any?
+
+      result = response.fetch(:result)
+      Result.new(
+        text: result[:content].filter_map { |part| part[:text] if part[:type] == 'text' }.join,
+        structured_content: result[:structuredContent],
+        error: result[:isError] == true,
+      )
+    end
+  end
+end

data/lib/action_model_context/tool.rb

@@ -0,0 +1,196 @@
+require 'active_support/core_ext/class/attribute'
+require 'active_support/rescuable'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/object/blank'
+
+module ActionModelContext
+  # Base class of the tools. An application subclasses it through `ApplicationTool`, under `app/mcp/tools`.
+  #
+  # @example
+  #   class EchoTool < ApplicationTool
+  #     argument :message, :string, required: true
+  #     argument :times, :integer
+  #
+  #     def call(message:, times: 1) = message * times
+  #   end
+  #
+  # @api public
+  class Tool
+    include Primitive
+
+    primitive kind: :tools, suffix: 'Tool'
+
+    # The types {argument} accepts.
+    ARGUMENT_TYPES = %i[string integer number boolean array object].freeze
+    # @api private
+    ARGUMENT_OPTIONS = %i[required null].freeze
+    # JSON Schema 2020-12, the dialect MCP mandates (SEP-1613), minus type and required that argument sets itself.
+    SCHEMA_KEYWORDS = %w[
+      $id $schema $ref $anchor $dynamicRef $dynamicAnchor $vocabulary $comment $defs
+      prefixItems items contains additionalProperties properties patternProperties dependentSchemas propertyNames
+      if then else allOf anyOf oneOf not unevaluatedItems unevaluatedProperties
+      const enum multipleOf maximum exclusiveMaximum minimum exclusiveMinimum maxLength minLength pattern
+      maxItems minItems uniqueItems maxContains minContains maxProperties minProperties dependentRequired
+      title description default deprecated readOnly writeOnly examples format contentEncoding contentMediaType contentSchema
+    ].freeze
+
+    class_attribute :declared_annotations, instance_accessor: false, instance_predicate: false
+    class_attribute :arguments, instance_accessor: false, instance_predicate: false, default: {}.freeze
+
+    class << self
+      # Declares the name, or reads it.
+      #
+      # @param name [String, nil] the name to declare
+      # @return [String, nil] the declared name, else the underscored class name without its `Tool` suffix
+      def tool_name(name = nil) = primitive_name(name)
+
+      # Declares an argument of the input schema.
+      #
+      # @example
+      #   argument :ids, :array, required: true, items: { type: 'integer' }, max_items: 50
+      #
+      # @param name [Symbol, String] the argument's name
+      # @param type [Symbol] one of {ARGUMENT_TYPES}
+      # @param keywords [Hash] any JSON Schema 2020-12 keyword, in snake_case or camelCase
+      # @option keywords [Boolean] :required (false) whether the client must send it
+      # @option keywords [Boolean] :null (false) whether it also accepts `null`
+      # @return [void]
+      # @raise [ArgumentError] when the type or a keyword is unknown
+      def argument(name, type, **keywords)
+        raise ArgumentError, "unknown argument type #{type.inspect}" unless ARGUMENT_TYPES.include?(type)
+
+        unknown = keywords.keys.reject { |key| ARGUMENT_OPTIONS.include?(key) || SCHEMA_KEYWORDS.include?(key.to_s.camelize(:lower)) }
+        raise ArgumentError, "unknown JSON Schema keyword #{unknown.first.inspect} for argument #{name.inspect}" if unknown.any?
+
+        self.arguments = arguments.merge(name.to_sym => keywords.merge(type:)).freeze
+      end
+
+      # Declares one argument per entry of a JSON Schema `properties` hash, `type: [..., 'null']` becoming `null: true`.
+      #
+      # @example
+      #   arguments_from({ title: { type: 'string' }, due_on: { type: %w[string null] } }, required: %i[title])
+      #
+      # @param properties [Hash{Symbol, String => Hash}] the schema of each argument
+      # @param required [Array<Symbol, String>] the names of the required arguments
+      # @return [void]
+      # @raise [ArgumentError] when a property has no single type, lists its own `required` or takes an unknown keyword
+      def arguments_from(properties, required: [])
+        required = required.map(&:to_s)
+        properties.each do |name, schema|
+          schema = schema.symbolize_keys
+          raise ArgumentError, "argument #{name.to_sym.inspect} lists its own required properties, which argument cannot express" if schema.key?(:required)
+
+          types = Array(schema[:type]).map(&:to_s)
+          null = types.delete('null').present?
+          raise ArgumentError, "argument #{name.to_sym.inspect} needs a single type, got #{schema[:type].inspect}" unless types.one?
+
+          argument(name, types.first.to_sym, required: required.include?(name.to_s), null:, **schema.except(:type))
+        end
+      end
+
+      # Lists the declared arguments.
+      #
+      # @return [Array<Symbol>]
+      # @api private
+      def argument_names = arguments.keys
+
+      # Tells whether the tool is exposed, which takes a `call` below this class.
+      #
+      # @return [Boolean]
+      # @api private
+      def concrete? = instance_method(:call).owner != Tool
+
+      # Declares the annotations, or reads them.
+      #
+      # @param hints [Hash] the keywords of `MCP::Tool::Annotations`, such as `read_only_hint: true`
+      # @return [Hash, nil] nil when none are declared
+      def annotations(**hints)
+        return declared_annotations if hints.empty?
+
+        self.declared_annotations = hints
+      end
+
+      # Builds the SDK tool for a request.
+      #
+      # @param context [Object] the context of the request
+      # @return [Class<MCP::Tool>]
+      # @api private
+      def to_mcp(context:)
+        tool = self
+        MCP::Tool.define(
+          name: tool_name, title:, description:, input_schema:, annotations: declared_annotations,
+        ) { |**args| tool.new(context:).call_mcp(args.except(:server_context)) }
+      end
+
+      private
+
+      # Builds the JSON Schema of the arguments.
+      #
+      # @return [Hash]
+      # @api private
+      def input_schema
+        properties = arguments.to_h { |name, spec| [ name, property_schema(name, spec) ] }
+        required = arguments.select { |_, spec| spec[:required] }.keys.map(&:to_s)
+        { type: 'object', properties:, required: }.compact_blank
+      end
+
+      # Builds the JSON Schema of an argument, its description falling back on I18n.
+      #
+      # @param name [Symbol] the argument's name
+      # @param spec [Hash] its declaration
+      # @return [Hash]
+      # @api private
+      def property_schema(name, spec)
+        type = spec[:null] ? [ spec[:type].to_s, 'null' ] : spec[:type].to_s
+        keywords = spec.except(*ARGUMENT_OPTIONS).transform_keys { |key| key.to_s.camelize(:lower).to_sym }
+        description = keywords[:description] || Translation.argument(i18n_kind, tool_name, name, :description)
+        { **keywords, type:, description: }.compact
+      end
+    end
+
+    # Runs the tool. A subclass defines it, with one keyword per argument it takes.
+    #
+    # @return [String, Hash, Array, MCP::Tool::Response] the result, a `Hash` also going out as structured content
+    # @raise [Error] to answer an error result with its message
+    # @raise [NotImplementedError] when no subclass defines it
+    def call(**) = raise(NotImplementedError, "#{self.class.name}#call is not implemented")
+
+    # Runs the tool for the SDK.
+    #
+    # @param arguments [Hash] the arguments the client sent
+    # @return [MCP::Tool::Response]
+    # @api private
+    def call_mcp(arguments)
+      to_response(with_rescue { invoke(arguments) })
+    rescue Error => e
+      MCP::Tool::Response.new([ { type: 'text', text: e.message } ], error: true)
+    end
+
+    private
+
+    # Wraps every call of the tool: override this private method and call `super`, as `process_action` in a
+    # controller. `rescue_from` covers it.
+    #
+    # @!visibility public
+    # @param arguments [Hash] the arguments as the client sent them, before they are sliced to the declared ones
+    # @return [Object] the value of {#call}, before its conversion
+    def invoke(arguments) = call(**arguments.slice(*self.class.argument_names))
+
+    # Converts the value of {#call}.
+    #
+    # @param result [String, Hash, Array, MCP::Tool::Response] that value
+    # @return [MCP::Tool::Response]
+    # @raise [TypeError] when the value is of another class
+    # @api private
+    def to_response(result)
+      case result
+      when MCP::Tool::Response then result
+      when String then MCP::Tool::Response.new([ { type: 'text', text: result } ])
+      when Hash then MCP::Tool::Response.new([ { type: 'text', text: result.to_json } ], structured_content: result)
+      when Array then MCP::Tool::Response.new([ { type: 'text', text: result.to_json } ])
+      else raise TypeError, "#{self.class.name}#call or its rescue_from handler must return a String, Hash, Array or MCP::Tool::Response, got #{result.class}"
+      end
+    end
+  end
+end

data/lib/action_model_context/translation.rb

@@ -0,0 +1,30 @@
+module ActionModelContext
+  # Reads the titles and descriptions of primitives from I18n.
+  #
+  # @api private
+  module Translation
+    # Looks up a key under `action_model_context.<kind>.<name>`.
+    #
+    # @param kind [Symbol] `:tools`, `:resources` or `:prompts`
+    # @param name [String, nil] the primitive name
+    # @param path [Array<Symbol>] the path of the key
+    # @return [String, Hash, nil] nil when the key is missing or the primitive has no name
+    def self.lookup(kind, name, *path)
+      return unless name
+
+      I18n.t(path.last, scope: [ :action_model_context, kind, name, *path[0...-1] ], default: nil)
+    end
+
+    # Reads an argument's title or description: a plain string under `arguments.<argument>` is its description.
+    #
+    # @param kind [Symbol] `:tools`, `:resources` or `:prompts`
+    # @param name [String, nil] the primitive name
+    # @param argument [Symbol] the argument name
+    # @param key [Symbol] `:title` or `:description`
+    # @return [String, nil]
+    def self.argument(kind, name, argument, key)
+      value = lookup(kind, name, :arguments, argument)
+      value.is_a?(Hash) ? value[key] : (value if key == :description)
+    end
+  end
+end

data/lib/action_model_context/version.rb

@@ -0,0 +1,3 @@
+module ActionModelContext
+  VERSION = '2026.11.02.161253'
+end

data/lib/action_model_context.rb

@@ -0,0 +1,14 @@
+require 'mcp'
+require 'active_support'
+require 'action_model_context/version'
+require 'action_model_context/error'
+require 'action_model_context/naming'
+require 'action_model_context/translation'
+require 'action_model_context/primitive'
+require 'action_model_context/tool'
+require 'action_model_context/resource'
+require 'action_model_context/prompt'
+require 'action_model_context/error_reporter'
+require 'action_model_context/protected_resource_metadata_middleware'
+require 'action_model_context/server'
+require 'action_model_context/railtie' if defined?(Rails::Railtie)

data/lib/actionmodelcontext.rb

@@ -0,0 +1 @@
+require 'action_model_context'