mcp_authorization 0.9.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b01924de48adcd82456518091bcfb6309908158c118fe0865e600417a70be766
-  data.tar.gz: 59ec07c72ae70fd00a77ff4e935b0c9feb03b5344e080b3d83aecfecf799390c
+  metadata.gz: 67586221cf3dfeaaffd4bb9b0a7dbc5b1b8f8adf515968b59bdf3c143ee41746
+  data.tar.gz: 8f53209e92d19cfdf5b2edb5c5c09189786f302dac31f5269b659fa196a24ac0
 SHA512:
-  metadata.gz: b603364bfb0c0aa3174e714f321b99c11394c938ccffd930aed01c950af91e60ab224a91565feafa3d1ee600a3327ec2c4c6d5d3420f69baf6f2e8b0ace25f02
-  data.tar.gz: a090369d9fe2da4276327b72ac3cf59f9e1626148c980093b42d6d3f85f0486bf496d3a9b6b5a906b1cec5d02e1d53b6b5e920c26c3d604c504655b522305cb5
+  metadata.gz: c1cf54717b5866778b8029686086b8a20e9ee348937cd539729e17b24a225fcc2ee8b04c24a392822447c3ffe93c9e7c42d7037790b0114de9388faaa2545cc3
+  data.tar.gz: cdbaea06cc7422e464ae0858c5664b9bc10021aae2a41705c9bd8c0dc46654295f07aa82bf6a13fd380b72b31ce849984f20ad1d0d1de1ead4886355d6ce2b9a

data/CHANGELOG.md

@@ -4,6 +4,45 @@ 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.11.0]
+
+A required param the caller left out is rejected before the handler runs, on
+a facade call as on a direct one. Behavior change, so a minor release.
+
+### Fixed
+- **A facade call no longer runs the target tool without its required params.** The MCP SDK checks `required` against the tool it was asked to call. For a facade that is the facade's own schema (`tool_name`, `arguments`), so the target's required params were never checked: `get_stage` without `workflow_id` reached the handler, which looked up `nil` and answered "Workflow not found". A model reading that concludes the workflow is missing or inaccessible, not that it left a param out. `RbsSchemaCompiler.filter_input` now raises `McpAuthorization::MissingRequiredInputKeysError` for any key in the caller's compiled `required` list that the params lack. A materialized tool returns it in-band, `<tool_name>: Missing required parameter: workflow_id. Nothing was executed. Accepted parameters: ...`, the same way as `UnknownInputKeysError`, so a facade caller sees the inner tool's name.
+- **A required param sent as `null` counts as missing.** The handler receives `nil` either way, so `get_stage(workflow_id: nil)` answered "Workflow not found" like an omitted key. A field that admits `null` through `@nullable()` is exempt. On a direct call the SDK's schema validation already refused that `null`.
+- **The unknown-key check runs first.** A call that sends `stage_id` instead of `to_stage_id` is missing a required key and carries an unknown one. The unknown-key message lists the accepted params, which tells the caller what it meant, so that call still gets it.
+
+### Unchanged
+- **Direct calls.** The SDK already rejected a missing required param before the tool's `call`; that response is unchanged.
+- **Gated fields.** `required` comes from the caller's compiled schema, so a field required behind a predicate the caller fails is not demanded from that caller.
+- **`config.reject_unknown_input_keys = false`** still drops unknown keys; it does not turn off this check, which the SDK already applied to every direct call.
+
+## [0.10.0]
+
+Nil-able RBS types compile to schemas that accept `null` in tool output.
+Input keeps 0.9's semantics unless a field opts in with the new
+`@nullable()` tag. This is a minor release because the tag is new and
+output schemas change shape for nil-able fields.
+
+### Fixed
+- **`T?` in output compiles to a nullable schema.** The compiler dropped the `?`, so `note: String?` became `{type: "string"}`. A handler that returned `note: nil`, as its contract allowed, then failed output validation. A scalar now compiles to a type array, `{type: ["string", "null"]}`, which keeps keywords such as `minLength` and `format` on the same schema. JSON Schema applies them to strings only, so `null` still passes. Every other schema is wrapped as `{anyOf: [<schema>, {type: "null"}]}`, including objects, arrays, `$ref`s, records, `Hash[...]`, and `const`/`enum` schemas.
+- **`T | nil` compiles the same as `T?`.** `nil` used to compile to the empty schema, so `String | nil` became `oneOf: [{type: "string"}, {}]`. A string matched both members, and `oneOf` rejected it. Nil members (`nil`, `NilClass`) are now stripped from the union and the rest is widened. On input it narrows to `T` (see below), so a valid `T` is accepted there too, and a `#:` call param typed `T | nil` is left out of `required`, as `T?` is. In 0.9 such a param was required and accepted only `null`; it now accepts a `T` or an omitted key, and `null` only with `@nullable()`.
+
+### Added
+- **`@nullable()` lets an input field accept `null`.** On input, `T?` and `T | nil` compile to `T`, as `T?` did in 0.9: the key may be omitted, and `null` is rejected. For an optional param, an explicit `null` and an omitted key are different requests. A handler that reads `params.fetch(:key, default)` or writes the value to a NOT NULL column handles only the omission. Tag a field `@nullable()` when `null` is a request the handler serves, such as clearing a stored value. The tag works on `#:` call params, `# @rbs type` records, and fields inside shared `.rbs` types, so one shared type can be nullable in one tool's output and strict in another tool's input.
+- **`@nullable()` on a type that is not nil-able raises `ArgumentError` at compile time.** `@nullable()` on `String` or `untyped` is a mistake: either the type is missing its `?`, or the tag is unneeded. Silently ignoring it would hide which one. The tag has no effect on output, which is already nullable.
+
+### Unchanged
+- **Input schemas.** Without the tag, an input field typed `T?` compiles as it did in 0.9. `?key: T` only removes `key` from `required`. A `#:` call param typed `T?` is still left out of `required`. A record field `key: T?` stays required.
+- **Projection.** A nil-able wrapper projects against its non-null branch. `filter_output`, and `filter_input` for a tagged field, still drop undeclared and gated keys inside a nil-able object or a nil-able union of records (`(A | B)?`, `A | B | nil`), and a `null` passes through.
+- **`@closed()` on a nil-able object closes the object.** `additionalProperties: false` goes on a copy of the object branch, not beside the `anyOf`, where it would reject every key.
+
+### Migration notes
+- Code that reads a compiled output schema's `type` directly sees an array for a nil-able scalar. For a nil-able object, array or `$ref`, it sees no `type` at the top of an `anyOf` wrapper. Inside the gem, `apply_tags` (`@min`/`@max`) and the facade's JSON-string coercion of object and array arguments look through both forms.
+- A host that wants an input field to accept `null` adds `@nullable()` to that field. Check the handler first: `null` should reach a code path that handles it, not a `fetch` default or a NOT NULL column.
+
 ## [0.9.0]
 
 Top-level params outside the caller's input schema are rejected instead of

