mcp_authorization 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20c6e18176da825d9b0e7bcf23a46962bfd56fe35feb9a50153eaf2596abf350
+  data.tar.gz: 61aff70044f8363aff6f36978653f9df161c99fc762e31640e739576048863ff
+SHA512:
+  metadata.gz: e3777b677db7e5bb447e7a7a574d7328e180007eb179165ff74ede8a80a7f93390989a9bae0869314d86754ad24d4c15cb89a082a6323de33f6327d6696c897f
+  data.tar.gz: bfa8da4b876faa556e8e51aeb3c9dd4fa948295eeab6d1ddb3017fa9ddea6c3dbbe20d13056fa5bc8ac08f18f983b2ea1b437e76efc622853e8333bdfac13bf1

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fountain (onboardiq)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,552 @@
+# mcp_authorization
+
+Rails engine for serving MCP tools with per-request schema discrimination compiled from RBS type annotations.
+
+Add it to your Gemfile and your Rails app speaks [MCP](https://modelcontextprotocol.io). Write `@rbs type` comments in plain Ruby service classes, tag fields and variants with `@requires(:flag)`, and the gem compiles tailored JSON Schema per request. The type definitions are the authorization policy.
+
+## Three layers of authorization
+
+The gem gives you three independent controls over what each user sees:
+
+| Layer | Mechanism | Effect |
+|---|---|---|
+| **Tool visibility** | `authorization :manage_workflows` on the tool class | Tool hidden entirely from users who lack the flag |
+| **Input fields** | `@requires(:backward_routing)` on a param in `#:` annotation | Field excluded from the input schema |
+| **Output variants** | `@requires(:backward_routing)` on a variant in `@rbs type output` | Variant excluded from the `oneOf` |
+
+All three go through the same predicate: `current_user.can?(:symbol)`. The symbol can represent a permission, a feature flag, a plan tier, an A/B bucket -- whatever your app puts behind it.
+
+## Install
+
+```ruby
+# Gemfile
+gem "mcp_authorization"
+```
+
+```sh
+bundle install
+```
+
+Routes install automatically at `/mcp`. No `mount` needed.
+
+## Configuration
+
+```ruby
+# config/initializers/mcp_authorization.rb
+McpAuthorization.configure do |config|
+  config.server_name    = "my-app"
+  config.server_version = "1.0.0"
+
+  # Build a context from each MCP request.
+  # Return anything that responds to .current_user.can?(symbol).
+  config.context_builder = ->(request) {
+    user = User.authenticate(request.headers["Authorization"])
+    OpenStruct.new(current_user: user)
+  }
+end
+```
+
+### Options
+
+| Option | Default | Description |
+|---|---|---|
+| `server_name` | `"mcp-authorization"` | Name in MCP handshake |
+| `server_version` | `"1.0.0"` | Version in MCP handshake |
+| `mount_path` | `"/mcp"` | URL prefix for MCP endpoints |
+| `default_domain` | `"default"` | Domain when no `:domain` segment in path |
+| `tool_paths` | `["app/mcp"]` | Directories where tool classes live (relative to Rails.root) |
+| `shared_type_paths` | `["sig/shared"]` | Directories where shared `.rbs` type files live |
+| `context_builder` | *required* | `(request) -> context` |
+| `cli_context_builder` | `nil` | `(domain:, role:) -> context` for rake tasks |
+
+## The contract
+
+The gem has two opinions about your app:
+
+```ruby
+context.current_user.can?(:symbol)         # => true/false  (required)
+context.current_user.default_for(:symbol)  # => value | nil (optional)
+```
+
+`can?` gates visibility -- fields, variants, and entire tools. `default_for` populates JSON Schema `default` values from the current user's context. The symbols can mean anything:
+
+```ruby
+current_user.can?(:manage_workflows)  # permission
+current_user.can?(:backward_routing)  # feature flag
+current_user.can?(:enterprise_plan)   # plan tier
+current_user.can?(:experiment_v2)     # A/B test
+
+current_user.default_for(:timezone)   # => "America/Chicago"
+current_user.default_for(:locale)     # => "en-US"
+```
+
+`default_for` is optional. If you don't use `@default_for` tags, you don't need it. When present, it's a simple case statement -- no metaprogramming:
+
+```ruby
+def default_for(key)
+  case key
+  when :timezone then timezone
+  when :locale then locale
+  end
+end
+```
+
+## Quick example
+
+### 1. Define shared types
+
+Define reusable types as `.rbs` files. These are plain RBS -- no comment markers.
+
+```rbs
+# sig/shared/error.rbs
+type error_code = "not_found"
+               | "invalid_transition"
+               | "already_at_stage"
+
+type error = {
+  success: false,
+  error: { code: error_code, message: String, hint: String }
+}
+```
+
+```rbs
+# sig/shared/applicant.rbs
+type applicant = {
+  id: String,
+  name: String,
+  current_stage: String,
+  applied_at: String
+}
+```
+
+### 2. Define a handler
+
+A handler includes `McpAuthorization::DSL`, imports shared types, and defines its own types. The `#:` annotation on `def call` is the input schema -- tag params with `@requires` to control who sees them.
+
+```ruby
+# app/service/workflows/advance_step.rb
+module Workflows
+  class AdvanceStep
+    # @rbs import error
+
+    include McpAuthorization::DSL
+
+    # @rbs type success = {
+    #   success: true,
+    #   applicant_id: String,
+    #   current_stage: String
+    # }
+
+    # @rbs type rerouted_success = {
+    #   success: true,
+    #   applicant_id: String,
+    #   previous_stage: String,
+    #   current_stage: String,
+    #   audit_trail: Array[String]
+    # }
+
+    # @rbs type output = success
+    #                   | rerouted_success  @requires(:backward_routing)
+    #                   | error
+
+    def description
+      if can?(:backward_routing)
+        "Advance an applicant to any stage, or reroute them backward."
+      else
+        "Advance an applicant to the next stage."
+      end
+    end
+
+    #: (
+    #:   applicant_id: String,
+    #:   workflow_id: String,
+    #:   ?stage_id: String?    @requires(:backward_routing),
+    #:   ?reason: String?      @requires(:backward_routing)
+    #: ) -> Hash[Symbol, untyped]
+    def call(applicant_id:, workflow_id:, stage_id: nil, reason: nil)
+      # your logic here
+    end
+  end
+end
+```
+
+### 3. Declare a tool
+
+```ruby
+# app/mcp/workflows/advance_step_tool.rb
+module Workflows
+  class AdvanceStepTool < McpAuthorization::Tool
+    tool_name "advance_step"
+    authorization :manage_workflows
+    not_destructive!
+    tags "operator"
+    dynamic_contract Workflows::AdvanceStep
+  end
+end
+```
+
+### 4. See the difference
+
+A user **without** `:backward_routing`:
+
+```
+advance_step — "Advance an applicant to the next stage."
+  input:  applicant_id, workflow_id
+  output: success | error
+```
+
+A user **with** `:backward_routing`:
+
+```
+advance_step — "Advance an applicant to any stage, or reroute them backward."
+  input:  applicant_id, workflow_id, stage_id, reason
+  output: success | rerouted_success | error
+```
+
+Same tool, same endpoint. The feature flag shapes the schema.
+
+## Handler interface
+
+A handler includes `McpAuthorization::DSL` and implements two methods:
+
+| Method | Purpose |
+|---|---|
+| `description` | Tool description shown to the MCP client |
+| `call(**params)` | Execute the tool and return a result |
+
+The DSL mixin provides `initialize(server_context:)`, `server_context`, and `can?(:flag)`.
+
+The input schema is inferred from the `#:` annotation on `def call`. The output schema comes from `@rbs type output`. No separate schema definition needed.
+
+## `@requires` rules
+
+**On input params** -- the param is excluded from the input schema when `can?` returns false. Tag them in the `#:` annotation above `def call`:
+
+```ruby
+#: (
+#:   query: String,
+#:   ?force: bool            @requires(:admin),
+#:   ?include_deleted: bool  @requires(:admin)
+#: ) -> Hash[Symbol, untyped]
+def call(query:, force: false, include_deleted: false)
+```
+
+**On output variants** -- the variant is excluded from the `oneOf`:
+
+```ruby
+# @rbs type output = public_result
+#                   | admin_result  @requires(:admin)
+#                   | error
+```
+
+Untagged params and variants are always included.
+
+## Shared types
+
+Define reusable types as `.rbs` files in `sig/shared/` (configurable via `shared_type_paths`):
+
+```rbs
+# sig/shared/pagination.rbs
+type pagination = {
+  page: Integer,
+  per_page: Integer,
+  total: Integer
+}
+```
+
+Import them in any handler:
+
+```ruby
+# @rbs import pagination
+# @rbs import error
+
+# @rbs type success = {
+#   success: true,
+#   items: Array[String],
+#   pagination: pagination
+# }
+
+# @rbs type output = success | error
+```
+
+The compiler loads `sig/shared/pagination.rbs` and `sig/shared/error.rbs`, parses their type definitions, and merges them into the handler's type map. The handler's own `@rbs type` definitions override on conflict.
+
+Shared types define **shapes**. Authorization (`@requires`) stays on the handler -- it's a local policy decision, not a property of the type itself.
+
+## Tool DSL
+
+```ruby
+class MyTool < McpAuthorization::Tool
+  tool_name "my_tool"
+  authorization :some_flag        # tool hidden when can?(:some_flag) is false
+  tags "recruiting", "operations" # which domains this tool appears in
+  read_only!                      # MCP annotation hints
+  dynamic_contract MyService      # handler class
+end
+```
+
+| Method | Purpose |
+|---|---|
+| `tool_name "name"` | MCP tool name |
+| `authorization :sym` | Tool-level visibility gate. Omit for public tools. |
+| `tags "domain1", ...` | Domain(s) this tool appears under. Defaults to `["default"]`. |
+| `dynamic_contract HandlerClass` | Handler providing description, schemas, and execution |
+| `read_only!` | Annotation: tool only reads data |
+| `not_destructive!` | Annotation: tool does not destroy data |
+| `destructive!` | Annotation: tool may destroy data |
+| `idempotent!` | Annotation: multiple calls have same effect |
+| `open_world!` | Annotation: tool may access external services |
+| `closed_world!` | Annotation: tool stays within the system |
+
+Tools self-register when loaded. Put them anywhere under `tool_paths` (default: `app/mcp/`).
+
+## Contract validation
+
+If a handler is missing required methods or schema definitions, the gem raises an `ArgumentError` on first request with a full diagnostic:
+
+```
+MyHandler does not satisfy the McpAuthorization handler contract.
+
+Problems:
+  - missing instance method #call
+  - missing instance method #description
+  - missing output schema (define # @rbs type output = variant1 | variant2 | ...)
+
+A handler class should look like:
+
+  class MyHandler
+    include McpAuthorization::DSL
+
+    # @rbs type output = success | error
+
+    def description
+      "What this tool does"
+    end
+
+    #: (name: String, ?force: bool @requires(:admin)) -> Hash[Symbol, untyped]
+    def call(name:, force: false)
+      # ...
+    end
+  end
+```
+
+## Multi-domain routing
+
+```
+POST /mcp/operator    -> tools tagged "operator"
+POST /mcp/recruiting  -> tools tagged "recruiting"
+POST /mcp             -> tools tagged with default_domain
+```
+
+Tag a tool with multiple domains to make it available in each:
+
+```ruby
+tags "operator", "recruiting"
+```
+
+## RBS type syntax
+
+The `@rbs type` comments compile to JSON Schema:
+
+```ruby
+# Primitives
+# @rbs type x = String    -> { "type": "string" }
+# @rbs type x = Integer   -> { "type": "integer" }
+# @rbs type x = Float     -> { "type": "number" }
+# @rbs type x = bool      -> { "type": "boolean" }
+# @rbs type x = true      -> { "type": "boolean", "const": true }
+# @rbs type x = false     -> { "type": "boolean", "const": false }
+
+# String enums
+# @rbs type status = "pending"
+#                  | "active"
+#                  | "closed"
+
+# Records
+# @rbs type result = {
+#   success: bool,
+#   message: String,
+#   count?: Integer
+# }
+# (count? is optional -- excluded from "required")
+
+# Arrays
+# @rbs type items = Array[String]
+
+# Type references (resolved from local types and imports)
+# @rbs type input = { id: String, status: status }
+```
+
+### Constraint and annotation tags
+
+Tag any field in a `#:` annotation or `@rbs type` record to add JSON Schema constraints. Tags are written as `@tag(value)` after the type:
+
+```ruby
+#: (
+#:   name: String                          @min(1) @max(100),
+#:   email: String                         @format(email),
+#:   age: Integer                          @min(0) @max(150),
+#:   score: Float                          @exclusive_min(0) @exclusive_max(1.0),
+#:   tags: Array[String]                   @min(1) @max(10) @unique(),
+#:   quantity: Integer                     @multiple_of(5),
+#:   ?timezone: String                     @default_for(:timezone),
+#:   ?stage_id: String?                    @requires(:backward_routing) @depends_on(:workflow_id)
+#: ) -> Hash[Symbol, untyped]
+```
+
+**Value constraints:**
+
+| Tag | Applies to | JSON Schema |
+|---|---|---|
+| `@min(n)` | String, Integer, Float, Array | `minLength`, `minimum`, or `minItems` |
+| `@max(n)` | String, Integer, Float, Array | `maxLength`, `maximum`, or `maxItems` |
+| `@exclusive_min(n)` | Integer, Float | `exclusiveMinimum` |
+| `@exclusive_max(n)` | Integer, Float | `exclusiveMaximum` |
+| `@multiple_of(n)` | Integer, Float | `multipleOf` |
+| `@pattern(regex)` | String | `pattern` |
+| `@format(name)` | String | `format` (e.g. `email`, `uri`, `date-time`) |
+| `@unique()` | Array | `uniqueItems: true` |
+
+**Metadata:**
+
+| Tag | JSON Schema | Purpose |
+|---|---|---|
+| `@desc(text)` | `description` | Field description — also used as tool-chaining hints for MCP clients |
+| `@title(text)` | `title` | Human-readable title |
+| `@default(value)` | `default` | Default value (`true`, `false`, `nil`, numbers, strings) |
+| `@default_for(:key)` | `default` | Dynamic default resolved via `current_user.default_for(:key)` |
+| `@example(value)` | `examples` | Example value (repeat for multiple: `@example(foo) @example(bar)`) |
+| `@deprecated()` | `deprecated: true` | Mark as deprecated |
+| `@read_only()` | `readOnly: true` | Read-only field |
+| `@write_only()` | `writeOnly: true` | Write-only field |
+
+**Authorization:**
+
+| Tag | Purpose |
+|---|---|
+| `@requires(:flag)` | Field/variant excluded when `can?(:flag)` is false |
+| `@depends_on(:field)` | Emits `dependentRequired` — field only required when parent field is present |
+
+**Niche:**
+
+| Tag | JSON Schema |
+|---|---|
+| `@closed()` / `@strict()` | `additionalProperties: false` |
+| `@media_type(type)` | `contentMediaType` (e.g. `application/json`) |
+| `@encoding(enc)` | `contentEncoding` (e.g. `base64`) |
+
+The `@min` / `@max` tags are type-aware: on strings they emit `minLength`/`maxLength`, on numbers `minimum`/`maximum`, and on arrays `minItems`/`maxItems`.
+
+### Multiline `#:` annotations
+
+The `#:` annotation above `def call` supports multiple lines. Each line starts with `#:`:
+
+```ruby
+#: (
+#:   applicant_id: String       @desc(Use fetch_latest_applicant to find this),
+#:   workflow_id: String,
+#:   ?stage_id: String?         @requires(:backward_routing) @depends_on(:workflow_id),
+#:   ?reason: String?           @requires(:backward_routing)
+#: ) -> Hash[Symbol, untyped]
+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.
+
+### `@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`:
+
+```ruby
+#: (
+#:   workflow_id: String,
+#:   ?stage_id: String?      @requires(:backward_routing) @depends_on(:workflow_id),
+#:   ?reason: String?        @requires(:backward_routing) @depends_on(:stage_id)
+#: ) -> Hash[Symbol, untyped]
+```
+
+When `:backward_routing` is enabled, the schema includes:
+```json
+{
+  "dependentRequired": {
+    "workflow_id": ["stage_id"],
+    "stage_id": ["reason"]
+  }
+}
+```
+
+### Discriminated unions
+
+Literal `true` / `false` types become `"const"` values in JSON Schema:
+
+```ruby
+# @rbs type success = { success: true, data: String }
+# @rbs type error   = { success: false, code: String }
+# @rbs type output  = success | error
+```
+
+MCP clients can narrow on `success: const true` vs `success: const false` -- the same pattern as TypeScript discriminated unions.
+
+## Performance
+
+Source files are parsed once at boot and cached in memory. Only `@requires` filtering runs per request (hash lookups and `can?` calls). In development, caches are cleared automatically on file change via the Rails reloader.
+
+## Development
+
+### Live reload
+
+In development mode, the gem wires into the Rails reloader. Edit an `@rbs type` annotation, save, and the next MCP request returns the updated schema. No server restart needed.
+
+### Rake tasks
+
+```sh
+# List tools visible to a given role
+bundle exec rake "mcp:tools[operator,manager]"
+
+# Print Claude Code / Claude Desktop config JSON
+bundle exec rake "mcp:claude[operator,manager]"
+
+# Launch MCP Inspector (requires npx)
+bundle exec rake "mcp:inspect[operator,manager]"
+```
+
+Rake tasks require `cli_context_builder`:
+
+```ruby
+config.cli_context_builder = ->(domain:, role:) {
+  user = User.new(role: role, permissions: ROLE_PERMISSIONS[role])
+  OpenStruct.new(current_user: user)
+}
+```
+
+## How it works
+
+1. MCP client sends a request to `/mcp/:domain`
+2. Engine calls your `context_builder` with the request
+3. `ToolRegistry` filters tools by domain tag and `authorization` gate (`can?` check)
+4. `RbsSchemaCompiler` loads shared types from `# @rbs import` declarations
+5. Input schema is compiled from the `#:` annotation on `def call`, filtering `@requires` params
+6. Output schema is compiled from `@rbs type output`, filtering `@requires` variants
+7. MCP client receives tool definitions with schemas tailored to the current user
+
+Different users hitting the same endpoint can see different tools, different descriptions, different input fields, and different output shapes.
+
+## Stateless transport and schema lifetime
+
+The gem uses the MCP SDK's Streamable HTTP transport in **stateless mode**. Each HTTP request creates a fresh `MCP::Server`, materialized with tools filtered and shaped for the current user. There is no persistent session or SSE stream between requests.
+
+This is a deliberate choice. The gem's value is per-request schema discrimination -- the same endpoint returns different JSON Schema depending on who's asking. A stateful session would bake the tool list at connection time, meaning permission changes during a session would serve stale schemas until reconnect.
+
+In practice this doesn't matter because MCP clients call `tools/list` once -- at the start of a conversation or when manually refreshed. The schema returned at that point is what the client (and the LLM behind it) uses for the entire conversation. Tool calls made later in the conversation still go through `context_builder` and the `authorization` gate, so a revoked permission results in a rejected call, not a leaked capability.
+
+The tradeoff: stateless mode cannot send `notifications/tools/list_changed` or use `report_progress` during long-running tool calls, since both require an open SSE stream. For most use cases this is the right default -- schemas that reflect the current user's permissions at conversation start, enforced again at call time.
+
+## Requirements
+
+- Ruby >= 3.1
+- Rails >= 7.0
+- [mcp](https://rubygems.org/gems/mcp) ~> 0.10
+
+## License
+
+MIT

data/app/controllers/mcp_authorization/mcp_controller.rb

@@ -0,0 +1,37 @@
+module McpAuthorization
+  class McpController < ActionController::Base
+    skip_forgery_protection
+
+    # POST/GET/DELETE /mcp/:domain
+    #: () -> void
+    def handle
+      server_context = build_server_context
+      tools = McpAuthorization::ToolRegistry.tool_classes_for(
+        domain: params[:domain],
+        server_context: server_context
+      )
+
+      server = MCP::Server.new(
+        name: McpAuthorization.config.server_name,
+        version: McpAuthorization.config.server_version,
+        tools: tools,
+        server_context: server_context
+      )
+      transport = MCP::Server::Transports::StreamableHTTPTransport.new(server, stateless: true)
+      server.transport = transport
+
+      status, headers, body = transport.handle_request(request)
+      headers.each { |k, v| response.set_header(k, v) }
+      render json: body.first, status: status
+    end
+
+    private
+
+    #: () -> untyped
+    def build_server_context
+      builder = McpAuthorization.config.context_builder
+      raise "McpAuthorization.config.context_builder must be configured" unless builder
+      builder.call(request)
+    end
+  end
+end

data/lib/mcp_authorization/configuration.rb

@@ -0,0 +1,81 @@
+module McpAuthorization
+  # Holds gem-wide settings. A single global instance is created lazily by
+  # McpAuthorization.configuration and configured in a Rails initializer:
+  #
+  #   McpAuthorization.configure do |c|
+  #     c.server_name      = "my-app"
+  #     c.server_version   = MyApp::VERSION
+  #     c.tool_paths       = %w[app/mcp]
+  #     c.context_builder  = ->(request) { ... }
+  #   end
+  #
+  # == Required settings
+  #
+  # +context_builder+ must be set before the first MCP request. Everything
+  # else has sensible defaults.
+  #
+  # == The context contract
+  #
+  # Both +context_builder+ and +cli_context_builder+ must return an object
+  # whose +current_user+ responds to:
+  #
+  #   current_user.can?(:symbol)              # required — gates field/tool visibility
+  #   current_user.default_for(:symbol)       # optional — populates @default_for tags
+  #
+  class Configuration
+    # Server name reported in the MCP +initialize+ handshake.
+    #: String
+    attr_accessor :server_name
+
+    # Server version reported in the MCP +initialize+ handshake.
+    #: String
+    attr_accessor :server_version
+
+    # Directories (relative to +Rails.root+) that contain tool classes.
+    # Added to +autoload_paths+ and +eager_load_paths+ by the Engine.
+    #: Array[String]
+    attr_accessor :tool_paths
+
+    # Directories (relative to +Rails.root+) where shared +.rbs+ type
+    # files live. Used by RbsSchemaCompiler to resolve +# @rbs import+.
+    #: Array[String]
+    attr_accessor :shared_type_paths
+
+    # Domain name used when the request URL has no +:domain+ segment.
+    #: String
+    attr_accessor :default_domain
+
+    # URL prefix where the Engine mounts its routes.
+    #: String
+    attr_accessor :mount_path
+
+    # Lambda that builds a server context from a Rack request.
+    # The returned object must satisfy the context contract above.
+    #: (^(untyped) -> untyped)?
+    attr_accessor :context_builder
+
+    # Lambda that builds a server context for CLI/rake usage.
+    # Same duck-type contract as +context_builder+.
+    #: (^(domain: String, role: String) -> untyped)?
+    attr_accessor :cli_context_builder
+
+    # When true, strips JSON Schema keywords that cause 400 errors in
+    # Anthropic's strict tool use mode (minLength, maximum, maxItems, etc.)
+    # and adds additionalProperties: false to all objects.
+    #: bool
+    attr_accessor :strict_schema
+
+    #: () -> void
+    def initialize
+      @server_name = "mcp-authorization"
+      @server_version = "1.0.0"
+      @tool_paths = %w[app/mcp]
+      @shared_type_paths = %w[sig/shared]
+      @default_domain = "default"
+      @mount_path = "/mcp"
+      @context_builder = nil
+      @cli_context_builder = nil
+      @strict_schema = false
+    end
+  end
+end