mcp_authorization 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b1dabd038e65fbf04f01e9ae27d109e8734ae78b4db4baeaa6d20200291a3899
-  data.tar.gz: 0250e2902b73117cfe4447f6036783e4a49613ee4626a407560a82bd19bf25ef
+  metadata.gz: '058c192ec678d3ceb11d6ae5fed31c1025156a83d40cf12f7458054f50935682'
+  data.tar.gz: 00aee0863c22ead686543f40e8658a3a019711db84c8554c28bcac287bc51253
 SHA512:
-  metadata.gz: fbdfb8c28047b39373227ece236670dfc6df6ee34a32ca36f77d6b49f3e31ba7859d82a4c998ff505534ca3e55611f506d7b20a976cd0095a54ce03bc2377a66
-  data.tar.gz: 6ba9ec325debe3564cca6f8b5fdbee732aab893e1dc744d261fbac53db22772b619b764c1a4d9bb9baff59961d5352b334a9c56e171fda8c44da8e4a5d052a79
+  metadata.gz: aeeb0fa5ab4074654132516b58e0b649aa3eaf3012b3703e98cb9d519c440f39f5bc080bde6947f802a8169073dc03dc1ee2cdf6ffc91b77f520182c7741a143
+  data.tar.gz: 89d8566f176bb0c6cb53cc84ca933adb01e858df69caa320d9d480759b7479efd814f6392c25fe61ecfef891c6246b7fbc0c6a349ba9c6892a01f1370c9f6255

data/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this gem are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and this project
 adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.7.1]
