open_router_enhanced 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c9c14171242103eaeab8219521180242f9e0ee0968c739f8db2148a17423a5
-  data.tar.gz: '0906f33ab027e8cbf17ff60ab120ec65de39ec689c6e9a48025fb8df679f7d55'
+  metadata.gz: '08f395125182c8bc6fdedec8b3c1057750344bc56f5988373a5a4deaaccf6585'
+  data.tar.gz: c98f3b9e15d8838b0fcc160c55a7b9ae0a4ade6fe05495d3663e016666c48914
 SHA512:
-  metadata.gz: 4cd127d4d6889e281e88e3f044f2444bd32e46f7ac4797d5c786b9a3fc5a8f792baf445c8dea481ab5018fae72646a221da05266bcb4134266735546e35a428d
-  data.tar.gz: a5b80c88d5f2228f1891409d2edb335a1a2c0294b94ffc69fb2730d0a854f7010c5eece8ac026eb6ba99a60df583634f42c77e18aada4b0399886b6a744a3488
+  metadata.gz: 5526e571d28a4c3d93726d67f4441c90890980c929b36938e2ed0f8137c29e0ac8773a7d438de4422119e0660522334447bab2585837333c2ae1651f79ef0cd9
+  data.tar.gz: 6977214b59795346e76855586eb04ff50f173e45ea6189ad1b514ad80ff5edabb1a68f433b8535977789516685eb321db6d820ca7fe18564821c9cd392a9ecf7

data/CHANGELOG.md

@@ -1,22 +1,15 @@
 ## [Unreleased]
 
-## [2.2.0] - 2026-06-28
+## [2.3.0] - 2026-07-08
 
-### Added
-
-- **`Routing` mixin** (`OpenRouter::Routing`) included in `Client`, providing two new meta-routing methods:
-  - `pareto_complete(messages, min_coding_score: nil, **opts)` — routes to the cheapest model meeting a configurable quality bar via OpenRouter's Pareto Code Router (`openrouter/pareto-code`). `min_coding_score` is validated to `0.0–1.0`.
-  - `fuse(messages, analysis_models: nil, judge: nil, preset: nil, max_tool_calls: nil, **opts)` — fans a prompt out to a panel of models and synthesises one answer via OpenRouter's Fusion router (`openrouter/fusion`). `analysis_models` (1–8) and `max_tool_calls` (1–16) are validated.
-- **`SubagentTool`** (`OpenRouter::SubagentTool`) — wraps OpenRouter's `openrouter:subagent` server tool so an orchestrator model can delegate self-contained subtasks to a cheaper worker model mid-generation. Constructor: `model:` (required worker model) plus optional `instructions:`, `max_completion_tokens:`, `temperature:`, and `reasoning:`. Pass it via the normal `tools:` array to `complete`.
-- **`Response#selected_model`** — alias for `#model`; returns the concrete model OpenRouter resolved for routing responses (e.g. Pareto, Auto, Fusion).
-
-### Changed
+### Fixed
 
-- Capability warning / strict-mode guards now exempt all `openrouter/`-prefixed meta-models (previously only `openrouter/auto` was exempt); this prevents spurious warnings or `CapabilityError` when using `pareto_complete` or `fuse` with tools or structured outputs.
+- **Structured output schemas now honor optional keys.** `Schema#to_h` previously forced *every* property — at every nesting level — into the `required` array, so fields declared with `required: false` (the DSL default) were silently made mandatory in the prompt, the native `json_schema` payload, and the healer. `to_h` now emits the schema honestly, respecting the `required` arrays exactly as declared. Optional fields stay optional and the model may omit them.
+- `to_h` and local validation now agree, so what is described to the model matches what is accepted.
 
-### Notes
+### Added
 
-- These three OpenRouter platform features are still evolving server-side. The gem builds and validates the requests; routing/synthesis/delegation behaviour is performed by OpenRouter. Fusion fans out to every panel model plus a judge, so it costs roughly 4–5× a single completion. `pareto_complete` may resolve to a reasoning model that consumes a small `max_tokens` budget entirely on reasoning (returning `nil` content with `finish_reason: "length"`) — budget `max_tokens` accordingly.
+- `Schema#to_strict_h` — the provider-strict form for native `json_schema` decoding. It still lists every property in `required` (so strict providers don't `400` on nested `required: []`), but expresses optionality the correct way: fields not declared required are made **nullable** (their type gains `"null"`) rather than mandatory. The native serialization path uses this form automatically for strict schemas.
 
 ## [2.0.0] - 2025-12-28
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    open_router_enhanced (2.2.0)
+    open_router_enhanced (2.3.0)
       activesupport (>= 6.0, < 9.0)
       dotenv (>= 2.0, < 4.0)
       faraday (>= 1.0, < 3.0)

data/README.md

@@ -45,7 +45,6 @@ The [OpenRouter API](https://openrouter.ai/docs) is a single unified interface f
   - [Tool Calling](#tool-calling)
   - [Structured Outputs](#structured-outputs)
   - [Smart Model Selection](#smart-model-selection)
-  - [Routing (Pareto & Fusion)](#routing-pareto--fusion)
   - [Prompt Templates](#prompt-templates)
   - [Streaming](#streaming)
   - [Usage Tracking](#usage-tracking)
@@ -384,95 +383,6 @@ models = OpenRouter::ModelSelector.new
 
 **[Complete Model Selection Documentation](docs/model_selection.md)**
 
-### Routing (Pareto & Fusion)
-
-OpenRouter offers two meta-routing modes that automatically pick or synthesize answers across models.
-
-#### Pareto Code Router
-
-Routes each request to the cheapest model that meets a configurable quality bar — useful when you want cost-optimised code completions without picking a specific model.
-
-```ruby
-# Cheapest model meeting default quality threshold
-response = client.pareto_complete([
-  { role: "user", content: "Write a binary search in Ruby" }
-])
-
-# Require a higher quality bar (0.0–1.0, higher = better)
-response = client.pareto_complete(
-  [{ role: "user", content: "Implement a red-black tree" }],
-  min_coding_score: 0.8,
-  max_tokens: 1000
-)
-
-# Which model actually answered?
-puts response.selected_model  # => "anthropic/claude-3.5-haiku"
-puts response.content
-```
-
-#### Fusion Router
-
-Fans a prompt out to a panel of models in parallel, then synthesises one answer with a judge model. Costs roughly 4–5× a single completion but can outperform any individual model.
-
-```ruby
-# Default panel (OpenRouter chooses)
-response = client.fuse([
-  { role: "user", content: "What is the best approach to distributed consensus?" }
-])
-
-# Custom panel + explicit judge
-response = client.fuse(
-  [{ role: "user", content: "Review this architecture" }],
-  analysis_models: [
-    "anthropic/claude-3.5-sonnet",
-    "openai/gpt-4o",
-    "google/gemini-2.0-flash-001"
-  ],
-  judge: "anthropic/claude-opus-4-5",
-  max_tokens: 2000
-)
-
-# Curated preset panels
-response = client.fuse(messages, preset: "general-budget")
-
-# selected_model reports the synthesis/judge model that produced the answer,
-# e.g. "anthropic/claude-opus-4-5" — not the "openrouter/fusion" router alias.
-puts response.selected_model
-puts response.content
-```
-
-> **Note:** Fusion fans out to every panel model plus a judge, so it costs roughly 4–5× a single completion. `min_coding_score` for Pareto is validated to `0.0–1.0`; `analysis_models` (1–8) and `max_tool_calls` (1–16) for Fusion are validated client-side.
-
-#### `SubagentTool`
-
-Wraps OpenRouter's built-in `openrouter:subagent` server tool so an LLM can spawn its own sub-completions during a tool-calling loop.
-
-```ruby
-subagent = OpenRouter::SubagentTool.new(
-  model: "anthropic/claude-3.5-haiku",  # required: the cheaper worker model
-  instructions: "Complete the task exactly as described. Be concise.", # optional
-  max_completion_tokens: 512            # optional (also: temperature:, reasoning:)
-)
-
-response = client.complete(
-  [{ role: "user", content: "Summarize the attached changelog into release notes." }],
-  model: "openai/gpt-4o",
-  tools: [subagent],
-  tool_choice: "auto"
-)
-```
-
-> The orchestrator decides whether to delegate. The gem's job is to build and send a valid `openrouter:subagent` tool; OpenRouter runs the worker server-side and feeds its result back into the orchestrator's generation.
-
-#### `Response#selected_model`
-
-All routing methods (`complete`, `pareto_complete`, `fuse`) return a `Response` object. Use `#selected_model` (alias for `#model`) to see which model OpenRouter ultimately used:
-
-```ruby
-response = client.pareto_complete(messages)
-puts response.selected_model  # e.g. "mistralai/codestral-2501"
-```
-
 ### Prompt Templates
 
 Create reusable, parameterized prompts with variable interpolation.

data/lib/open_router/callbacks.rb

@@ -43,7 +43,7 @@ module OpenRouter
       @callbacks[event].each do |callback|
         callback.call(data)
       rescue StandardError => e
-        OpenRouter.log_warning("[OpenRouter] Callback error for #{event}: #{e.message}")
+        warn "[OpenRouter] Callback error for #{event}: #{e.message}"
       end
     end
   end

data/lib/open_router/client.rb

@@ -8,7 +8,6 @@ require_relative "callbacks"
 require_relative "parameter_builder"
 require_relative "tool_serializer"
 require_relative "request_handler"
-require_relative "routing"
 
 module OpenRouter
   class ServerError < StandardError; end
@@ -19,7 +18,6 @@ module OpenRouter
     include OpenRouter::ParameterBuilder
     include OpenRouter::ToolSerializer
     include OpenRouter::RequestHandler
-    include OpenRouter::Routing
 
     attr_reader :callbacks, :usage_tracker, :configuration
 
@@ -60,7 +58,10 @@ module OpenRouter
       opts = normalize_options(options, kwargs)
       parameters = prepare_base_parameters(messages, opts, stream)
       forced_extraction = configure_tools_and_structured_outputs!(parameters, opts)
-      configure_plugins!(parameters, opts.response_format, stream)
+      # Gate the response-healing plugin on what's actually on the wire — it requires
+      # response_format to be present, so keying off opts.response_format (intent) would
+      # attach it even when no response_format was sent and produce a 400.
+      configure_plugins!(parameters, parameters[:response_format], stream)
       validate_vision_support(opts.model, messages)
 
       trigger_callbacks(:before_request, parameters)
@@ -68,7 +69,7 @@ module OpenRouter
       raw_response = execute_request(parameters)
       validate_response!(raw_response, stream)
 
-      response = build_response(raw_response, opts.response_format, forced_extraction)
+      response = build_response(raw_response, opts.response_format, forced_extraction, strict: resolve_strict(opts.strict))
 
       model_for_tracking = opts.model.is_a?(String) ? opts.model : opts.model.first
       @usage_tracker&.track(response, model: model_for_tracking)
@@ -195,6 +196,13 @@ module OpenRouter
 
     private
 
+    # Per-call `strict:` wins; otherwise fall back to the configured default.
+    def resolve_strict(strict)
+      return strict unless strict.nil?
+
+      configuration.structured_output_strict
+    end
+
     def normalize_options(options, kwargs)
       case options
       when CompletionOptions

data/lib/open_router/completion_options.rb

@@ -147,11 +147,18 @@ module OpenRouter
     # Client-side options (not sent to API)
     # ═══════════════════════════════════════════════════════════════════════════
 
-    # @return [Boolean, nil] Override forced extraction mode for structured outputs
-    #   true: Force extraction via system message injection
-    #   false: Use native structured output
-    #   nil: Auto-determine based on model capability
-    attr_accessor :force_structured_output
+    # @return [Boolean, nil] Request provider-side native json_schema enforcement.
+    #   true:  Send response_format: { type: "json_schema", ... } (grammar-constrained,
+    #          only supported by some models/providers — can 400 on unsupported ones).
+    #   false/nil (default): Send response_format: { type: "json_object" } and describe
+    #          the schema in the prompt. Widely supported; validated/healed client-side.
+    attr_accessor :native
+
+    # @return [Boolean, nil] Validation strictness for structured outputs.
+    #   true:  Raise StructuredOutputError if the response doesn't match the schema.
+    #   false/nil (default): Best-effort — return the parsed JSON as-is.
+    #   When nil, falls back to configuration.structured_output_strict.
+    attr_accessor :strict
 
     # All supported parameters with their defaults
     DEFAULTS = {
@@ -193,11 +200,12 @@ module OpenRouter
       # Responses API
       reasoning: nil,
       # Client-side
-      force_structured_output: nil
+      native: nil,
+      strict: nil
     }.freeze
 
     # Parameters that are client-side only (not sent to API)
-    CLIENT_SIDE_PARAMS = %i[force_structured_output extras].freeze
+    CLIENT_SIDE_PARAMS = %i[native strict extras].freeze
 
     # Initialize with keyword arguments
     #

data/lib/open_router/json_healer.rb

@@ -133,7 +133,7 @@ module OpenRouter
     rescue StandardError => e
       # If the healing call itself fails, we can't proceed.
       # Return the original broken content to let the loop fail naturally.
-      OpenRouter.log_warning("[OpenRouter Warning] JSON healing request failed: #{e.message}")
+      warn "[OpenRouter Warning] JSON healing request failed: #{e.message}"
 
       # Trigger callback for failed healing
       if @client.respond_to?(:trigger_callbacks)

data/lib/open_router/request_handler.rb

@@ -58,8 +58,9 @@ module OpenRouter
       raise ServerError, "Empty response from OpenRouter. Might be worth retrying once or twice."
     end
 
-    def build_response(raw_response, response_format, forced_extraction)
-      response = Response.new(raw_response, response_format: response_format, forced_extraction: forced_extraction)
+    def build_response(raw_response, response_format, forced_extraction, strict: false)
+      response = Response.new(raw_response, response_format: response_format, forced_extraction: forced_extraction,
+                                            strict: strict)
       response.client = self
       response
     end
@@ -69,7 +70,7 @@ module OpenRouter
     end
 
     def warn_if_unsupported(model, capability, feature_name)
-      return if model.is_a?(Array) || model.to_s.start_with?("openrouter/")
+      return if model.is_a?(Array) || model == "openrouter/auto"
       return if ModelRegistry.has_capability?(model, capability)
 
       if configuration.strict_mode
@@ -80,7 +81,7 @@ module OpenRouter
       warning_key = "#{model}:#{capability}"
       return if @capability_warnings_shown.include?(warning_key)
 
-      OpenRouter.log_warning("[OpenRouter Warning] Model '#{model}' may not support #{feature_name} (missing :#{capability} capability). The request will still be attempted.")
+      warn "[OpenRouter Warning] Model '#{model}' may not support #{feature_name} (missing :#{capability} capability). The request will still be attempted."
       @capability_warnings_shown << warning_key
     end
 

data/lib/open_router/response.rb

@@ -10,13 +10,14 @@ module OpenRouter
   class Response
     include OpenRouter::ResponseParsing
 
-    attr_reader :raw_response, :response_format, :forced_extraction
+    attr_reader :raw_response, :response_format, :forced_extraction, :strict
     attr_accessor :client
 
-    def initialize(raw_response, response_format: nil, forced_extraction: false)
+    def initialize(raw_response, response_format: nil, forced_extraction: false, strict: false)
       @raw_response = raw_response.is_a?(Hash) ? raw_response.with_indifferent_access : {}
       @response_format = response_format
       @forced_extraction = forced_extraction
+      @strict = strict
       @client = nil
     end
 
@@ -80,14 +81,7 @@ module OpenRouter
 
     # Structured output methods
     def structured_output(mode: nil, auto_heal: nil)
-      # Use global default mode if not specified
-      if mode.nil?
-        mode = if @client&.configuration.respond_to?(:default_structured_output_mode)
-                 @client.configuration.default_structured_output_mode || :strict
-               else
-                 :strict
-               end
-      end
+      mode ||= default_structured_output_mode
       # Validate mode parameter
       raise ArgumentError, "Invalid mode: #{mode}. Must be :strict or :gentle." unless %i[strict gentle].include?(mode)
 
@@ -104,6 +98,10 @@ module OpenRouter
 
         result = parse_and_heal_structured_output(auto_heal: should_heal)
 
+        # In the json_object path (lenient extraction) a parse failure yields nil rather
+        # than raising. Strict mode must surface that as an error rather than returning nil.
+        raise StructuredOutputError, "Failed to parse structured output from response" if result.nil?
+
         # Only validate after parsing if healing is disabled (healing handles its own validation)
         if result && !should_heal
           schema_obj = extract_schema_from_response_format
@@ -185,10 +183,6 @@ module OpenRouter
       @raw_response["model"]
     end
 
-    # Alias for #model — returns the concrete model the API/router used.
-    # Useful for Pareto, Auto, and Fusion routing ("which model answered?").
-    alias selected_model model
-
     def created
       @raw_response["created"]
     end
@@ -260,5 +254,13 @@ module OpenRouter
     def error_message
       @raw_response.dig("error", "message")
     end
+
+    private
+
+    # :strict raises on schema mismatch; :gentle returns best-effort. Driven by the
+    # `strict:` flag resolved at request time (per-call option or configured default).
+    def default_structured_output_mode
+      @strict ? :strict : :gentle
+    end
   end
 end

data/lib/open_router/schema.rb

@@ -28,23 +28,36 @@ module OpenRouter
       new(name, builder.to_h, strict:)
     end
 
-    # Convert to the format expected by OpenRouter API
+    # Convert to the format expected by OpenRouter API.
+    #
+    # This is the *honest* representation: it respects the `required` arrays
+    # exactly as declared, so fields you left optional stay optional. It is what
+    # we describe to the model (prompt injection), what we validate against, and
+    # what we hand the healer — keeping "what we ask for" and "what we accept" in
+    # agreement. The provider-strict, all-required form lives in #to_strict_h and
+    # is used only when serializing a native `json_schema` request.
     def to_h
-      # Apply OpenRouter-specific transformations
-      openrouter_schema = @schema.dup
-
-      # OpenRouter/Azure requires ALL properties to be in the required array
-      # even if they are logically optional. This is a deviation from JSON Schema spec
-      # but necessary for compatibility.
-      if openrouter_schema[:properties]&.any?
-        all_properties = openrouter_schema[:properties].keys.map(&:to_s)
-        openrouter_schema[:required] = all_properties
-      end
+      {
+        name: @name,
+        strict: @strict,
+        schema: @schema
+      }
+    end
 
+    # Provider-strict form for native `json_schema` decoding.
+    #
+    # OpenRouter / OpenAI strict mode requires EVERY object — at every nesting
+    # level, including nested objects and array items — to list all of its
+    # properties in its `required` array; a nested `required: []` gets a 400.
+    # We satisfy that WITHOUT silently making optional fields mandatory: any
+    # property that was not declared required is made nullable (its type gains
+    # "null"), which is exactly how strict mode expresses optionality. The model
+    # may then return `null` for it instead of being forced to invent a value.
+    def to_strict_h
       {
         name: @name,
         strict: @strict,
-        schema: openrouter_schema
+        schema: enforce_all_required(@schema)
       }
     end
 
@@ -121,6 +134,51 @@ module OpenRouter
 
     private
 
+    # Recursively force every object to list all its properties in `required`,
+    # keeping declared-optional properties optional by making them nullable.
+    # Reads each node's OWN existing `required` before overwriting, so nested
+    # optionality is preserved at every level.
+    def enforce_all_required(node)
+      case node
+      when Hash
+        transformed = node.each_with_object({}) { |(key, value), acc| acc[key] = enforce_all_required(value) }
+
+        props = transformed[:properties] || transformed["properties"]
+        if props.is_a?(Hash) && props.any?
+          key = transformed.key?(:properties) ? :required : "required"
+          already_required = Array(transformed[key]).map(&:to_s)
+          props.each do |prop_name, prop_def|
+            next if already_required.include?(prop_name.to_s)
+
+            props[prop_name] = make_nullable(prop_def)
+          end
+          transformed[key] = props.keys.map(&:to_s)
+        end
+
+        transformed
+      when Array
+        node.map { |element| enforce_all_required(element) }
+      else
+        node
+      end
+    end
+
+    # Add "null" to a property's type union so it can be omitted (as null) under
+    # strict mode. Leaves the property untouched if it has no determinable type.
+    def make_nullable(prop_def)
+      return prop_def unless prop_def.is_a?(Hash)
+
+      type_key = if prop_def.key?(:type) then :type
+                 elsif prop_def.key?("type") then "type"
+                 end
+      return prop_def unless type_key
+
+      types = Array(prop_def[type_key]).map(&:to_s)
+      return prop_def if types.include?("null")
+
+      prop_def.merge(type_key => types + ["null"])
+    end
+
     def validate_schema!
       raise ArgumentError, "Schema name is required" if @name.nil? || @name.empty?
       raise ArgumentError, "Schema must be a hash" unless @schema.is_a?(Hash)

data/lib/open_router/streaming_client.rb

@@ -135,7 +135,7 @@ module OpenRouter
       @streaming_callbacks[event].each do |callback|
         callback.call(data)
       rescue StandardError => e
-        OpenRouter.log_warning("[OpenRouter] Streaming callback error for #{event}: #{e.message}")
+        warn "[OpenRouter] Streaming callback error for #{event}: #{e.message}"
       end
     end
 

data/lib/open_router/tool_serializer.rb

@@ -20,43 +20,35 @@ module OpenRouter
       parameters[:tool_choice] = opts.tool_choice if opts.tool_choice
     end
 
-    # Returns forced_extraction boolean
+    # Configure the structured-output request.
+    #
+    # Default (native: false): ask the provider for a plain JSON object — the most
+    # widely supported response_format across models/providers — and describe the
+    # schema in the prompt. The model's capability registry never gates the request.
+    #
+    # Opt-in (native: true): send response_format: { type: "json_schema", ... } for
+    # grammar-constrained decoding. Only some models/providers support this; it can
+    # 400 on the rest, which is why it is explicit rather than auto-detected.
+    #
+    # Returns the lenient-extraction flag (true when the schema was injected into the
+    # prompt, so the response may need JSON extracted from surrounding text).
     def configure_structured_outputs!(parameters, opts)
       return false unless opts.response_format?
 
-      force_extraction = determine_forced_extraction_mode(opts.model, opts.force_structured_output)
+      schema = extract_schema(opts.response_format)
 
-      if force_extraction
-        handle_forced_structured_output!(parameters, opts.model, opts.response_format)
-        true
-      else
-        handle_native_structured_output!(parameters, opts.model, opts.response_format)
-        false
+      if opts.native && schema
+        warn_if_unsupported(opts.model, :structured_outputs, "structured outputs")
+        parameters[:response_format] = serialize_response_format(opts.response_format)
+        return false
       end
-    end
-
-    def determine_forced_extraction_mode(model, force_structured_output)
-      return force_structured_output unless force_structured_output.nil?
-
-      if model.is_a?(String) &&
-         !model.start_with?("openrouter/") &&
-         !ModelRegistry.has_capability?(model, :structured_outputs) &&
-         configuration.auto_force_on_unsupported_models
-        OpenRouter.log_warning("[OpenRouter] Model '#{model}' doesn't support native structured outputs. Automatically using forced extraction mode.")
-        true
-      else
-        false
-      end
-    end
 
-    def handle_forced_structured_output!(parameters, model, response_format)
-      warn_if_unsupported(model, :structured_outputs, "structured outputs") if configuration.strict_mode
-      inject_schema_instructions!(parameters[:messages], response_format)
-    end
+      # Default json_object path.
+      parameters[:response_format] = { type: "json_object" }
+      return false unless schema
 
-    def handle_native_structured_output!(parameters, model, response_format)
-      warn_if_unsupported(model, :structured_outputs, "structured outputs")
-      parameters[:response_format] = serialize_response_format(response_format)
+      inject_schema_instructions!(parameters[:messages], schema)
+      true
     end
 
     # Serialize tools to Chat Completions API format: { type: "function", function: { name:, parameters: } }
@@ -102,19 +94,25 @@ module OpenRouter
       case response_format
       when Hash
         if response_format[:json_schema].is_a?(Schema)
-          response_format.merge(json_schema: response_format[:json_schema].to_h)
+          response_format.merge(json_schema: native_schema_hash(response_format[:json_schema]))
         else
           response_format
         end
       when Schema
-        { type: "json_schema", json_schema: response_format.to_h }
+        { type: "json_schema", json_schema: native_schema_hash(response_format) }
       else
         response_format
       end
     end
 
-    def inject_schema_instructions!(messages, response_format)
-      schema = extract_schema(response_format)
+    # Provider-side json_schema decoding requires every property in `required`.
+    # For strict schemas we emit the all-required-with-nullable-optionals form so
+    # the request doesn't 400; non-strict schemas are sent honestly.
+    def native_schema_hash(schema)
+      schema.strict ? schema.to_strict_h : schema.to_h
+    end
+
+    def inject_schema_instructions!(messages, schema)
       return unless schema
 
       instruction_content = if schema.respond_to?(:get_format_instructions)
@@ -126,18 +124,15 @@ module OpenRouter
       messages << { role: "system", content: instruction_content }
     end
 
+    # Pull the schema out of a response_format. Returns nil for a plain
+    # { type: "json_object" } directive (no schema to describe or validate).
     def extract_schema(response_format)
       case response_format
       when Schema
         response_format
       when Hash
-        if response_format[:json_schema].is_a?(Schema)
-          response_format[:json_schema]
-        elsif response_format[:json_schema].is_a?(Hash)
-          response_format[:json_schema]
-        else
-          response_format
-        end
+        json_schema = response_format[:json_schema] || response_format["json_schema"]
+        json_schema if json_schema.is_a?(Schema) || json_schema.is_a?(Hash)
       end
     end
 

data/lib/open_router/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenRouter
-  VERSION = "2.2.0"
+  VERSION = "2.3.0"
 end