data/README.md

@@ -692,6 +692,7 @@ end
 | Tag | JSON Schema |
 |---|---|
 | `@closed()` / `@strict()` | `additionalProperties: false` |
+| `@nullable()` | Input only: a nil-able (`T?`) field also accepts `null`. Raises `ArgumentError` on a type that is not nil-able. |
 | `@media_type(type)` | `contentMediaType` (e.g. `application/json`) |
 | `@encoding(enc)` | `contentEncoding` (e.g. `base64`) |
 
@@ -724,6 +725,10 @@ def call(applicant_id:, workflow_id:, stage_id: nil, reason: nil)
 
 Prefix a param with `?` to mark it optional. Suffix the type with `?` for nilable types. Both together (`?name: Type?`) means the field is optional and can be nil.
 
+The two markers compile separately. `?name: String` leaves `name` out of `required`, but a value that is present must be a string. In a `# @rbs type` record, `name: String?` keeps `name` required; a `#:` call param typed `String?` is optional. `String | nil` compiles the same as `String?` in both places.
+
+Nullability depends on direction. In a tool's output, `String?` accepts `null`: a scalar compiles to `{"type": ["string", "null"]}`, and anything else to `{"anyOf": [<schema>, {"type": "null"}]}`. In a tool's input, `String?` compiles to `{"type": "string"}` and rejects `null`, unless the field is tagged `@nullable()`. Tag a field when `null` is a request its handler serves, such as `?hire_by: String? @nullable() @desc(Pass null to remove the deadline)`. An explicit `null` and an omitted key are different requests, and `@nullable()` on a type without `?` raises `ArgumentError`.
+
 ### `@depends_on` for conditional required fields
 
 Use `@depends_on(:parent_field)` to express that a field is only required when another field is present. This emits JSON Schema `dependentRequired`:

data/lib/mcp_authorization/facade_builder.rb

@@ -331,7 +331,7 @@ module McpAuthorization
         parsed.each_with_object({}) do |(key, value), out|
           sym = key.to_sym
           expected = properties[sym] || properties[key.to_s] || {}
