open_router_enhanced 2.2.0 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b6c9c14171242103eaeab8219521180242f9e0ee0968c739f8db2148a17423a5
-  data.tar.gz: '0906f33ab027e8cbf17ff60ab120ec65de39ec689c6e9a48025fb8df679f7d55'
+  metadata.gz: 9f4936ab4591643976d7cf5f63b92fec61fef1fda2900ce6ed022ce35671bd3a
+  data.tar.gz: 1ac1e6ea82c9eacc1bc28e4b99490507bcf1f335446f3ab1cbab2a2ca8d749b4
 SHA512:
-  metadata.gz: 4cd127d4d6889e281e88e3f044f2444bd32e46f7ac4797d5c786b9a3fc5a8f792baf445c8dea481ab5018fae72646a221da05266bcb4134266735546e35a428d
-  data.tar.gz: a5b80c88d5f2228f1891409d2edb335a1a2c0294b94ffc69fb2730d0a854f7010c5eece8ac026eb6ba99a60df583634f42c77e18aada4b0399886b6a744a3488
+  metadata.gz: ef3a651dee0fec1b4d0508e88578c78ed1d259b5dc7c5fb5917d7af0690a2e69c12732f6fc5a0b423340da7afddbc4de80f08f8a27e616c9d7c15a1051508a39
+  data.tar.gz: 017ec8a29aeb205e396265409c8f9d53f3f7280d025543e89b2c95510d6b21fe78f230461dcc5291a433c1b60f850425ba754dcfc1ab32e98517b1f522688692

data/CHANGELOG.md

@@ -1,23 +1,5 @@
 ## [Unreleased]
 
-## [2.2.0] - 2026-06-28
-
-### 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
-
-- 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.
-
-### Notes
-
-- 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.
-
 ## [2.0.0] - 2025-12-28
 
 ### Overview

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    open_router_enhanced (2.2.0)
+    open_router_enhanced (2.2.1)
       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

@@ -30,24 +30,40 @@ module OpenRouter
 
     # Convert to the format expected by OpenRouter API
     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: openrouter_schema
+        schema: enforce_all_required(@schema)
       }
     end
 
+    # 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. Forcing this only at the top level
+    # makes nested objects come back with `required: []`, which strict providers
+    # reject with a 400. Walk the schema and enforce it recursively.
+    #
+    # (Optional fields are expressed in strict mode by adding "null" to the
+    # property's type union, not by omitting them from `required`.)
+    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"
+          transformed[key] = props.keys.map(&:to_s)
+        end
+
+        transformed
+      when Array
+        node.map { |element| enforce_all_required(element) }
+      else
+        node
+      end
+    end
+
     # Get the pure JSON Schema (respects required flags) for testing/validation
     def pure_schema
       @schema

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
-      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
+      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 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: } }
@@ -113,8 +105,7 @@ module OpenRouter
       end
     end
 
-    def inject_schema_instructions!(messages, response_format)
-      schema = extract_schema(response_format)
+    def inject_schema_instructions!(messages, schema)
       return unless schema
 
       instruction_content = if schema.respond_to?(:get_format_instructions)
@@ -126,18 +117,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.2.1"
 end

data/lib/open_router.rb

@@ -19,7 +19,6 @@ end
 require_relative "open_router/http"
 require_relative "open_router/completion_options"
 require_relative "open_router/tool"
-require_relative "open_router/subagent_tool"
 require_relative "open_router/tool_call_base"
 require_relative "open_router/tool_call"
 require_relative "open_router/schema"
@@ -31,7 +30,6 @@ require_relative "open_router/model_registry"
 require_relative "open_router/model_selector"
 require_relative "open_router/prompt_template"
 require_relative "open_router/usage_tracker"
-require_relative "open_router/routing"
 require_relative "open_router/client"
 require_relative "open_router/streaming_client"
 require_relative "open_router/version"
@@ -56,15 +54,11 @@ module OpenRouter
     # Capability validation configuration
     attr_accessor :strict_mode
 
-    # Automatic forcing configuration
-    attr_accessor :auto_force_on_unsupported_models
-
-    # Default structured output mode configuration
-    attr_accessor :default_structured_output_mode
-
-    # Optional logger. When set, gem warnings are routed through it (e.g. Rails.logger).
-    # When nil (default), warnings go to Kernel.warn → $stderr.
-    attr_accessor :logger
+    # Default validation strictness for structured outputs.
+    # false (default): best-effort, return parsed JSON as-is.
+    # true: raise StructuredOutputError when the response doesn't match the schema.
+    # Overridden per-call by the `strict:` option.
+    attr_accessor :structured_output_strict
 
     DEFAULT_API_VERSION = "v1"
     DEFAULT_REQUEST_TIMEOUT = 120
@@ -99,11 +93,8 @@ module OpenRouter
       # Capability validation defaults
       self.strict_mode = ENV.fetch("OPENROUTER_STRICT_MODE", "false").downcase == "true"
 
-      # Auto forcing defaults
-      self.auto_force_on_unsupported_models = ENV.fetch("OPENROUTER_AUTO_FORCE", "true").downcase == "true"
-
-      # Default structured output mode
-      self.default_structured_output_mode = ENV.fetch("OPENROUTER_DEFAULT_MODE", "strict").to_sym
+      # Default structured output validation strictness (loose/best-effort by default)
+      self.structured_output_strict = ENV.fetch("OPENROUTER_STRUCTURED_STRICT", "false").downcase == "true"
     end
 
     def access_token
@@ -136,12 +127,4 @@ module OpenRouter
   def self.configure
     yield(configuration)
   end
-
-  def self.log_warning(message)
-    if configuration.logger
-      configuration.logger.warn(message)
-    else
-      Kernel.warn(message)
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open_router_enhanced
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.1
 platform: ruby
 authors:
 - Eric Stiens
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-29 00:00:00.000000000 Z
+date: 2026-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -134,8 +134,6 @@ files:
 - docs/responses_api.md
 - docs/streaming.md
 - docs/structured_outputs.md
-- docs/superpowers/plans/2026-06-27-openrouter-routing-features.md
-- docs/superpowers/specs/2026-06-27-openrouter-routing-features-design.md
 - docs/tools.md
 - examples/basic_completion.rb
 - examples/dynamic_model_switching_example.rb
@@ -164,10 +162,8 @@ files:
 - lib/open_router/response_parsing.rb
 - lib/open_router/responses_response.rb
 - lib/open_router/responses_tool_call.rb
-- lib/open_router/routing.rb
 - lib/open_router/schema.rb
 - lib/open_router/streaming_client.rb
-- lib/open_router/subagent_tool.rb
 - lib/open_router/tool.rb
 - lib/open_router/tool_call.rb
 - lib/open_router/tool_call_base.rb