omni_agent 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f8a84d4b38e835bc00b73a88bc233932198498112e3837e33fdfdf3dbabab981
-  data.tar.gz: 6d5cd7709dc61be01ae892a67732b08ee3e17a6d4af7d81f8640f0fd618010e8
+  metadata.gz: bc288d35e0b6c6e5e4ea763c36d05aa37ee95d20aeb2f4b1369e15a6ba22bc92
+  data.tar.gz: 428b4d96e1b1f7ad2bf1f7cd2c99893333c0eac59d2add9a94faf18198376baa
 SHA512:
-  metadata.gz: b56c77174212b7a4ba2e45b2b3bb6e0f384631fcdd2bcbf30e2a32c8edb1617b239e8bdd482dbb259baf48746b20c38d29fd325685262337e38ab1e9669a5220
-  data.tar.gz: 5fcb5179527eda96d3dc6726ad78c73b1bba4b3ef7c34825cbfec03c2437e7018647b43cf9f9d43791599efdc628530d5c6cfefcb6f431bd7548a97f7c9a8365
+  metadata.gz: 9c55eaf9a31782bb1c16c152d15627943cef09f5a179c6039590b412dba505196aae36ed325905992bd26df567c74553a83fec629c59062c2cfa5d4981a03bf4
+  data.tar.gz: 904fdc44a855a5b7cfe66817cd531cc86bd44d5a8f8bccd6b97c6bf3d313a4b4e4a7a2f18fb18305bf5ae5be4bca7424562c1e39f77ecbb12ee63bea4d00fcf3

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.1.11](https://github.com/ACR1209/omni_agent/compare/omni_agent/v0.1.10...omni_agent/v0.1.11) (2026-10-15)
+
+
+### Features
+
+* **mcp:** add OAuth 2.1 authentication per the MCP authorization spec ([160c3d4](https://github.com/ACR1209/omni_agent/commit/160c3d47fb70272c58162359296c795a03b52219))
+
+
+### Bug Fixes
+
+* **mcp:** stop blocking requests while fetching the JWKS ([5074eb2](https://github.com/ACR1209/omni_agent/commit/5074eb2d939b2c1d6c365b15482cc9024f361527))
+
 ## [0.1.10](https://github.com/ACR1209/omni_agent/compare/omni_agent/v0.1.9...omni_agent/v0.1.10) (2026-10-09)
 
 

data/README.md

@@ -262,6 +262,10 @@ class SupportServer < OmniAgent::MCP::Server
 
 	authenticate :bearer, tokens: -> { ENV.fetch("SUPPORT_MCP_TOKENS", "").split(",") }
 	# or: authenticate { |request| User.find_by(api_token: request.bearer_token) }
+	# or OAuth 2.1 (MCP authorization spec), with tokens from your authorization server:
+	# authenticate :oauth, resource: "https://app.example.com/mcp/support",
+	#                      authorization_servers: "https://auth.example.com",
+	#                      jwks_uri: "https://auth.example.com/.well-known/jwks.json"
 
 	authorize_tool { |tool_class, principal| !tool_class.tags.include?(:admin) }
 	context { |principal, _request| { current_user: principal } }

data/lib/generators/omni_agent/mcp_server/mcp_server_generator.rb

@@ -101,6 +101,10 @@ module OmniAgent
 
             # Comma-separated list of accepted bearer tokens.
             authenticate :bearer, tokens: -> { ENV.fetch("#{token_env_var}", "").split(",") }
+            # Or OAuth 2.1 with tokens from your authorization server (add `gem "jwt"`):
+            # authenticate :oauth, resource: "https://app.example.com/mcp/...",
+            #                      authorization_servers: "https://auth.example.com",
+            #                      jwks_uri: "https://auth.example.com/.well-known/jwks.json"
 
             # Hide tools per principal:
             # authorize_tool { |tool_class, principal| true }

data/lib/omni_agent/mcp/authenticator.rb

@@ -3,7 +3,8 @@ require "active_support/security_utils"
 module OmniAgent
   module MCP
     class Authenticator
-      Result = Struct.new(:authenticated, :principal) do
+      # error and access_token are only set by `authenticate :oauth`.
+      Result = Struct.new(:authenticated, :principal, :error, :access_token) do
         def authenticated?
           authenticated == true
         end
@@ -21,7 +22,7 @@ module OmniAgent
         if authentication.nil?
           raise OmniAgent::MCPError,
                 "#{@server_class.name} does not declare authentication. " \
-                "Add `authenticate :bearer, tokens: ...`, `authenticate { |request| ... }`, " \
+                "Add `authenticate :bearer, tokens: ...`, `authenticate :oauth, ...`, `authenticate { |request| ... }`, " \
                 "or explicitly opt out with `authenticate :none`."
         end
 
@@ -30,6 +31,8 @@ module OmniAgent
           success(nil)
         when :bearer
           authenticate_bearer(request, authentication[:tokens])
+        when :oauth
+          authentication[:resource_server].authenticate(request)
         when :custom
           principal = authentication[:block].call(request)
           principal ? success(principal) : failure

data/lib/omni_agent/mcp/oauth/access_token.rb

@@ -0,0 +1,60 @@
+module OmniAgent
+  module MCP
+    module OAuth
+      # A validated access token and its claims (JWT payload or introspection
+      # response). It is the principal unless `authenticate :oauth` has a block.
+      class AccessToken
+        attr_reader :token, :claims
+
+        def initialize(token, claims)
+          @token = token
+          @claims = claims.transform_keys(&:to_s).freeze
+        end
+
+        def [](key)
+          claims[key.to_s]
+        end
+
+        def subject
+          claims["sub"]
+        end
+
+        def issuer
+          claims["iss"]
+        end
+
+        def client_id
+          claims["client_id"] || claims["azp"]
+        end
+
+        def audience
+          Array(claims["aud"]).map(&:to_s)
+        end
+
+        # RFC 9068 / RFC 7662 use a space-separated "scope"; some providers
+        # (Okta, Entra ID) use "scp", as a string or an array.
+        def scopes
+          raw = claims.key?("scope") ? claims["scope"] : claims["scp"]
+          raw.is_a?(Array) ? raw.map(&:to_s) : raw.to_s.split
+        end
+
+        def scope?(*names)
+          (names.flatten.map(&:to_s) - scopes).empty?
+        end
+
+        def expires_at
+          Time.at(claims["exp"]) if claims["exp"].is_a?(Numeric)
+        end
+
+        def to_s
+          subject.to_s
+        end
+
+        # Never print the raw token.
+        def inspect
+          "#<#{self.class.name} sub=#{subject.inspect} client_id=#{client_id.inspect} scopes=#{scopes.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth/http_client.rb

@@ -0,0 +1,52 @@
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module OmniAgent
+  module MCP
+    module OAuth
+      # Minimal JSON client for the authorization server (JWKS, introspection).
+      module HTTPClient
+        OPEN_TIMEOUT = 5
+        READ_TIMEOUT = 5
+
+        NETWORK_ERRORS = [
+          IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError, URI::InvalidURIError
+        ].freeze
+
+        module_function
+
+        def get_json(url)
+          uri = URI.parse(url.to_s)
+          request(uri, Net::HTTP::Get.new(uri))
+        end
+
+        def post_form_json(url, form, basic_auth: nil)
+          uri = URI.parse(url.to_s)
+          post = Net::HTTP::Post.new(uri)
+          post.set_form_data(form)
+          post.basic_auth(*basic_auth) if basic_auth
+          request(uri, post)
+        end
+
+        def request(uri, http_request)
+          http_request["accept"] = "application/json"
+
+          response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                     open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+            http.request(http_request)
+          end
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise VerificationError, "#{http_request.method} #{uri} returned HTTP #{response.code}"
+          end
+
+          JSON.parse(response.body.to_s)
+        rescue JSON::ParserError, *NETWORK_ERRORS => e
+          raise VerificationError, "#{http_request.method} #{uri} failed: #{e.class}: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth/introspection_verifier.rb

@@ -0,0 +1,43 @@
+require "uri"
+
+module OmniAgent
+  module MCP
+    module OAuth
+      # Asks the authorization server whether a token is active (RFC 7662).
+      # Works with opaque tokens. Returns the introspection response, or nil
+      # when the token is not active.
+      class IntrospectionVerifier
+        def initialize(url:, client_id: nil, client_secret: nil)
+          raise ArgumentError, "introspection: requires url:" if url.nil?
+
+          @url = url
+          @client_id = client_id
+          @client_secret = client_secret
+        end
+
+        def call(token, _request = nil)
+          response = HTTPClient.post_form_json(
+            OAuth.resolve(@url),
+            { "token" => token, "token_type_hint" => "access_token" },
+            basic_auth: credentials
+          )
+          response.is_a?(Hash) && response["active"] == true ? response : nil
+        end
+
+        def inspect
+          "#<#{self.class.name} url=#{@url.inspect}>"
+        end
+
+        private
+
+        # client_secret_basic: RFC 6749 section 2.3.1 form-encodes both values.
+        def credentials
+          client_id = OAuth.resolve(@client_id)
+          return if client_id.nil?
+
+          [ client_id, OAuth.resolve(@client_secret) ].map { |value| URI.encode_www_form_component(value.to_s) }
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth/jwt_verifier.rb

@@ -0,0 +1,122 @@
+module OmniAgent
+  module MCP
+    module OAuth
+      # Verifies JWT access tokens (RFC 9068) with the authorization server's
+      # JSON Web Key Set. Returns the payload, or nil when the token is invalid.
+      # Issuer, audience and scopes are checked afterwards by ResourceServer.
+      class JWTVerifier
+        # Asymmetric algorithms only: a JWKS publishes public keys.
+        DEFAULT_ALGORITHMS = %w[RS256 RS384 RS512 PS256 PS384 PS512 ES256 ES384 ES512].freeze
+        CACHE_TTL = 300
+        # A token signed with an unknown `kid` refetches the key set (key
+        # rotation), but at most this often, so forged tokens cannot make every
+        # request call the authorization server. Also the wait after a failed fetch.
+        MIN_REFRESH_INTERVAL = 30
+
+        def self.require_jwt!
+          require "jwt"
+        rescue LoadError
+          raise OmniAgent::MissingDependencyError,
+                "The 'jwt' gem is required for `authenticate :oauth, jwks_uri: ...`. " \
+                "Please add `gem 'jwt'` to your Gemfile."
+        end
+
+        def initialize(jwks_uri, algorithms: DEFAULT_ALGORITHMS, leeway: 0)
+          self.class.require_jwt!
+
+          @jwks_uri = jwks_uri
+          @algorithms = Array(algorithms).map(&:to_s)
+          @leeway = leeway
+          # Held only while fetching, so at most one fetch runs at a time.
+          # Reading the cached keys never takes it.
+          @fetch_mutex = Mutex.new
+          @jwks = nil
+          @fetched_at = nil
+          @failed_at = nil
+        end
+
+        def call(token, _request = nil)
+          payload, _header = ::JWT.decode(
+            token, nil, true,
+            algorithms: @algorithms,
+            jwks: method(:jwks),
+            required_claims: %w[exp iss],
+            leeway: @leeway
+          )
+          payload
+        rescue ::JWT::DecodeError
+          nil
+        end
+
+        private
+
+        # Key loader for JWT.decode. Called with `kid_not_found: true` when the
+        # token's `kid` is not in the cached set.
+        def jwks(options = {})
+          if @jwks.nil?
+            load_initial_jwks
+          elsif refresh_due?(options) && @fetch_mutex.try_lock
+            # Only the thread that got the lock refreshes; the others keep
+            # using the cached keys instead of waiting for it.
+            begin
+              fetch_jwks
+            ensure
+              @fetch_mutex.unlock
+            end
+          end
+
+          @jwks
+        end
+
+        # With no keys yet, concurrent requests wait for one shared fetch rather
+        # than each fetching in turn. After a failure they fail fast until
+        # MIN_REFRESH_INTERVAL has passed, so a down authorization server does
+        # not tie up every app thread on timeouts.
+        def load_initial_jwks
+          raise_unavailable if backing_off?
+
+          @fetch_mutex.synchronize do
+            next if @jwks
+            raise_unavailable if backing_off?
+
+            fetch_jwks
+          end
+
+          raise_unavailable if @jwks.nil?
+        end
+
+        def refresh_due?(options)
+          return false if backing_off?
+
+          age = monotonic_now - @fetched_at
+          age > CACHE_TTL || (options[:kid_not_found] && age > MIN_REFRESH_INTERVAL)
+        end
+
+        def fetch_jwks
+          keys = HTTPClient.get_json(OAuth.resolve(@jwks_uri))
+          # @fetched_at first: readers that see @jwks expect it to be set.
+          @fetched_at = monotonic_now
+          @jwks = keys
+          @failed_at = nil
+        rescue VerificationError => e
+          @failed_at = monotonic_now
+          fallback = @jwks ? "using cached keys" : "retrying in #{MIN_REFRESH_INTERVAL}s"
+          MCP.logger&.warn("[OmniAgent::MCP] Could not fetch JWKS, #{fallback}: #{e.message}")
+        end
+
+        def backing_off?
+          failed_at = @failed_at
+          !failed_at.nil? && monotonic_now - failed_at < MIN_REFRESH_INTERVAL
+        end
+
+        def raise_unavailable
+          raise VerificationError, "JWKS from #{OAuth.resolve(@jwks_uri)} is unavailable"
+        end
+
+        def monotonic_now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth/resource_server.rb

@@ -0,0 +1,166 @@
+require "uri"
+
+module OmniAgent
+  module MCP
+    module OAuth
+      # Built by `authenticate :oauth, ...`. Validates bearer access tokens
+      # (signature or introspection, issuer, audience, expiry and scopes) and
+      # describes the server in Protected Resource Metadata (RFC 9728) so MCP
+      # clients can find the authorization server.
+      class ResourceServer
+        METADATA_PATH = "/.well-known/oauth-protected-resource".freeze
+        # Seconds of clock skew tolerated when checking exp and nbf.
+        LEEWAY = 30
+
+        attr_reader :scopes
+
+        def initialize(resource:, authorization_servers:, scopes: [], scopes_supported: nil, audience: nil,
+                       jwks_uri: nil, algorithms: JWTVerifier::DEFAULT_ALGORITHMS, introspection: nil,
+                       verify_token: nil, &principal_block)
+          raise ArgumentError, "authenticate :oauth requires resource:" if resource.nil?
+          raise ArgumentError, "authenticate :oauth requires authorization_servers:" if Array(authorization_servers).empty?
+
+          validate_resource!(resource) unless resource.respond_to?(:call)
+
+          @resource = resource
+          @authorization_servers = authorization_servers
+          @scopes = Array(scopes).map(&:to_s).freeze
+          @scopes_supported = scopes_supported && Array(scopes_supported).map(&:to_s).freeze
+          @audience = audience
+          @principal_block = principal_block
+          @verifier = build_verifier(jwks_uri, algorithms, introspection, verify_token)
+        end
+
+        # Returns an Authenticator::Result. `error` is nil when no token was
+        # sent, :invalid_token or :insufficient_scope (RFC 6750 section 3.1).
+        def authenticate(request)
+          token = request.bearer_token
+          return failure(nil) if token.nil?
+
+          claims = verify(token, request)
+          return failure(:invalid_token) unless claims.is_a?(Hash)
+
+          access_token = AccessToken.new(token, claims)
+          return failure(:invalid_token) unless valid?(access_token)
+          return failure(:insufficient_scope) unless access_token.scope?(scopes)
+
+          principal = @principal_block ? @principal_block.call(access_token, request) : access_token
+          return failure(:invalid_token) unless principal
+
+          Authenticator::Result.new(true, principal, nil, access_token)
+        rescue VerificationError => e
+          MCP.logger&.error("[OmniAgent::MCP] OAuth token verification failed: #{e.message}")
+          failure(:invalid_token)
+        end
+
+        def metadata(resource_name: nil)
+          supported = @scopes_supported || scopes
+
+          {
+            resource: resource,
+            authorization_servers: authorization_servers,
+            scopes_supported: supported.empty? ? nil : supported,
+            bearer_methods_supported: [ "header" ],
+            resource_name: resource_name
+          }.compact
+        end
+
+        # Value of the WWW-Authenticate header for a 401 or 403 response.
+        def challenge(realm:, error: nil)
+          params = { realm: realm, resource_metadata: metadata_url }
+          params[:error] = error.to_s if error
+          params[:scope] = scopes.join(" ") unless scopes.empty?
+
+          "Bearer " + params.map { |key, value| %(#{key}="#{value}") }.join(", ")
+        end
+
+        # Served by RackApp under the MCP endpoint itself, so it works wherever
+        # the server is mounted.
+        def metadata_url
+          "#{resource.chomp('/')}#{METADATA_PATH}"
+        end
+
+        def resource
+          OAuth.resolve(@resource).to_s
+        end
+
+        def authorization_servers
+          Array(OAuth.resolve(@authorization_servers)).map(&:to_s)
+        end
+
+        private
+
+        def build_verifier(jwks_uri, algorithms, introspection, verify_token)
+          given = { jwks_uri: jwks_uri, introspection: introspection, verify_token: verify_token }.compact
+          unless given.size == 1
+            raise ArgumentError, "authenticate :oauth requires exactly one of jwks_uri:, introspection: or verify_token:"
+          end
+
+          if jwks_uri
+            JWTVerifier.new(jwks_uri, algorithms: algorithms, leeway: LEEWAY)
+          elsif introspection
+            IntrospectionVerifier.new(**introspection.transform_keys(&:to_sym))
+          else
+            raise ArgumentError, "verify_token: must respond to #call" unless verify_token.respond_to?(:call)
+
+            verify_token
+          end
+        end
+
+        def verify(token, request)
+          if @verifier.respond_to?(:arity) && @verifier.arity == 1
+            @verifier.call(token)
+          else
+            @verifier.call(token, request)
+          end
+        end
+
+        def valid?(access_token)
+          claims = access_token.claims
+
+          fresh?(claims) && trusted_issuer?(claims) && intended_audience?(access_token)
+        end
+
+        def fresh?(claims)
+          now = Time.now.to_i
+          return false if claims.key?("exp") && !(claims["exp"].is_a?(Numeric) && now < claims["exp"] + LEEWAY)
+          return false if claims.key?("nbf") && !(claims["nbf"].is_a?(Numeric) && now >= claims["nbf"] - LEEWAY)
+
+          true
+        end
+
+        # JWTs must carry `iss`; introspection responses and custom verifiers may omit it.
+        def trusted_issuer?(claims)
+          return true unless claims.key?("iss")
+
+          authorization_servers.map { |server| normalize(server) }.include?(normalize(claims["iss"]))
+        end
+
+        # RFC 8707: the token must have been issued for this server. Tokens
+        # meant for another resource are rejected, never passed through.
+        def intended_audience?(access_token)
+          expected = Array(OAuth.resolve(@audience) || resource).map { |value| normalize(value) }
+
+          access_token.audience.any? { |value| expected.include?(normalize(value)) }
+        end
+
+        def normalize(uri)
+          uri.to_s.chomp("/")
+        end
+
+        def validate_resource!(resource)
+          uri = URI.parse(resource.to_s)
+          return if uri.is_a?(URI::HTTP) && uri.host && uri.fragment.nil?
+
+          raise ArgumentError, "resource: must be the absolute http(s) URL of the MCP endpoint, without a fragment"
+        rescue URI::InvalidURIError
+          raise ArgumentError, "resource: #{resource.inspect} is not a valid URL"
+        end
+
+        def failure(error)
+          Authenticator::Result.new(false, nil, error, nil)
+        end
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/oauth.rb

@@ -0,0 +1,18 @@
+module OmniAgent
+  module MCP
+    # Resource server side of the MCP authorization spec (OAuth 2.1). Access
+    # tokens are issued by an external authorization server and validated here;
+    # see ResourceServer.
+    module OAuth
+      # The authorization server could not be reached or answered with something
+      # unusable. The request is rejected as unauthenticated.
+      class VerificationError < OmniAgent::MCPError; end
+
+      # Settings accept a value or a callable, so they can be read from ENV or
+      # credentials on every request.
+      def self.resolve(value)
+        value.respond_to?(:call) ? value.call : value
+      end
+    end
+  end
+end

data/lib/omni_agent/mcp/rack_app.rb

@@ -7,6 +7,11 @@ module OmniAgent
     class RackApp
       JSON_HEADERS = { "content-type" => "application/json" }.freeze
       PARSE_FAILED = Object.new.freeze
+      METADATA_CORS_HEADERS = {
+        "access-control-allow-origin" => "*",
+        "access-control-allow-methods" => "GET, OPTIONS",
+        "access-control-allow-headers" => "mcp-protocol-version"
+      }.freeze
 
       # Accepts the server class or its name. Passing a String defers the
       # constant lookup to request time, which keeps routes reload-safe.
@@ -23,11 +28,17 @@ module OmniAgent
       def call(env)
         server_class = MCP.resolve_server_class(@server)
         request = Request.new(env)
+        resource_server = server_class.configured_oauth_resource_server
+
+        # Public, so clients can discover the authorization server before they have a token.
+        if resource_server && request.path_info == OAuth::ResourceServer::METADATA_PATH
+          return protected_resource_metadata(server_class, resource_server, request)
+        end
 
         return forbidden unless origin_allowed?(request, server_class)
 
         auth = Authenticator.new(server_class).authenticate(request)
-        return unauthorized(server_class) unless auth.authenticated?
+        return unauthorized(server_class, resource_server, auth) unless auth.authenticated?
 
         return method_not_allowed unless request.post?
 
@@ -41,7 +52,7 @@ module OmniAgent
         message = parse_json(body)
         return json_response(400, parse_error_response) if message.equal?(PARSE_FAILED)
 
-        server = server_class.new(principal: auth.principal, request: request, transport: :http)
+        server = server_class.new(principal: auth.principal, access_token: auth.access_token, request: request, transport: :http)
         response = Handler.new(server).call(message)
         return [ 202, {}, [] ] if response.nil?
 
@@ -94,13 +105,26 @@ module OmniAgent
         http_error(403, "Origin not allowed")
       end
 
-      def method_not_allowed
-        [ 405, JSON_HEADERS.merge("allow" => "POST"), [ JSON.generate({ error: "Method not allowed" }) ] ]
+      def method_not_allowed(allow = "POST")
+        [ 405, JSON_HEADERS.merge("allow" => allow), [ JSON.generate({ error: "Method not allowed" }) ] ]
+      end
+
+      def unauthorized(server_class, resource_server, auth)
+        realm = server_class.server_name
+        challenge = resource_server ? resource_server.challenge(realm: realm, error: auth.error) : %(Bearer realm="#{realm}")
+        status, message = auth.error == :insufficient_scope ? [ 403, "Insufficient scope" ] : [ 401, "Unauthorized" ]
+
+        [ status, JSON_HEADERS.merge("www-authenticate" => challenge), [ JSON.generate({ error: message }) ] ]
       end
 
-      def unauthorized(server_class)
-        headers = JSON_HEADERS.merge("www-authenticate" => %(Bearer realm="#{server_class.server_name}"))
-        [ 401, headers, [ JSON.generate({ error: "Unauthorized" }) ] ]
+      # RFC 9728 Protected Resource Metadata. Browser-based clients fetch it
+      # cross-origin, and it holds nothing secret, so any origin may read it.
+      def protected_resource_metadata(server_class, resource_server, request)
+        return [ 204, METADATA_CORS_HEADERS.dup, [] ] if request.options?
+        return method_not_allowed("GET") unless request.get? || request.head?
+
+        metadata = resource_server.metadata(resource_name: server_class.server_name)
+        [ 200, JSON_HEADERS.merge(METADATA_CORS_HEADERS), [ JSON.generate(metadata) ] ]
       end
     end
   end

data/lib/omni_agent/mcp/server.rb

@@ -50,8 +50,17 @@ module OmniAgent
           add_tool_declaration(type: :tool, tool_class: tool_class, name: as.to_s)
         end
 
-        def authenticate(strategy = nil, tokens: nil, &block)
-          @authentication = if block
+        def authenticate(strategy = nil, tokens: nil, **oauth_options, &block)
+          if strategy != :oauth && oauth_options.any?
+            raise ArgumentError, "unknown keywords for authenticate: #{oauth_options.keys.map(&:inspect).join(', ')}"
+          end
+
+          @authentication = if strategy == :oauth
+            raise ArgumentError, "authenticate :oauth does not take tokens:" unless tokens.nil?
+
+            # The block, if any, maps the validated access token to the principal.
+            { strategy: :oauth, resource_server: OAuth::ResourceServer.new(**oauth_options, &block) }
+          elsif block
             { strategy: :custom, block: block }
           elsif strategy == :none
             { strategy: :none }
@@ -60,7 +69,7 @@ module OmniAgent
 
             { strategy: :bearer, tokens: tokens }
           else
-            raise ArgumentError, "authenticate expects :bearer (with tokens:), :none, or a block"
+            raise ArgumentError, "authenticate expects :bearer (with tokens:), :oauth, :none, or a block"
           end
         end
 
@@ -93,6 +102,11 @@ module OmniAgent
         def configured_stdio_principal_block; setting(:@stdio_principal_block); end
         def configured_allowed_origins; list_setting(:@allowed_origins); end
 
+        def configured_oauth_resource_server
+          authentication = configured_authentication
+          authentication[:resource_server] if authentication && authentication[:strategy] == :oauth
+        end
+
         # Ordered { "ToolName" => tool_class }: for each server in the
         # inheritance chain, its <Server>::Tools namespace first, then its
         # declared tools. Resolved on every call so lazily referenced tools
@@ -203,12 +217,14 @@ module OmniAgent
         end
       end
 
-      attr_reader :principal, :request, :transport
+      # access_token is the OAuth::AccessToken for `authenticate :oauth`, nil otherwise.
+      attr_reader :principal, :request, :transport, :access_token
 
-      def initialize(principal: nil, request: nil, transport: :http)
+      def initialize(principal: nil, request: nil, transport: :http, access_token: nil)
         @principal = principal
         @request = request
         @transport = transport
+        @access_token = access_token
       end
 
       def visible_tools
@@ -227,6 +243,7 @@ module OmniAgent
 
       def tool_context
         base = { mcp_principal: principal, mcp_request: request }
+        base[:mcp_access_token] = access_token if access_token
         context_block = self.class.configured_context_block
         return base unless context_block
 

data/lib/omni_agent/version.rb

@@ -1,3 +1,3 @@
 module OmniAgent
-  VERSION = "0.1.10"
+  VERSION = "0.1.11"
 end

data/lib/omni_agent.rb

@@ -3,7 +3,10 @@ require "omni_agent/engine" if defined?(Rails)
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
-loader.inflector.inflect("openai" => "OpenAI", "cli" => "CLI", "mcp" => "MCP")
+loader.inflector.inflect(
+  "openai" => "OpenAI", "cli" => "CLI", "mcp" => "MCP",
+  "oauth" => "OAuth", "jwt_verifier" => "JWTVerifier", "http_client" => "HTTPClient"
+)
 loader.ignore(File.expand_path("generators", __dir__))
 loader.setup
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: omni_agent
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.1.11
 platform: ruby
 authors:
 - ACR1209
@@ -85,6 +85,12 @@ files:
 - lib/omni_agent/mcp.rb
 - lib/omni_agent/mcp/authenticator.rb
 - lib/omni_agent/mcp/handler.rb
+- lib/omni_agent/mcp/oauth.rb
+- lib/omni_agent/mcp/oauth/access_token.rb
+- lib/omni_agent/mcp/oauth/http_client.rb
+- lib/omni_agent/mcp/oauth/introspection_verifier.rb
+- lib/omni_agent/mcp/oauth/jwt_verifier.rb
+- lib/omni_agent/mcp/oauth/resource_server.rb
 - lib/omni_agent/mcp/rack_app.rb
 - lib/omni_agent/mcp/request.rb
 - lib/omni_agent/mcp/routing.rb