-          expected_type = expected[:type] || expected["type"]
+          expected_type = RbsSchemaCompiler.send(:primary_type, expected)
           if value.is_a?(String) && %w[object array].include?(expected_type.to_s)
             value = parse_json_blob(value, sym)
           end

data/lib/mcp_authorization/rbs_schema_compiler.rb

@@ -67,6 +67,22 @@ module McpAuthorization
     end
   end
 
+  # Raised by +filter_input+ for a required param the caller left out; a facade call never reaches the SDK's check.
+  class MissingRequiredInputKeysError < ArgumentError
+    attr_reader :missing_keys, :accepted_keys
+
+    #: (Array[String], Array[String]) -> void
+    def initialize(missing_keys, accepted_keys)
+      @missing_keys = missing_keys
+      @accepted_keys = accepted_keys
+      super(
+        "Missing required parameter#{"s" if missing_keys.size > 1}: #{missing_keys.join(", ")}. " \
+        "Nothing was executed. Accepted parameters: #{accepted_keys.join(", ")}. " \
+        "Re-send the call with #{missing_keys.size > 1 ? "them" : "it"}."
+      )
+    end
+  end
+
   # Compiles RBS-style type annotations in Ruby source files into JSON Schema,
   # with per-request filtering based on +@requires+ permission tags.
   #
@@ -107,6 +123,18 @@ module McpAuthorization
   # - +@desc(text)+, +@title(text)+ — JSON Schema annotation keywords
   #
   class RbsSchemaCompiler
+    # Scalar JSON types +nullable+ widens with a type array rather than an
+    # +anyOf+ wrapper.
+    NULLABLE_SCALAR_TYPES = %w[string integer number boolean].freeze
+
+    # The branch +nullable+ adds to an +anyOf+.
+    NULL_SCHEMA = { type: "null" }.freeze
+
+    # Internal key +apply_tags+ sets on a field tagged +@nullable()+. It
+    # survives only until +finalize_for+, which strips it from every
+    # compiled schema; it never reaches a caller.
+    NULLABLE_INPUT_KEY = :"x-mcp-nullable-input"
+
     class << self
       # ---------------------------------------------------------------
       # Public API
@@ -132,7 +160,7 @@ module McpAuthorization
           )
         end
 
-        schema = with_ref_injection(schema, cached[:type_map])
+        schema = finalize_for(:input, with_ref_injection(schema, cached[:type_map]))
         McpAuthorization.config.strict_schema ? strict_sanitize(schema) : schema
       end
 
@@ -145,7 +173,7 @@ module McpAuthorization
 
         if cached[:raw_output]&.dig(:kind) == :union
           schema = compile_tagged_union(cached[:raw_output][:body], cached[:type_map], server_context, rctx: build_rctx(server_context, cached))
-          schema = with_ref_injection(schema, cached[:type_map])
+          schema = finalize_for(:output, with_ref_injection(schema, cached[:type_map]))
           return McpAuthorization.config.strict_schema ? strict_sanitize(schema) : schema
         end
       end
@@ -173,9 +201,25 @@ module McpAuthorization
         schema = compile_input_for_filter(handler_class, server_context: server_context)
         return params unless schema
         reject_unknown_input_keys!(params, schema) if McpAuthorization.config.reject_unknown_input_keys
+        reject_missing_required_keys!(params, schema)
         project_against_schema(params, schema, defs_from(schema))
       end
 
+      # Runs after the unknown-key check, which names the right key; a null counts as missing unless the field is +@nullable()+.
+      #: (Hash[untyped, untyped], Hash[Symbol, untyped]) -> void
+      def reject_missing_required_keys!(params, schema)
+        properties = schema[:properties] || {}
+        sent = params.to_h { |key, value| [key.to_s, value] }
+        missing = (schema[:required] || []).map(&:to_s).select do |key|
+          next true unless sent.key?(key)
+
+          sent[key].nil? && !null_admitting?(properties[key.to_sym] || properties[key] || {})
+        end
+        return if missing.empty?
+
+        raise MissingRequiredInputKeysError.new(missing, properties.keys.map(&:to_s).sort)
+      end
+
       # Raise when +params+ carries a top-level key outside +schema+'s
       # properties. Both the unknown and the accepted names come from the
       # caller's own schema, so the message reveals nothing +tools/list+ did
@@ -305,7 +349,7 @@ module McpAuthorization
           )
         end
 