+
+Follow-ups from the 0.7.0 review (onboardiq/mcp_authorization#31).
+
+### Fixed
+- **A facade `tools/call` no longer recompiles every tool in the group.** `FacadeBuilder.facade_for` (the `tools/call` routing path) built the facade with the `:vendor_extension` `_meta` payload, which compiles the input schema of *every* tool in the group — but dispatch only needs the advertised name set, and nothing on the call path reads `_meta`. Over a 30-tool group that was ~30 extra per-tool compiles on every call, partially regressing the 0.6.0 "compile only the invoked tool" optimization on exactly the large domains facades target. `build_facade` now takes `for_dispatch:` (true from `facade_for`) and skips the `_meta` map; `tools/list` (`facades_for`) is unchanged and still carries it.
+- **`facet_domain(group_by:)` is now validated.** Any value but `:category` (the only supported grouping key) raises `ArgumentError`, consistent with `schema_strategy:`/`uncategorized:`. Previously a typo (`group_by: :tag`) was silently accepted and behaved as `:category`.
+- **Corrected a stale RBS annotation on `FacadeBuilder.facade_input_schema`** (declared 3 params for a 2-param method; the intervening prose comment also caused Sentinel to omit it from the generated sigs). Annotation fixed and moved adjacent to the def so it regenerates.
+
+### Added
+- **Cache-vocabulary test for the facade path** (design doc §8): asserts a cold compile of a faceted domain learns the consulted decisions, so two callers with different permission sets produce different `tools_list_key`s (guarding against a shared-listing RBAC leak).
+
 ## [0.7.0] - 2026-07-21
 
 Declarative tool grouping: a domain can present its tools as a small set of

data/lib/mcp_authorization/configuration.rb

@@ -132,6 +132,11 @@ module McpAuthorization
     # Behaviors for a tool in a faceted domain that declares no +category+.
     UNCATEGORIZED_MODES = %i[fallback error].freeze #: Array[Symbol]
 
+    # Grouping keys +facet_domain+ knows how to group by. Only +:category+
+    # exists today (the +category+ DSL is the only grouping key); accepted
+    # explicitly so a future key is an additive, validated change.
+    GROUP_BY_KEYS = %i[category].freeze #: Array[Symbol]
+
     # Default suffix appended to a category to form its facade tool name
     # (e.g. category +:orders+ → +orders_tools+). Overridable per domain via
     # +facet_domain(..., facade_suffix:)+.
@@ -186,6 +191,10 @@ module McpAuthorization
     # (+[a-z0-9_]+) so the derived name stays a valid MCP tool name.
     #: (Symbol | String, group_by: Symbol, ?schema_strategy: Symbol, ?uncategorized: Symbol, ?facade_suffix: String | Symbol) -> void
     def facet_domain(domain, group_by:, schema_strategy: :vendor_extension, uncategorized: :fallback, facade_suffix: DEFAULT_FACADE_SUFFIX)
+      unless GROUP_BY_KEYS.include?(group_by.to_sym)
+        raise ArgumentError, "unknown group_by #{group_by.inspect}; " \
+          "expected one of #{GROUP_BY_KEYS.inspect}"
+      end
       unless SCHEMA_STRATEGIES.include?(schema_strategy)
         raise ArgumentError, "unknown schema_strategy #{schema_strategy.inspect}; " \
           "expected one of #{SCHEMA_STRATEGIES.inspect}"

data/lib/mcp_authorization/facade_builder.rb

@@ -45,13 +45,22 @@ module McpAuthorization
       # A single facade by its tool name (e.g. "orders_tools"), or nil when
       # the name matches no non-empty group for this caller. Used by
       # +tools/call+ routing so one call doesn't build every facade.
+      #
+      # Built with +for_dispatch: true+ — a +tools/call+ only needs the
+      # advertised name set to route through, never the +_meta+ per-tool
+      # schemas (those are a +tools/list+ concern). Skipping them avoids
+      # recompiling every tool's input schema in the group on each call,
+      # preserving the "compile only the invoked tool" cost that facades'
+      # large target domains most depend on.
       #: (domain: String, name: String, server_context: untyped) -> singleton(MCP::Tool)?
       def facade_for(domain:, name:, server_context:)
         config = McpAuthorization.config.facet_config(domain)
         return nil unless config
 
         group_tools(domain, server_context, config).each do |category, tools|
-          return build_facade(domain, category, tools, server_context, config) if facade_name(category, config) == name
+          if facade_name(category, config) == name
+            return build_facade(domain, category, tools, server_context, config, for_dispatch: true)
+          end
         end
         nil
       end
@@ -110,8 +119,12 @@ module McpAuthorization
       # Build the synthetic MCP::Tool subclass for one group, with this
       # caller's description, schema, and dispatch baked in — the same
       # materialization shape Tool.materialize_for uses for real tools.
-      #: (String, Symbol, Array[singleton(McpAuthorization::Tool)], untyped, Hash[Symbol, untyped]) -> singleton(MCP::Tool)
-      def build_facade(domain, category, tools, server_context, config)
+      #
+      # +for_dispatch:+ true skips the +_meta+ per-tool schema map, which only
+      # a +tools/list+ consumer reads — a +tools/call+ routes on the advertised
+      # name set alone. See +facade_for+.
+      #: (String, Symbol, Array[singleton(McpAuthorization::Tool)], untyped, Hash[Symbol, untyped], ?for_dispatch: bool) -> singleton(MCP::Tool)
+      def build_facade(domain, category, tools, server_context, config, for_dispatch: false)
         name = facade_name(category, config)
         desc = facade_description(category, tools, server_context)
         strategy = config[:schema_strategy]
@@ -124,8 +137,9 @@ module McpAuthorization
         # keywords, and `_meta` is never forwarded to the model as the tool's
         # input_schema. So the listing stays valid for strict Zod clients and
         # strict-mode LLM tool-calling while still carrying the schemas in-band
-        # for capable clients.
-        meta_payload = strategy == :vendor_extension ? { "tool-input-schemas" => child_schema_map(tools, server_context) } : nil
+        # for capable clients. Skipped on the dispatch path (nothing reads it
+        # there) so a facade call doesn't recompile every tool in the group.
+        meta_payload = !for_dispatch && strategy == :vendor_extension ? { "tool-input-schemas" => child_schema_map(tools, server_context) } : nil
 
         advertised = tools.map(&:tool_name).to_set
         builder = self
@@ -166,10 +180,10 @@ module McpAuthorization
         DESC
       end
 
-      # The facade inputSchema for the configured strategy. All three keep
+      # The facade inputSchema for the configured strategy. Both strategies keep
       # per-tool schemas out of the description and advertise only tools the
       # caller may invoke; they differ in where argument schemas live.
-      #: (Array[singleton(McpAuthorization::Tool)], untyped, Symbol) -> Hash[Symbol, untyped]
+      #
       # The facade inputSchema is always a flat object — a `tool_name` enum plus
       # a permissive `arguments` object, with NO top-level combinator. LLM tool
       # `input_schema` must have an object root: Anthropic and OpenAI reject
@@ -180,6 +194,7 @@ module McpAuthorization
       # on the facade's `_meta` (:vendor_extension, see build_facade) for a
       # client to expand, or are omitted entirely (:lazy) and enforced at
       # dispatch by the target tool's own filter_input.
+      #: (Array[singleton(McpAuthorization::Tool)], Symbol) -> Hash[Symbol, untyped]
       def facade_input_schema(tools, strategy)
         arguments_description =
           if strategy == :vendor_extension

data/lib/mcp_authorization/version.rb

@@ -1,3 +1,3 @@
 module McpAuthorization
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mcp_authorization
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - AndyGauge
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-22 00:00:00.000000000 Z
+date: 2026-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails