open_router_enhanced 1.2.5 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 006c0d9fe0bb456345df1e75db430cf54943d85f34c55a931cf3490aa7e8ad45
-  data.tar.gz: 15953a9890fa76b4d039ff40357e11407bbd03fe44d731926327e65a909e7b94
+  metadata.gz: 925d55d16a222d6a954c449307c480ab85bf3092138b172cd8a2561f40aeeba4
+  data.tar.gz: 7f427cb96bdd2a98c355096db04babb861a8bb2a13ab3f7f940c5397a9d4f651
 SHA512:
-  metadata.gz: 7048aec5f2abd698c35300fea40135c149ea90345c4e9897d14ac1114ba88a85b1b5ddcef77b3dfc1f01993c5dcb1dd922e011a3fb0162dfcdf1ab1b518de933
-  data.tar.gz: 859c1f7a15f59b11a530eb7eb460e36499782dda46eb76affdf74e63f474f9e40b56d24b4bea65fb6cb08b5438e0186f04b73aed99cf2dd6de2eeebc5a83691d
+  metadata.gz: c4cea4727bfa5df23b123e695cd95fe6106f6a57a5184e8b3af9f7c043e3198702ea433fc7d553220c3def45d1adc899b4e53ff4b7fa3ff4b005cf76a580c681
+  data.tar.gz: 9544496653c0716f7c704d10f7376e21e20bc4f98fe784114822640ffc957142e3fed056bcdc6d135e333010e2489910c44f7a445aa50ac3dc18eb9fe52bb4ee

data/CHANGELOG.md

@@ -1,5 +1,254 @@
 ## [Unreleased]
 
+## [2.0.0] - 2025-12-28
+
+### Overview
+
+Version 2.0.0 introduces the `CompletionOptions` class - a structured, self-documenting way to configure API requests. This replaces the previous pattern of 11+ keyword arguments with a clean, reusable options object.
+
+**This is a semver major release, but existing code will continue to work without modification.** The new patterns are opt-in and recommended for new code.
+
+---
+
+### Breaking Changes
+
+Method signatures now accept an optional `CompletionOptions` object as the second parameter:
+
+| Method | Old Signature | New Signature |
+|--------|---------------|---------------|
+| `complete` | `(messages, model:, tools:, ...)` | `(messages, options = nil, stream:, **kwargs)` |
+| `stream_complete` | `(messages, model:, ...)` | `(messages, options = nil, accumulate_response:, **kwargs, &block)` |
+| `stream` | `(messages, model:, ...)` | `(messages, options = nil, **kwargs, &block)` |
+| `responses` | `(input, model:, ...)` | `(input, options = nil, **kwargs)` |
+
+**Important**: The `options` parameter accepts `CompletionOptions`, `Hash`, or `nil`. All existing keyword argument patterns continue to work.
+
+---
+
+### Migration Guide
+
+#### No Changes Required (Backward Compatible)
+
+All existing code continues to work:
+
+```ruby
+# ✅ These all work exactly as before:
+client.complete(messages, model: "openai/gpt-4o")
+client.complete(messages, model: "openai/gpt-4o", temperature: 0.7)
+client.stream(messages, model: "openai/gpt-4o") { |chunk| print chunk }
+client.responses("Hello", model: "openai/gpt-4o", reasoning: { effort: "high" })
+```
+
+#### Recommended: Use CompletionOptions for New Code
+
+For new code, we recommend using `CompletionOptions` for better IDE support, documentation, and reusability:
+
+```ruby
+# Create reusable configuration
+opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  temperature: 0.7,
+  max_tokens: 1000
+)
+
+# Use across multiple calls
+response1 = client.complete(messages1, opts)
+response2 = client.complete(messages2, opts)
+
+# Override specific values without mutating original
+creative_opts = opts.merge(temperature: 1.2)
+response3 = client.complete(messages3, creative_opts)
+```
+
+#### Migrating Complex Configurations
+
+**Before (v1.x)**:
+```ruby
+client.complete(
+  messages,
+  model: "openai/gpt-4o",
+  tools: my_tools,
+  tool_choice: "auto",
+  temperature: 0.7,
+  max_tokens: 2000,
+  providers: ["openai", "azure"],
+  response_format: { type: "json_object" },
+  extras: { custom_param: "value" }
+)
+```
+
+**After (v2.0 - recommended)**:
+```ruby
+opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  tools: my_tools,
+  tool_choice: "auto",
+  temperature: 0.7,
+  max_tokens: 2000,
+  providers: ["openai", "azure"],
+  response_format: { type: "json_object" },
+  extras: { custom_param: "value" }
+)
+
+client.complete(messages, opts)
+```
+
+#### Migrating Streaming Code
+
+**Before (v1.x)**:
+```ruby
+client.stream_complete(
+  messages,
+  model: "openai/gpt-4o",
+  accumulate_response: true
+) do |chunk|
+  print chunk.dig("choices", 0, "delta", "content")
+end
+```
+
+**After (v2.0 - recommended)**:
+```ruby
+opts = OpenRouter::CompletionOptions.new(model: "openai/gpt-4o")
+
+client.stream_complete(messages, opts, accumulate_response: true) do |chunk|
+  print chunk.dig("choices", 0, "delta", "content")
+end
+
+# Or use the simpler stream method:
+client.stream(messages, opts) { |content| print content }
+```
+
+#### Pattern: Base Options with Per-Request Overrides
+
+```ruby
+# Define base configuration once
+BASE_OPTS = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  max_tokens: 1000,
+  providers: ["openai"]
+)
+
+# Override for specific use cases
+def generate_creative_content(prompt)
+  messages = [{ role: "user", content: prompt }]
+  client.complete(messages, BASE_OPTS, temperature: 1.2)
+end
+
+def generate_factual_content(prompt)
+  messages = [{ role: "user", content: prompt }]
+  client.complete(messages, BASE_OPTS, temperature: 0.1)
+end
+```
+
+---
+
+### Added
+
+#### `OpenRouter::CompletionOptions` Class
+
+A structured configuration object supporting **30+ parameters** organized by category:
+
+**Core Parameters**:
+- `model` - Model ID string or array for fallback routing
+- `tools` - Tool/function definitions
+- `tool_choice` - `"auto"`, `"none"`, `"required"`, or specific tool
+- `extras` - Hash for pass-through of any additional/future parameters
+
+**Sampling Parameters** (control response randomness):
+- `temperature` - 0.0-2.0, controls randomness (default varies by model)
+- `top_p` - 0.0-1.0, nucleus sampling threshold
+- `top_k` - Integer, limits token selection to top K
+- `frequency_penalty` - -2.0 to 2.0, penalize frequent tokens
+- `presence_penalty` - -2.0 to 2.0, penalize tokens already present
+- `repetition_penalty` - 0.0-2.0, general repetition penalty
+- `min_p` - 0.0-1.0, minimum probability threshold
+- `top_a` - 0.0-1.0, dynamic token filtering
+- `seed` - Integer for reproducible outputs
+
+**Output Control**:
+- `max_tokens` - Maximum tokens to generate (legacy)
+- `max_completion_tokens` - Maximum tokens (preferred, newer API)
+- `stop` - String or array of stop sequences
+- `logprobs` - Boolean, return log probabilities
+- `top_logprobs` - 0-20, number of top logprobs per token
+- `logit_bias` - Hash mapping token IDs to bias values (-100 to 100)
+- `response_format` - Structured output schema configuration
+- `parallel_tool_calls` - Boolean, allow parallel function calls
+- `verbosity` - `:low`, `:medium`, `:high`
+
+**OpenRouter Routing**:
+- `providers` - Array of provider names (becomes `provider.order`)
+- `provider` - Full provider config hash (overrides `providers`)
+- `transforms` - Array of transform identifiers
+- `plugins` - Array of plugin configs (`web-search`, `response-healing`, etc.)
+- `prediction` - Predicted output for latency optimization
+- `route` - `"fallback"` or `"sort"`
+- `metadata` - Custom key-value metadata
+- `user` - End-user identifier for tracking
+- `session_id` - Session grouping identifier (max 128 chars)
+
+**Responses API**:
+- `reasoning` - Hash with `effort:` key (`"minimal"`, `"low"`, `"medium"`, `"high"`)
+
+**Client-Side Options** (not sent to API):
+- `force_structured_output` - Override forced extraction mode behavior
+
+#### Helper Methods
+
+```ruby
+opts = CompletionOptions.new(model: "gpt-4", tools: [...])
+
+opts.has_tools?           # => true if tools are defined
+opts.has_response_format? # => true if response_format is set
+opts.fallback_models?     # => true if model is an array
+
+opts.to_h                 # => Hash of all non-nil, non-empty values
+opts.to_api_params        # => Hash for API request (excludes client-side params)
+opts.merge(temp: 0.5)     # => New CompletionOptions with override
+```
+
+---
+
+### Backward Compatibility
+
+**All existing patterns continue to work**:
+
+```ruby
+# Direct kwargs (unchanged from v1.x)
+client.complete(messages, model: "gpt-4")
+
+# Hash as second argument
+client.complete(messages, { model: "gpt-4", temperature: 0.7 })
+
+# CompletionOptions object (new in v2.0)
+opts = CompletionOptions.new(model: "gpt-4")
+client.complete(messages, opts)
+
+# Options with kwargs overrides (new in v2.0)
+client.complete(messages, opts, temperature: 0.9)
+```
+
+The `normalize_options` helper transparently handles all input styles.
+
+---
+
+### Internal Improvements
+
+- New `normalize_options` private helper for flexible input handling
+- Refactored `prepare_base_parameters` to accept `CompletionOptions`
+- Refactored `configure_tools_and_structured_outputs!` to use `CompletionOptions`
+- Added focused parameter helpers:
+  - `configure_sampling_parameters!`
+  - `configure_output_parameters!`
+  - `configure_routing_parameters!`
+- Improved separation of concerns in request building
+
+---
+
+### Bug Fixes
+
+- Fixed issue where `extras` hash contents were nested incorrectly in API requests. Parameters like `max_tokens` passed via `extras` now correctly appear at the top level of the request body.
+
 ## [1.2.2] - 2025-12-25
 
 ### Fixed

data/Gemfile.lock

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

data/README.md

@@ -198,6 +198,89 @@ end
 
 **[Full configuration documentation](docs/configuration.md)**
 
+## CompletionOptions
+
+For complex requests with many parameters, use `CompletionOptions` to organize your configuration:
+
+```ruby
+# Create reusable options
+opts = OpenRouter::CompletionOptions.new(
+  model: "anthropic/claude-3.5-sonnet",
+  temperature: 0.7,
+  max_tokens: 1000,
+  tools: [weather_tool],
+  providers: ["anthropic"]
+)
+
+# Use with complete()
+response = client.complete(messages, opts)
+
+# Override specific values
+response = client.complete(messages, opts, temperature: 0.9)
+
+# All these styles work (backward compatible):
+client.complete(messages, model: "gpt-4")                    # kwargs
+client.complete(messages, { model: "gpt-4" })                 # hash
+client.complete(messages, opts)                              # options object
+client.complete(messages, opts, temperature: 0.5)            # options + override
+```
+
+### Available Parameters
+
+```ruby
+OpenRouter::CompletionOptions.new(
+  # Model selection
+  model: "gpt-4",                      # Model ID or array for fallback
+  route: "fallback",                   # Routing strategy
+
+  # Sampling parameters
+  temperature: 0.7,                    # 0.0-2.0
+  top_p: 0.9,                         # Nucleus sampling
+  top_k: 50,                          # Top-K sampling
+  frequency_penalty: 0.5,             # -2.0 to 2.0
+  presence_penalty: 0.3,              # -2.0 to 2.0
+  repetition_penalty: 1.1,            # 0.0-2.0
+  min_p: 0.05,                        # Minimum probability
+  top_a: 0.1,                         # Dynamic filtering
+  seed: 42,                           # Reproducibility
+
+  # Output control
+  max_tokens: 1000,                   # Max completion tokens
+  max_completion_tokens: 1000,        # Preferred over max_tokens
+  stop: ["\n", "END"],                # Stop sequences
+  logprobs: true,                     # Return log probabilities
+  top_logprobs: 5,                    # Number of top logprobs
+  logit_bias: { "50256" => -100 },    # Token biasing
+  response_format: schema,            # Structured output
+  parallel_tool_calls: true,          # Allow parallel calls
+
+  # Tools
+  tools: [weather_tool],              # Tool definitions
+  tool_choice: "auto",                # auto, none, required, or specific
+
+  # OpenRouter routing
+  providers: ["anthropic", "openai"], # Simple provider ordering
+  provider: {                         # Full provider config
+    order: ["anthropic"],
+    quantizations: ["fp16"],
+    allow_fallbacks: true
+  },
+  transforms: ["middle-out"],         # Message transforms
+  plugins: [{ id: "web-search" }],    # OpenRouter plugins
+  prediction: { type: "content", content: "..." }, # Latency optimization
+  metadata: { request_id: "abc123" }, # Custom metadata
+  user: "user_123",                   # User identifier
+  session_id: "session_456",          # Session grouping
+
+  # Responses API
+  reasoning: { effort: "high" },      # For reasoning models
+
+  # Client-side
+  force_structured_output: true,      # Force schema injection
+  extras: { custom_param: "value" }   # Pass-through params
+)
+```
+
 ## Features
 
 ### Tool Calling

data/docs/model_selection.md

@@ -15,6 +15,36 @@ model = OpenRouter::ModelSelector.new
 response = client.complete(messages, model: model, tools: tools)
 ```
 
+## Using CompletionOptions with Model Selection (v2.0+)
+
+Combine model selection with `CompletionOptions` for powerful, reusable configurations:
+
+```ruby
+# Select model dynamically
+model = OpenRouter::ModelSelector.new
+                                 .require(:function_calling, :structured_outputs)
+                                 .optimize_for(:cost)
+                                 .choose
+
+# Create reusable options with the selected model
+opts = OpenRouter::CompletionOptions.new(
+  model: model,
+  tools: my_tools,
+  max_tokens: 1000
+)
+
+# Use across multiple calls
+response = client.complete(messages, opts)
+
+# Or use fallback model arrays directly in options
+fallback_opts = OpenRouter::CompletionOptions.new(
+  model: ["anthropic/claude-3.5-sonnet", "openai/gpt-4o", "google/gemini-pro"],
+  route: "fallback"
+)
+```
+
+All keyword argument patterns continue to work for backward compatibility.
+
 ## ModelSelector API
 
 The `ModelSelector` class provides a fluent interface for building complex model selection criteria.

data/docs/plugins.md

@@ -31,6 +31,40 @@ response = client.complete(
 )
 ```
 
+## Using CompletionOptions with Plugins (v2.0+)
+
+For cleaner, reusable configurations, use the `CompletionOptions` class:
+
+```ruby
+# Create reusable plugin configuration
+web_search_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o-mini",
+  plugins: [{ id: "web-search" }]
+)
+
+# Use across multiple calls
+response = client.complete(messages, web_search_opts)
+
+# Combine multiple plugins with other options
+research_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  plugins: [
+    { id: "web-search" },
+    { id: "pdf-inputs" }
+  ],
+  max_tokens: 2000,
+  temperature: 0.3
+)
+
+# Add prediction for latency optimization
+fast_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  prediction: { type: "content", content: "The answer is..." }
+)
+```
+
+All keyword argument patterns continue to work for backward compatibility.
+
 ## Response Healing Plugin
 
 The response-healing plugin fixes common JSON formatting issues server-side:

data/docs/responses_api.md

@@ -17,6 +17,40 @@ response = client.responses(
 puts response.content  # => "Paris"
 ```
 
+## Using CompletionOptions (v2.0+)
+
+For cleaner, reusable configurations, use the `CompletionOptions` class:
+
+```ruby
+# Create reusable reasoning configuration
+reasoning_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/o4-mini",
+  reasoning: { effort: "high" },
+  max_tokens: 1000
+)
+
+# Use with responses
+response = client.responses("Explain quantum entanglement", reasoning_opts)
+
+# Override specific values per-request
+response = client.responses(
+  "What is 15% of 80?",
+  reasoning_opts,
+  reasoning: { effort: "low" }  # Simpler problem, less reasoning needed
+)
+
+# Create tool-enabled responses configuration
+tool_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o-mini",
+  tools: [weather_tool, calculator_tool],
+  tool_choice: "auto"
+)
+
+response = client.responses("What's the weather in Tokyo?", tool_opts)
+```
+
+All keyword argument patterns continue to work for backward compatibility.
+
 ## With Reasoning
 
 The Responses API supports reasoning with configurable effort levels:

data/docs/streaming.md

@@ -22,6 +22,38 @@ response = streaming_client.stream_complete(
 puts response.content  # Complete response after streaming
 ```
 
+## Using CompletionOptions (v2.0+)
+
+For cleaner, reusable configurations, use the `CompletionOptions` class:
+
+```ruby
+# Create reusable streaming configuration
+stream_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o-mini",
+  temperature: 0.8,
+  max_tokens: 2000
+)
+
+# Use with stream_complete
+response = streaming_client.stream_complete(
+  messages,
+  stream_opts,
+  accumulate_response: true
+)
+
+# Use with simple stream method
+streaming_client.stream(messages, stream_opts) do |chunk|
+  print chunk
+end
+
+# Override specific values per-request
+streaming_client.stream(messages, stream_opts, temperature: 0.2) do |chunk|
+  print chunk
+end
+```
+
+All keyword argument patterns continue to work for backward compatibility.
+
 ## Streaming with Callbacks
 
 The streaming client supports extensive callback events for monitoring and custom processing.

data/docs/structured_outputs.md

@@ -35,6 +35,37 @@ puts user["age"]     # => 30
 puts user["email"]   # => "john@example.com"
 ```
 
+## Using CompletionOptions (v2.0+)
+
+For cleaner, reusable configurations, use the `CompletionOptions` class:
+
+```ruby
+# Create reusable structured output configuration
+struct_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  response_format: user_schema,
+  max_tokens: 500,
+  temperature: 0.1  # Lower temperature for more deterministic outputs
+)
+
+# Use across multiple calls
+response1 = client.complete(messages1, struct_opts)
+response2 = client.complete(messages2, struct_opts)
+
+# Override for specific requests
+creative_opts = struct_opts.merge(temperature: 0.8)
+response3 = client.complete(messages3, creative_opts)
+
+# Control forced structured output behavior
+opts_with_force = OpenRouter::CompletionOptions.new(
+  model: "some-model",
+  response_format: schema,
+  force_structured_output: true  # Override auto-detection
+)
+```
+
+All keyword argument patterns continue to work for backward compatibility.
+
 ## Key Concepts: JSON Content vs Structured Outputs
 
 **Important: These are fundamentally different features.**

data/docs/tools.md

@@ -9,7 +9,7 @@ The OpenRouter gem provides comprehensive support for OpenRouter's function call
 weather_tool = OpenRouter::Tool.define do
   name "get_weather"
   description "Get current weather for a location"
-  
+
   parameters do
     string :location, required: true, description: "City name or coordinates"
     string :units, enum: ["celsius", "fahrenheit"], description: "Temperature units"
@@ -23,6 +23,37 @@ response = client.complete(
   tools: [weather_tool],
   tool_choice: "auto"
 )
+```
+
+## Using CompletionOptions (v2.0+)
+
+For cleaner, reusable configurations, use the `CompletionOptions` class:
+
+```ruby
+# Create reusable tool configuration
+tool_opts = OpenRouter::CompletionOptions.new(
+  model: "anthropic/claude-3.5-sonnet",
+  tools: [weather_tool, calculator_tool],
+  tool_choice: "auto",
+  max_tokens: 1000
+)
+
+# Use with complete
+response = client.complete(messages, tool_opts)
+
+# Override tool_choice per request
+response = client.complete(messages, tool_opts, tool_choice: "required")
+
+# Configure parallel tool calling
+parallel_opts = OpenRouter::CompletionOptions.new(
+  model: "openai/gpt-4o",
+  tools: tools,
+  tool_choice: "auto",
+  parallel_tool_calls: true  # Allow multiple tool calls simultaneously
+)
+```
+
+All keyword argument patterns continue to work for backward compatibility.
 
 # Handle tool calls
 if response.has_tool_calls?

data/lib/open_router/client.rb

@@ -4,7 +4,6 @@ require "active_support/core_ext/object/blank"
 require "active_support/core_ext/hash/indifferent_access"
 
 require_relative "http"
-require "pry"
 
 module OpenRouter
   class ServerError < StandardError; end
@@ -92,27 +91,31 @@ module OpenRouter
     end
 
     # Performs a chat completion request to the OpenRouter API.
-    # @param messages [Array<Hash>] Array of message hashes with role and content, like [{role: "user", content: "What is the meaning of life?"}]
-    # @param model [String|Array] Model identifier, or array of model identifiers if you want to fallback to the next model in case of failure
-    # @param providers [Array<String>] Optional array of provider identifiers, ordered by priority
-    # @param transforms [Array<String>] Optional array of strings that tell OpenRouter to apply a series of transformations to the prompt before sending it to the model. Transformations are applied in-order
-    # @param plugins [Array<Hash>] Optional array of plugin hashes like [{id: "response-healing"}]. Available plugins: response-healing, web-search, pdf-inputs
-    # @param tools [Array<Tool>] Optional array of Tool objects or tool definition hashes for function calling
-    # @param tool_choice [String|Hash] Optional tool choice: "auto", "none", "required", or specific tool selection
-    # @param response_format [Hash] Optional response format for structured outputs
-    # @param prediction [Hash] Optional predicted output for latency reduction, e.g. {type: "content", content: "predicted text"}
-    # @param extras [Hash] Optional hash of model-specific parameters to send to the OpenRouter API
+    #
+    # @param messages [Array<Hash>] Array of message hashes with role and content
+    # @param options [CompletionOptions, Hash, nil] Options object or hash with configuration
     # @param stream [Proc, nil] Optional callable object for streaming
-    # @return [Response] The completion response wrapped in a Response object.
-    # rubocop:disable Metrics/ParameterLists
-    def complete(messages, model: "openrouter/auto", providers: [], transforms: [], plugins: [], tools: [], tool_choice: nil,
-                 response_format: nil, force_structured_output: nil, prediction: nil, extras: {}, stream: nil)
-      # rubocop:enable Metrics/ParameterLists
-      parameters = prepare_base_parameters(messages, model, providers, transforms, plugins, prediction, stream, extras)
-      forced_extraction = configure_tools_and_structured_outputs!(parameters, model, tools, tool_choice,
-                                                                  response_format, force_structured_output)
-      configure_plugins!(parameters, response_format, stream)
-      validate_vision_support(model, messages)
+    # @param kwargs [Hash] Additional options (merged with options parameter)
+    # @return [Response] The completion response wrapped in a Response object
+    #
+    # @example Simple usage (unchanged)
+    #   client.complete(messages, model: "gpt-4")
+    #
+    # @example With CompletionOptions
+    #   opts = CompletionOptions.new(model: "gpt-4", temperature: 0.7, tools: my_tools)
+    #   client.complete(messages, opts)
+    #
+    # @example Hash options
+    #   client.complete(messages, { model: "gpt-4", temperature: 0.7 })
+    #
+    # @example Options with override
+    #   client.complete(messages, base_opts, temperature: 0.9)
+    def complete(messages, options = nil, stream: nil, **kwargs)
+      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)
+      validate_vision_support(opts.model, messages)
 
       # Trigger before_request callbacks
       trigger_callbacks(:before_request, parameters)
@@ -120,10 +123,11 @@ module OpenRouter
       raw_response = execute_request(parameters)
       validate_response!(raw_response, stream)
 
-      response = build_response(raw_response, response_format, forced_extraction)
+      response = build_response(raw_response, opts.response_format, forced_extraction)
 
       # Track usage if enabled
-      @usage_tracker&.track(response, model: model.is_a?(String) ? model : model.first)
+      model_for_tracking = opts.model.is_a?(String) ? opts.model : opts.model.first
+      @usage_tracker&.track(response, model: model_for_tracking)
 
       # Trigger after_response callbacks
       trigger_callbacks(:after_response, response)
@@ -152,39 +156,42 @@ module OpenRouter
     # This is an OpenAI-compatible stateless API with support for reasoning.
     #
     # @param input [String, Array] The input text or structured message array
-    # @param model [String] Model identifier (e.g., "openai/o4-mini")
-    # @param reasoning [Hash, nil] Optional reasoning config, e.g. {effort: "high"}
-    #   Effort levels: "minimal", "low", "medium", "high"
-    # @param tools [Array<Tool, Hash>] Optional array of tool definitions
-    # @param tool_choice [String, Hash, nil] Optional: "auto", "none", "required", or specific tool
-    # @param max_output_tokens [Integer, nil] Maximum tokens to generate
-    # @param temperature [Float, nil] Sampling temperature (0-2)
-    # @param top_p [Float, nil] Nucleus sampling parameter (0-1)
-    # @param extras [Hash] Additional parameters to pass to the API
+    # @param options [CompletionOptions, Hash, nil] Options object or hash with configuration
+    # @param kwargs [Hash] Additional options (merged with options parameter)
     # @return [ResponsesResponse] The response wrapped in a ResponsesResponse object
     #
     # @example Basic usage
     #   response = client.responses("What is 2+2?", model: "openai/o4-mini")
     #   puts response.content
     #
-    # @example With reasoning
-    #   response = client.responses(
-    #     "Solve this step by step: What is 15% of 80?",
+    # @example With reasoning using CompletionOptions
+    #   opts = CompletionOptions.new(
     #     model: "openai/o4-mini",
     #     reasoning: { effort: "high" }
     #   )
+    #   response = client.responses("Solve this step by step: What is 15% of 80?", opts)
     #   puts response.reasoning_summary
     #   puts response.content
-    def responses(input, model:, reasoning: nil, tools: [], tool_choice: nil,
-                  max_output_tokens: nil, temperature: nil, top_p: nil, extras: {})
-      parameters = { model: model, input: input }
-      parameters[:reasoning] = reasoning if reasoning
-      parameters[:tools] = serialize_tools_for_responses(tools) if tools.any?
-      parameters[:tool_choice] = tool_choice if tool_choice
-      parameters[:max_output_tokens] = max_output_tokens if max_output_tokens
-      parameters[:temperature] = temperature if temperature
-      parameters[:top_p] = top_p if top_p
-      parameters.merge!(extras)
+    #
+    # @example With kwargs (still works)
+    #   response = client.responses("Question", model: "openai/o4-mini", reasoning: { effort: "high" })
+    def responses(input, options = nil, **kwargs)
+      opts = normalize_options(options, kwargs)
+
+      # Model is required for Responses API
+      if opts.model == "openrouter/auto"
+        raise ArgumentError, "model is required for responses API (cannot use default 'openrouter/auto')"
+      end
+
+      parameters = { model: opts.model, input: input }
+      parameters[:reasoning] = opts.reasoning if opts.reasoning
+      parameters[:tools] = serialize_tools_for_responses(opts.tools) if opts.has_tools?
+      parameters[:tool_choice] = opts.tool_choice if opts.tool_choice
+      # Prefer max_completion_tokens over max_tokens (consistent with complete() method)
+      parameters[:max_output_tokens] = opts.max_completion_tokens || opts.max_tokens if opts.max_completion_tokens || opts.max_tokens
+      parameters[:temperature] = opts.temperature if opts.temperature
+      parameters[:top_p] = opts.top_p if opts.top_p
+      parameters.merge!(opts.extras || {})
 
       raw = post(path: "/responses", parameters: parameters)
       ResponsesResponse.new(raw)
@@ -314,18 +321,47 @@ module OpenRouter
 
     private
 
+    # Normalize options from various input formats into CompletionOptions
+    #
+    # @param options [CompletionOptions, Hash, nil] Options object or hash
+    # @param kwargs [Hash] Additional keyword arguments
+    # @return [CompletionOptions] Normalized options object
+    def normalize_options(options, kwargs)
+      case options
+      when CompletionOptions
+        kwargs.empty? ? options : options.merge(**kwargs)
+      when Hash
+        # Symbolize keys to handle both string and symbol key hashes
+        symbolized = options.transform_keys(&:to_sym)
+        CompletionOptions.new(**symbolized.merge(kwargs))
+      when nil
+        CompletionOptions.new(**kwargs)
+      else
+        raise ArgumentError, "options must be CompletionOptions, Hash, or nil"
+      end
+    end
+
     # Prepare the base parameters for the API request
-    def prepare_base_parameters(messages, model, providers, transforms, plugins, prediction, stream, extras)
+    #
+    # @param messages [Array<Hash>] Array of message hashes
+    # @param opts [CompletionOptions] Normalized options object
+    # @param stream [Proc, nil] Optional streaming handler
+    # @return [Hash] Parameters hash for the API request
+    def prepare_base_parameters(messages, opts, stream)
       parameters = { messages: messages.dup }
 
-      configure_model_parameter!(parameters, model)
-      configure_provider_parameter!(parameters, providers)
-      configure_transforms_parameter!(parameters, transforms)
-      configure_plugins_parameter!(parameters, plugins)
-      configure_prediction_parameter!(parameters, prediction)
+      configure_model_parameter!(parameters, opts.model)
+      configure_provider_parameter!(parameters, opts)
+      configure_transforms_parameter!(parameters, opts.transforms)
+      configure_plugins_parameter!(parameters, opts.plugins)
+      configure_prediction_parameter!(parameters, opts.prediction)
       configure_stream_parameter!(parameters, stream)
+      configure_sampling_parameters!(parameters, opts)
+      configure_output_parameters!(parameters, opts)
+      configure_routing_parameters!(parameters, opts)
 
-      parameters.merge!(extras)
+      # Merge any extras last (allows overriding anything)
+      parameters.merge!(opts.extras || {})
       parameters
     end
 
@@ -339,9 +375,66 @@ module OpenRouter
       end
     end
 
-    # Configure the provider parameter if providers are specified
-    def configure_provider_parameter!(parameters, providers)
-      parameters[:provider] = { order: providers } if providers.any?
+    # Configure the provider parameter from options
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    def configure_provider_parameter!(parameters, opts)
+      # Full provider config takes precedence over simple providers array
+      if opts.provider && !opts.provider.empty?
+        parameters[:provider] = opts.provider
+      elsif opts.providers.any?
+        parameters[:provider] = { order: opts.providers }
+      end
+
+      # Route parameter for fallback models
+      parameters[:route] = opts.route if opts.route
+    end
+
+    # Configure sampling parameters (temperature, top_p, etc.)
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    def configure_sampling_parameters!(parameters, opts)
+      parameters[:temperature] = opts.temperature if opts.temperature
+      parameters[:top_p] = opts.top_p if opts.top_p
+      parameters[:top_k] = opts.top_k if opts.top_k
+      parameters[:frequency_penalty] = opts.frequency_penalty if opts.frequency_penalty
+      parameters[:presence_penalty] = opts.presence_penalty if opts.presence_penalty
+      parameters[:repetition_penalty] = opts.repetition_penalty if opts.repetition_penalty
+      parameters[:min_p] = opts.min_p if opts.min_p
+      parameters[:top_a] = opts.top_a if opts.top_a
+      parameters[:seed] = opts.seed if opts.seed
+    end
+
+    # Configure output control parameters
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    def configure_output_parameters!(parameters, opts)
+      # Prefer max_completion_tokens over max_tokens if both are set
+      if opts.max_completion_tokens
+        parameters[:max_completion_tokens] = opts.max_completion_tokens
+      elsif opts.max_tokens
+        parameters[:max_tokens] = opts.max_tokens
+      end
+
+      parameters[:stop] = opts.stop if opts.stop
+      parameters[:logprobs] = opts.logprobs unless opts.logprobs.nil?
+      parameters[:top_logprobs] = opts.top_logprobs if opts.top_logprobs
+      parameters[:logit_bias] = opts.logit_bias if opts.logit_bias && !opts.logit_bias.empty?
+      parameters[:parallel_tool_calls] = opts.parallel_tool_calls unless opts.parallel_tool_calls.nil?
+      parameters[:verbosity] = opts.verbosity if opts.verbosity
+    end
+
+    # Configure OpenRouter-specific routing parameters
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    def configure_routing_parameters!(parameters, opts)
+      parameters[:metadata] = opts.metadata if opts.metadata && !opts.metadata.empty?
+      parameters[:user] = opts.user if opts.user
+      parameters[:session_id] = opts.session_id if opts.session_id
     end
 
     # Configure the transforms parameter if transforms are specified
@@ -396,32 +489,42 @@ module OpenRouter
     end
 
     # Configure tools and structured outputs, returning forced_extraction flag
-    def configure_tools_and_structured_outputs!(parameters, model, tools, tool_choice, response_format,
-                                                force_structured_output)
-      configure_tool_calling!(parameters, model, tools, tool_choice)
-      configure_structured_outputs!(parameters, model, response_format, force_structured_output)
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    # @return [Boolean] Whether forced extraction mode is being used
+    def configure_tools_and_structured_outputs!(parameters, opts)
+      configure_tool_calling!(parameters, opts)
+      configure_structured_outputs!(parameters, opts)
     end
 
     # Configure tool calling support
-    def configure_tool_calling!(parameters, model, tools, tool_choice)
-      return unless tools.any?
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    def configure_tool_calling!(parameters, opts)
+      return unless opts.has_tools?
 
-      warn_if_unsupported(model, :function_calling, "tool calling")
-      parameters[:tools] = serialize_tools(tools)
-      parameters[:tool_choice] = tool_choice if tool_choice
+      warn_if_unsupported(opts.model, :function_calling, "tool calling")
+      parameters[:tools] = serialize_tools(opts.tools)
+      parameters[:tool_choice] = opts.tool_choice if opts.tool_choice
     end
 
     # Configure structured output support and return forced_extraction flag
-    def configure_structured_outputs!(parameters, model, response_format, force_structured_output)
-      return false unless response_format
+    #
+    # @param parameters [Hash] Request parameters hash
+    # @param opts [CompletionOptions] Options object
+    # @return [Boolean] Whether forced extraction mode is being used
+    def configure_structured_outputs!(parameters, opts)
+      return false unless opts.has_response_format?
 
-      force_structured_output = determine_forced_extraction_mode(model, force_structured_output)
+      force_extraction = determine_forced_extraction_mode(opts.model, opts.force_structured_output)
 
-      if force_structured_output
-        handle_forced_structured_output!(parameters, model, response_format)
+      if force_extraction
+        handle_forced_structured_output!(parameters, opts.model, opts.response_format)
         true
       else
-        handle_native_structured_output!(parameters, model, response_format)
+        handle_native_structured_output!(parameters, opts.model, opts.response_format)
         false
       end
     end

data/lib/open_router/completion_options.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+module OpenRouter
+  # CompletionOptions provides a structured way to configure API requests.
+  #
+  # Supports all OpenRouter API parameters plus client-side options.
+  # Can be used with complete(), stream_complete(), and responses() methods.
+  #
+  # @example Simple usage with kwargs (unchanged)
+  #   client.complete(messages, model: "gpt-4")
+  #
+  # @example Using CompletionOptions for complex requests
+  #   options = OpenRouter::CompletionOptions.new(
+  #     model: "anthropic/claude-3.5-sonnet",
+  #     temperature: 0.7,
+  #     tools: [weather_tool],
+  #     providers: ["anthropic"]
+  #   )
+  #   client.complete(messages, options)
+  #
+  # @example Merging options with overrides
+  #   base_opts = CompletionOptions.new(model: "gpt-4", temperature: 0.5)
+  #   client.complete(messages, base_opts, temperature: 0.9)  # overrides temperature
+  #
+  class CompletionOptions
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Common params (used by both Complete and Responses APIs)
+    # ═══════════════════════════════════════════════════════════════════════════
+
+    # @return [String, Array<String>] Model ID or array for fallback routing
+    attr_accessor :model
+
+    # @return [Array<Tool, Hash>] Tool/function definitions for function calling
+    attr_accessor :tools
+
+    # @return [String, Hash, nil] Tool selection: "auto", "none", "required", or specific
+    attr_accessor :tool_choice
+
+    # @return [Hash] Pass-through for any additional/future API params
+    attr_accessor :extras
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Sampling parameters (OpenRouter passes these to underlying models)
+    # ═══════════════════════════════════════════════════════════════════════════
+
+    # @return [Float, nil] Sampling temperature (0.0-2.0, default 1.0)
+    attr_accessor :temperature
+
+    # @return [Float, nil] Nucleus sampling (0.0-1.0)
+    attr_accessor :top_p
+
+    # @return [Integer, nil] Limits token selection to top K options
+    attr_accessor :top_k
+
+    # @return [Float, nil] Frequency penalty (-2.0 to 2.0)
+    attr_accessor :frequency_penalty
+
+    # @return [Float, nil] Presence penalty (-2.0 to 2.0)
+    attr_accessor :presence_penalty
+
+    # @return [Float, nil] Repetition penalty (0.0-2.0)
+    attr_accessor :repetition_penalty
+
+    # @return [Float, nil] Minimum probability threshold (0.0-1.0)
+    attr_accessor :min_p
+
+    # @return [Float, nil] Dynamic filtering based on confidence (0.0-1.0)
+    attr_accessor :top_a
+
+    # @return [Integer, nil] Random seed for reproducibility
+    attr_accessor :seed
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Output control
+    # ═══════════════════════════════════════════════════════════════════════════
+
+    # @return [Integer, nil] Legacy max tokens limit
+    attr_accessor :max_tokens
+
+    # @return [Integer, nil] Preferred max completion tokens limit
+    attr_accessor :max_completion_tokens
+
+    # @return [String, Array<String>, nil] Stop sequences
+    attr_accessor :stop
+
+    # @return [Boolean, nil] Return log probabilities of output tokens
+    attr_accessor :logprobs
+
+    # @return [Integer, nil] Number of top logprobs to return (0-20)
+    attr_accessor :top_logprobs
+
+    # @return [Hash, nil] Token ID to bias mapping (-100 to 100)
+    attr_accessor :logit_bias
+
+    # @return [Hash, Schema, nil] Structured output schema/format
+    attr_accessor :response_format
+
+    # @return [Boolean, nil] Allow parallel tool calls
+    attr_accessor :parallel_tool_calls
+
+    # @return [Symbol, String, nil] Output verbosity (:low, :medium, :high)
+    attr_accessor :verbosity
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    # OpenRouter-specific routing & features
+    # ═══════════════════════════════════════════════════════════════════════════
+
+    # @return [Array<String>] Simple provider ordering (becomes provider.order)
+    attr_accessor :providers
+
+    # @return [Hash, nil] Full provider config (overrides :providers if set)
+    #   Supports: order, only, ignore, allow_fallbacks, require_parameters,
+    #   data_collection, zdr, quantizations, sort, max_price, etc.
+    attr_accessor :provider
+
+    # @return [Array<String>] Transform identifiers (e.g., ["middle-out"])
+    attr_accessor :transforms
+
+    # @return [Array<Hash>] Plugin configurations
+    attr_accessor :plugins
+
+    # @return [Hash, nil] Predicted output for latency reduction
+    #   Format: { type: "content", content: "predicted text" }
+    attr_accessor :prediction
+
+    # @return [String, nil] Routing strategy: "fallback" or "sort"
+    attr_accessor :route
+
+    # @return [Hash, nil] Custom key-value metadata
+    attr_accessor :metadata
+
+    # @return [String, nil] End-user identifier for tracking
+    attr_accessor :user
+
+    # @return [String, nil] Session grouping identifier (max 128 chars)
+    attr_accessor :session_id
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    # Responses API specific
+    # ═══════════════════════════════════════════════════════════════════════════
+
+    # @return [Hash, nil] Reasoning configuration for Responses API
+    #   Format: { effort: "minimal"|"low"|"medium"|"high" }
+    attr_accessor :reasoning
+
+    # ═══════════════════════════════════════════════════════════════════════════
+    # 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
+
+    # All supported parameters with their defaults
+    DEFAULTS = {
+      # Common
+      model: "openrouter/auto",
+      tools: [],
+      tool_choice: nil,
+      extras: {},
+      # Sampling
+      temperature: nil,
+      top_p: nil,
+      top_k: nil,
+      frequency_penalty: nil,
+      presence_penalty: nil,
+      repetition_penalty: nil,
+      min_p: nil,
+      top_a: nil,
+      seed: nil,
+      # Output
+      max_tokens: nil,
+      max_completion_tokens: nil,
+      stop: nil,
+      logprobs: nil,
+      top_logprobs: nil,
+      logit_bias: nil,
+      response_format: nil,
+      parallel_tool_calls: nil,
+      verbosity: nil,
+      # OpenRouter routing
+      providers: [],
+      provider: nil,
+      transforms: [],
+      plugins: [],
+      prediction: nil,
+      route: nil,
+      metadata: nil,
+      user: nil,
+      session_id: nil,
+      # Responses API
+      reasoning: nil,
+      # Client-side
+      force_structured_output: nil
+    }.freeze
+
+    # Parameters that are client-side only (not sent to API)
+    CLIENT_SIDE_PARAMS = %i[force_structured_output extras].freeze
+
+    # Initialize with keyword arguments
+    #
+    # @param attrs [Hash] Parameter values (see DEFAULTS for available keys)
+    def initialize(**attrs)
+      DEFAULTS.each do |key, default|
+        value = attrs.key?(key) ? attrs[key] : default
+        # Deep dup arrays/hashes to prevent mutation of shared defaults
+        value = value.dup if value.is_a?(Array) || value.is_a?(Hash)
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+
+    # Convert to hash, excluding nil values and empty collections
+    #
+    # @return [Hash] Non-empty parameter values
+    def to_h
+      DEFAULTS.keys.each_with_object({}) do |key, hash|
+        value = instance_variable_get(:"@#{key}")
+        next if value.nil?
+        next if value.respond_to?(:empty?) && value.empty?
+
+        hash[key] = value
+      end
+    end
+
+    # Create a new CompletionOptions with merged overrides
+    #
+    # @param overrides [Hash] Values to override
+    # @return [CompletionOptions] New instance with merged values
+    def merge(**overrides)
+      self.class.new(**to_h.merge(overrides))
+    end
+
+    # Build API request parameters hash
+    # Excludes client-side-only options and merges extras
+    #
+    # @return [Hash] Parameters ready for API request
+    def to_api_params
+      api_params = to_h.reject { |key, _| CLIENT_SIDE_PARAMS.include?(key) }
+      api_params.merge(extras || {})
+    end
+
+    # Check if this options object has any tools defined
+    #
+    # @return [Boolean]
+    def has_tools?
+      tools.is_a?(Array) && !tools.empty?
+    end
+
+    # Check if response format is configured
+    #
+    # @return [Boolean]
+    def has_response_format?
+      !response_format.nil?
+    end
+
+    # Check if using model fallback (array of models)
+    #
+    # @return [Boolean]
+    def fallback_models?
+      model.is_a?(Array)
+    end
+  end
+end

data/lib/open_router/streaming_client.rb

@@ -33,24 +33,34 @@ module OpenRouter
     # Enhanced streaming completion with better event handling and response reconstruction
     #
     # @param messages [Array<Hash>] Array of message hashes
-    # @param model [String|Array] Model identifier or array of models for fallback
+    # @param options [CompletionOptions, Hash, nil] Options object or hash with configuration
     # @param accumulate_response [Boolean] Whether to accumulate and return complete response
-    # @param extras [Hash] Additional parameters for the completion request
+    # @param kwargs [Hash] Additional options (merged with options parameter)
     # @param block [Proc] Optional block to call for each chunk (in addition to registered callbacks)
     # @return [Response, nil] Complete response if accumulate_response is true, nil otherwise
-    def stream_complete(messages, model: "openrouter/auto", accumulate_response: true, **extras, &block)
+    #
+    # @example Simple usage (unchanged)
+    #   client.stream_complete(messages, model: "gpt-4")
+    #
+    # @example With CompletionOptions
+    #   opts = CompletionOptions.new(model: "gpt-4", temperature: 0.7)
+    #   client.stream_complete(messages, opts)
+    #
+    # @example Options with overrides
+    #   client.stream_complete(messages, base_opts, temperature: 0.9)
+    def stream_complete(messages, options = nil, accumulate_response: true, **kwargs, &block)
+      opts = normalize_options(options, kwargs)
       response_accumulator = ResponseAccumulator.new if accumulate_response
 
       # Set up streaming handler (pass optional per-call block)
       stream_handler = build_stream_handler(response_accumulator, &block)
 
       # Trigger start callback
-      trigger_streaming_callbacks(:on_start, { model: model, messages: messages })
+      trigger_streaming_callbacks(:on_start, { model: opts.model, messages: messages })
 
       begin
-        # Execute the streaming request
-        # Note: extras must be passed as a hash, not splatted, to match complete()'s signature
-        complete(messages, model: model, stream: stream_handler, extras: extras)
+        # Execute the streaming request using parent's complete method
+        complete(messages, opts, stream: stream_handler)
 
         # Return accumulated response if requested
         if accumulate_response && response_accumulator
@@ -70,22 +80,26 @@ module OpenRouter
     # Stream with a simple block interface
     #
     # @param messages [Array<Hash>] Array of message hashes
-    # @param model [String|Array] Model identifier
+    # @param options [CompletionOptions, Hash, nil] Options object or hash with configuration
+    # @param kwargs [Hash] Additional options (merged with options parameter)
     # @param block [Proc] Block to call for each content chunk
-    # @param extras [Hash] Additional parameters
     #
-    # @example
+    # @example Simple usage (unchanged)
     #   client.stream(messages, model: "openai/gpt-4o-mini") do |chunk|
     #     print chunk
     #   end
-    def stream(messages, model: "openrouter/auto", **extras, &block)
+    #
+    # @example With CompletionOptions
+    #   opts = CompletionOptions.new(model: "gpt-4", temperature: 0.7)
+    #   client.stream(messages, opts) { |chunk| print chunk }
+    def stream(messages, options = nil, **kwargs, &block)
       raise ArgumentError, "Block required for streaming" unless block_given?
 
       stream_complete(
         messages,
-        model: model,
+        options,
         accumulate_response: false,
-        **extras
+        **kwargs
       ) do |chunk|
         content = extract_content_from_chunk(chunk)
         block.call(content) if content

data/lib/open_router/version.rb

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

data/lib/open_router.rb

@@ -17,6 +17,7 @@ module OpenRouter
 end
 
 require_relative "open_router/http"
+require_relative "open_router/completion_options"
 require_relative "open_router/tool"
 require_relative "open_router/tool_call_base"
 require_relative "open_router/tool_call"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: open_router_enhanced
 version: !ruby/object:Gem::Version
-  version: 1.2.5
+  version: 2.0.0
 platform: ruby
 authors:
 - Eric Stiens
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-12-27 00:00:00.000000000 Z
+date: 2025-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -149,6 +149,7 @@ files:
 - examples/tool_loop_example.rb
 - lib/open_router.rb
 - lib/open_router/client.rb
+- lib/open_router/completion_options.rb
 - lib/open_router/http.rb
 - lib/open_router/json_healer.rb
 - lib/open_router/model_registry.rb