-        with_ref_injection(schema, cached[:type_map])
+        finalize_for(:input, with_ref_injection(schema, cached[:type_map]))
       end
 
       # Like +compile_output+ but skips +strict_sanitize+. Returns nil when
@@ -316,7 +360,7 @@ module McpAuthorization
         return nil unless cached[:raw_output]&.dig(:kind) == :union
 
         schema = compile_tagged_union(cached[:raw_output][:body], cached[:type_map], server_context, rctx: build_rctx(server_context, cached))
-        with_ref_injection(schema, cached[:type_map])
+        finalize_for(:output, with_ref_injection(schema, cached[:type_map]))
       end
 
       # Extract the +$defs+ table from a compiled schema for +$ref+ resolution.
@@ -357,6 +401,12 @@ module McpAuthorization
         schema = resolve_ref(schema, defs)
         return value unless schema.is_a?(Hash)
 
+        # A nil-able wrapper projects against its non-null branch, which may
+        # itself be a union with no type of its own that best_variant_for
+        # could score.
+        inner = non_null_variant(schema)
+        return (value.nil? ? value : project_against_schema(value, inner, defs)) if inner
+
         variants = schema[:oneOf] || schema[:anyOf]
         if variants.is_a?(Array) && !variants.empty?
           # Flatten so intersection (allOf) members project like the object
@@ -587,6 +637,8 @@ module McpAuthorization
             tags[:unique] = true
           when "closed", "strict"
             tags[:closed] = true
+          when "nullable"
+            tags[:nullable] = true
           when "media_type"
             tags[:media_type] = tag_value
           when "encoding"
@@ -869,15 +921,16 @@ module McpAuthorization
       #: (Hash[Symbol, untyped], Hash[Symbol, untyped], ?server_context: untyped?) -> Hash[Symbol, untyped]
       def apply_tags(schema, tags, server_context: nil)
         # Type-aware min/max
+        constrained_type = primary_type(schema)
         if tags[:min]
-          case schema[:type]
+          case constrained_type
           when "string" then schema[:minLength] = tags[:min]
           when "integer", "number" then schema[:minimum] = tags[:min]
           when "array" then schema[:minItems] = tags[:min]
           end
         end
         if tags[:max]
-          case schema[:type]
+          case constrained_type
           when "string" then schema[:maxLength] = tags[:max]
           when "integer", "number" then schema[:maximum] = tags[:max]
           when "array" then schema[:maxItems] = tags[:max]
@@ -910,8 +963,26 @@ module McpAuthorization
         schema[:readOnly] = true if tags[:read_only]
         schema[:writeOnly] = true if tags[:write_only]
 
+        if tags[:nullable]
+          unless null_admitting?(schema)
+            raise ArgumentError,
+              "@nullable() needs a nil-able type (T? or T | nil); got #{schema.inspect}"
+          end
+          schema[NULLABLE_INPUT_KEY] = true
+        end
+
         # Niche constraints
-        schema[:additionalProperties] = false if tags[:closed]
+        if tags[:closed]
+          # On a nil-able wrapper the keyword belongs on the object branch:
+          # beside anyOf there are no properties, so every key would be
+          # additional. Copy the branch, which may be a shared type_map entry.
+          inner = non_null_variant(schema)
+          if inner
+            schema[:anyOf] = [inner.merge(additionalProperties: false), NULL_SCHEMA.dup]
+          else
+            schema[:additionalProperties] = false
+          end
+        end
         schema[:contentMediaType] = tags[:media_type] if tags[:media_type]
         schema[:contentEncoding] = tags[:encoding] if tags[:encoding]
 
@@ -1682,7 +1753,7 @@ module McpAuthorization
             params << {
               name: name,
               type: type,
-              required: !optional && !type.end_with?("?"),
+              required: !optional && !nilable_type?(type),
               tags: tags
             }
           end
@@ -1804,9 +1875,9 @@ module McpAuthorization
       # Handles:
       # - Primitives: +String+ → +{type: "string"}+, +Integer+ → +{type: "integer"}+, etc.
       # - Arrays: +Array[String]+ → +{type: "array", items: {type: "string"}}+
-      # - Optionals: +String?+ → +{type: "string"}+ (nullability is handled at the field level)
+      # - Optionals: +String?+ → +{type: ["string", "null"]}+; see +nullable+
       # - Inline records: +{name: String}+ → nested object schema
-      # - Unions: +"a" | "b"+ → string enum; +A | B+ → +oneOf+
+      # - Unions: +"a" | "b"+ → string enum; +A | B+ → +oneOf+; +T | nil+ → same as +T?+
       # - Named types: looked up in +type_map+, falling back to +{type: "string"}+
       #
       # @param rbs_type [String] RBS type expression.
@@ -1860,9 +1931,9 @@ module McpAuthorization
         when RBS::Types::Literal
           visit_rbs_literal(node)
         when RBS::Types::Optional
-          # Optional wraps a type; nullability is handled at field
-          # level (required-set), not in the JSON Schema type itself.
-          visit_rbs_type(node.type, type_map, rctx)
+          # T? admits nil. Whether the key may be omitted is a separate,
+          # field-level question (?key: and the required set).
+          nullable(visit_rbs_type(node.type, type_map, rctx))
         when RBS::Types::Union
           visit_rbs_union(node, type_map, rctx)
         when RBS::Types::Intersection
@@ -1945,6 +2016,20 @@ module McpAuthorization
       def visit_rbs_union(node, type_map, rctx = nil)
         types = node.types
 
+        # T | nil means T? — strip the nil members and widen the rest.
+        # Compiling nil as its own member would emit oneOf [T, {}]; the
+        # empty schema matches every value, so a valid T matched two
+        # members and oneOf rejected it.
+        nils, others = types.partition { |t| nil_type?(t) }
+        if nils.any? && others.any?
+          inner = if others.size == 1
+            visit_rbs_type(others.first, type_map, rctx)
+          else
+            visit_rbs_union(RBS::Types::Union.new(types: others, location: nil), type_map, rctx)
+          end
+          return nullable(inner)
+        end
+
         # All string literals → enum.
         if types.all? { |t| t.is_a?(RBS::Types::Literal) && t.literal.is_a?(String) }
           return { type: "string", enum: types.map { |t| t.literal.to_s } }
@@ -1961,6 +2046,141 @@ module McpAuthorization
         { oneOf: types.map { |t| visit_rbs_type(t, type_map, rctx) } }
       end
 
+      # True when the RBS type +type+ admits nil: +T?+, or a union with a
+      # +nil+ or +NilClass+ member. A call param typed this way may be
+      # omitted, whichever spelling declares it.
+      #: (String) -> bool
+      def nilable_type?(type)
+        node = RBS::Parser.parse_type(type, require_eof: true)
+        node.is_a?(RBS::Types::Optional) ||
+          (node.is_a?(RBS::Types::Union) && node.types.any? { |t| nil_type?(t) })
+      rescue RBS::ParsingError
+        type.end_with?("?")
+      end
+
+      # True for the RBS spellings of nil: the +nil+ base type and +NilClass+.
+      #: (untyped) -> bool
+      def nil_type?(node)
+        node.is_a?(RBS::Types::Bases::Nil) ||
+          (node.is_a?(RBS::Types::ClassInstance) && node.name.to_s.sub(/\A::/, "") == "NilClass")
+      end
+
+      # Widen +schema+ to also accept +null+.
+      #
+      # A plain scalar (+string+, +integer+, +number+, +boolean+) takes the
+      # type-array form, +{type: ["string", "null"]}+, so the keywords
+      # +apply_tags+ adds next to it (+minLength+, +format+, +pattern+, ...)
+      # stay on the same schema. They constrain strings only, so a null
+      # still passes.
+      #
+      # Everything else is wrapped: +{anyOf: [schema, {type: "null"}]}+.
+      # Objects and arrays keep +type: "object"+ / +type: "array"+ inside
+      # the wrapper, which +project_against_schema+ and +best_variant_for+
+      # depend on to keep dropping undeclared and gated keys. A +const+ or
+      # +enum+ schema is wrapped too, since its value list would otherwise
+      # reject null. The empty schema already accepts null and is returned
+      # unchanged.
+      #: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+      def nullable(schema)
+        return schema if schema.empty?
+
+        type = schema[:type]
+        if type.is_a?(Array)
+          return type.include?("null") ? schema : schema.merge(type: type + ["null"])
+        end
+
+        if NULLABLE_SCALAR_TYPES.include?(type) && !schema.key?(:const) && !schema.key?(:enum)
+          return schema.merge(type: [type, "null"])
+        end
+
+        variants = schema[:anyOf]
+        return schema if variants.is_a?(Array) && variants.include?(NULL_SCHEMA)
+
+        { anyOf: [schema, NULL_SCHEMA.dup] }
+      end
+
+      # The non-null branch of an +anyOf+ wrapper +nullable+ produced, or nil
+      # when +schema+ is not one.
+      #: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]?
+      def non_null_variant(schema)
+        variants = schema[:anyOf]
+        return nil unless variants.is_a?(Array) && variants.size == 2 && variants.include?(NULL_SCHEMA)
+
+        variants.find { |v| v != NULL_SCHEMA }
+      end
+
+      # True when +schema+ is one of the forms +nullable+ produces.
+      #: (Hash[Symbol, untyped]) -> bool
+      def null_admitting?(schema)
+        type = schema[:type]
+        return true if type.is_a?(Array) && type.include?("null")
+
+        !non_null_variant(schema).nil?
+      end
+
+      # Settle nullability for one direction of a compiled schema.
+      #
+      # Output keeps every +T?+ / +T | nil+ nullable: a handler may return
+      # nil where its contract says so. Input narrows each of them back to
+      # +T+, unless the field is tagged +@nullable()+. For an optional
+      # param an explicit +null+ and an omitted key are different requests,
+      # and a handler that reads +params.fetch(:key, default)+ or writes
+      # the value to a NOT NULL column handles only the second. A shared
+      # type can therefore be nullable in a tool's output and strict in
+      # another tool's input. Either way the internal tag marker is
+      # removed. Returns a new schema; the cached type map is not touched.
+      #: (Symbol, untyped) -> untyped
+      def finalize_for(direction, schema)
+        case schema
+        when Hash
+          keep = schema[NULLABLE_INPUT_KEY]
+          result = schema.each_with_object({}) do |(key, value), out|
+            next if key == NULLABLE_INPUT_KEY
+            out[key] = finalize_for(direction, value)
+          end
+          direction == :input && !keep ? non_nullable(result) : result
+        when Array
+          schema.map { |item| finalize_for(direction, item) }
+        else
+          schema
+        end
+      end
+
+      # Undo +nullable+ on one schema node: drop "null" from a type array,
+      # or unwrap an +anyOf: [schema, {type: "null"}]+ wrapper, keeping the
+      # wrapper's own keywords (description, examples) on the result.
+      #: (Hash[Symbol, untyped]) -> Hash[Symbol, untyped]
+      def non_nullable(schema)
+        type = schema[:type]
+        if type.is_a?(Array) && type.include?("null")
+          rest = type - ["null"]
+          return schema.merge(type: rest.size == 1 ? rest.first : rest)
+        end
+
+        inner = non_null_variant(schema)
+        return schema unless inner
+
+        inner.merge(schema.reject { |key, _| key == :anyOf })
+      end
+
+      # The non-null JSON type a schema describes, or nil. Looks through the
+      # forms +nullable+ produces: a +[T, "null"]+ type array, and an
+      # +anyOf+ of one schema plus +{type: "null"}+.
+      #: (Hash[Symbol, untyped]?) -> String?
+      def primary_type(schema)
+        return nil unless schema.is_a?(Hash)
+
+        type = schema[:type] || schema["type"]
+        return type.to_s if type.is_a?(String) || type.is_a?(Symbol)
+        return (type.map(&:to_s) - ["null"]).first if type.is_a?(Array)
+
+        variants = schema[:anyOf] || schema["anyOf"]
+        return nil unless variants.is_a?(Array)
+
+        others = variants.reject { |v| v == NULL_SCHEMA || v == { "type" => "null" } }
+        others.size == 1 ? primary_type(others.first) : nil
+      end
+
       # Map +RBS::Types::Record+ to a JSON Schema object. RBS handles
       # +?key:+ optional markers natively — they land in
       # +node.optional_fields+ rather than +node.fields+. No need for

data/lib/mcp_authorization/tool.rb

@@ -241,7 +241,7 @@ module McpAuthorization
               filtered_params = McpAuthorization::RbsSchemaCompiler.filter_input(
                 handler, params, server_context: effective_ctx
               )
-            rescue McpAuthorization::UnknownInputKeysError => e
+            rescue McpAuthorization::UnknownInputKeysError, McpAuthorization::MissingRequiredInputKeysError => e
               # In-band tool error (isError: true), not a JSON-RPC failure, so the
               # model reads the guidance. tool_name, not defn[:name]: a host may
               # rename the materialized class, and the caller knows the new name.

data/lib/mcp_authorization/version.rb

@@ -1,3 +1,3 @@
 module McpAuthorization
-  VERSION = "0.9.0"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mcp_authorization
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.11.0
 platform: ruby
 authors:
 - AndyGauge
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-28 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails