raix 2.0.3 → 2.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44058aeb590e21ead9e7db9ebdc9a4ecffc9f4771b75663e137b22ecca4cd7d2
-  data.tar.gz: c59475844e68ef02379d85f7dde02540a58e7659d6b44a7fb83db7f491998635
+  metadata.gz: 3f9cda9662a819d937b2be909563e7bbd145111b2f70006a596b6fc30cf25fe6
+  data.tar.gz: 280b9bee2cc6b3f47ded7b0ae88b406842184c48597efc4c9aa085458bff4cab
 SHA512:
-  metadata.gz: 76c43e2109fc3ec1be374c2b5df9e024ad09274e2ece3df976eb6f961d022123453bb995f6f0680921df5f224c439cbd19ec8eac8d5acc201d80193541396509
-  data.tar.gz: c0ee5f840e83718168668cf844a2cb3e7969f2cd5e199235b8532049660aab0cf7750abcf0e8748ffda7427fee73c7739fc37060c739efc64bcf7b04867c9da5
+  metadata.gz: dc7ee985af7a5b832803e7aa9300986f83fd520315e4d3668e68fa1d9084be08782517054dac91e9a187e190de2876215e0dfa71bb2f09ffb462d9f275b22e71
+  data.tar.gz: 49380b2201f8563dd7e69c30a76866b16b89d2085c6bc3e953afd6f233343d4f9c93ba891c02122228d2579341b9c64c423f16751d588d97e5105c6443d2da07

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [Unreleased]
 
+## [2.0.5] - 2026-06-04
+
+### Fixed
+- `Raix::Configuration` no longer defaults `temperature` to `0.0`. The default was being injected into every request payload, which OpenRouter rejects with `404 No endpoints found that can handle the requested parameters` when routed to providers whose `supported_parameters` list omits `temperature` (notably Anthropic's Claude 4.7 family) and `provider.require_parameters: true` is set — which Raix sets automatically whenever `json: true` is passed to `chat_completion`. Callers that want a specific temperature should set one explicitly (`self.temperature = 0.0` on the including class, or `Raix.configure { |c| c.temperature = 0.0 }` globally); when unset, Raix now omits the parameter and the provider's own server-side default applies. `max_tokens`, `max_completion_tokens`, and `model` defaults are unchanged.
+- `Raix::FunctionToolAdapter` now forwards the full JSON-Schema dict for each function parameter to RubyLLM instead of rebuilding it from `type` + `description` only. Rich schema fields like `additionalProperties`, `items`, `enum`, and nested `properties` were silently dropped, leaving providers (notably Gemini's structured output via OpenRouter) to invent degenerate shapes for `type: object` arguments — e.g. emitting `{"prefix" => false}` instead of `{"prefix:title" => "..."}`. Function declarations with rich object schemas now reach the provider intact.
+- The outer tool-args schema continues to inject `additionalProperties: false` and `strict: true` by default for OpenAI strict-mode compatibility, but consumers can override either by setting them explicitly in the function declaration.
+- Multimodal `transcript` content is no longer silently dropped on the RubyLLM backend. OpenAI-style content arrays (a `text` part plus one or more `{ type: "image_url", image_url: { url: ... } }` parts) were passed to RubyLLM verbatim, which treats the array as plain text — so a vision model received text only and confabulated an answer. Raix now translates `image_url` parts into RubyLLM attachments via `Raix::MultimodalContentAdapter`, decoding base64 `data:` URIs into binary IO (RubyLLM's `Attachment` does not natively recognize `data:` URIs) and passing http(s) URLs through. Text-only completions are unaffected (#51).
+
+## [2.0.4] - 2026-05-19
+
+### Fixed
+- `ruby_llm_request` now preserves the upstream provider's `id`, `model`, and `provider` fields, plus the full `usage` payload (including `prompt_tokens_details.cached_tokens` and `completion_tokens_details.reasoning_tokens`) on the OpenAI-compatible response hash. Previously the conversion dropped everything except `choices` and basic token counts, which broke callers that needed the generation id for authoritative cost lookups (e.g. OpenRouter's `/api/v1/generation` endpoint) or that wanted to verify prompt-cache hits via `cached_tokens`.
+- Added `require "active_support/core_ext/module/delegation"` so `Raix::ChatCompletion` loads cleanly without an external preload of ActiveSupport. The class uses `delegate :configuration, to: :class` but did not pull in the required core ext, so a bare `require "raix"` would raise `NoMethodError` for `delegate`.
+
 ## [2.0.3] - 2026-04-30
 
 ### Fixed

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    raix (2.0.3)
+    raix (2.0.5)
       activesupport (>= 6.0)
       faraday-retry (~> 2.0)
       ostruct

data/Rakefile

@@ -2,6 +2,8 @@
 
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "shellwords"
+require "tmpdir"
 
 RSpec::Core::RakeTask.new(:spec)
 
@@ -16,3 +18,26 @@ RuboCop::RakeTask.new(:rubocop) do |task|
 end
 
 task default: %i[spec rubocop]
+
+namespace :release do
+  desc "Create a GitHub release for the current version (runs automatically after `rake release`)"
+  task :github do
+    version = Bundler::GemHelper.gemspec.version.to_s
+    tag = "v#{version}"
+    section = File.read("CHANGELOG.md").match(/^## \[#{Regexp.escape(version)}\][^\n]*\n(.*?)(?=^## \[|\z)/m)
+
+    if section.nil?
+      warn "release:github — no CHANGELOG entry for #{version}; skipping GitHub release."
+      next
+    end
+
+    notes_file = File.join(Dir.tmpdir, "raix-release-notes-#{version}.md")
+    File.write(notes_file, "#{section[1].strip}\n")
+
+    sh "gh release create #{tag.shellescape} --title #{"Release #{version}".shellescape} --notes-file #{notes_file.shellescape} --latest=true"
+  end
+end
+
+Rake::Task["release"].enhance do
+  Rake::Task["release:github"].invoke
+end

data/lib/raix/chat_completion.rb

@@ -4,6 +4,7 @@ require "active_support/concern"
 require "active_support/core_ext/object/blank"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/module/delegation"
 require "ruby_llm"
 
 module Raix
@@ -56,9 +57,7 @@ module Raix
     end
 
     # Instance level access to the class-level configuration.
-    def configuration
-      self.class.configuration
-    end
+    delegate :configuration, to: :class
 
     # This method performs chat completion based on the provided transcript and parameters.
     #
@@ -356,7 +355,7 @@ module Raix
           chat.with_instructions(content)
         when "user"
           has_user_message = true
-          chat.add_message(role: :user, content:)
+          chat.add_message(role: :user, content: MultimodalContentAdapter.translate(content))
         when "assistant"
           if msg[:tool_calls] || msg["tool_calls"]
             chat.add_message(role: :assistant, content:, tool_calls: msg[:tool_calls] || msg["tool_calls"])
@@ -398,8 +397,34 @@ module Raix
         # Non-streaming mode - return OpenAI-compatible response format
         response_message = has_user_message ? chat.complete : chat.ask
 
-        # Convert RubyLLM response to OpenAI format for compatibility
+        # Pull through the raw provider payload when available. OpenRouter's
+        # `id` is the only handle we have to look up authoritative billing
+        # cost via /api/v1/generation, and callers that watch the response
+        # snapshot for `model` / cached-token counts shouldn't have to break
+        # out of the OpenAI-compatible shape to get them.
+        raw_body = response_message.raw.respond_to?(:body) ? response_message.raw.body : nil
+        raw_body = {} unless raw_body.is_a?(Hash)
+
+        usage_payload = {
+          "prompt_tokens" => response_message.input_tokens,
+          "completion_tokens" => response_message.output_tokens,
+          "total_tokens" => (response_message.input_tokens || 0) + (response_message.output_tokens || 0)
+        }
+
+        # Merge prompt_tokens_details / completion_tokens_details (cached tokens,
+        # reasoning tokens) when the provider supplied them.
+        if (upstream_usage = raw_body["usage"]).is_a?(Hash)
+          upstream_usage.each do |key, value|
+            next if usage_payload.key?(key)
+
+            usage_payload[key] = value
+          end
+        end
+
         {
+          "id" => raw_body["id"],
+          "model" => raw_body["model"] || response_message.model_id,
+          "provider" => raw_body["provider"],
           "choices" => [
             {
               "message" => {
@@ -410,11 +435,7 @@ module Raix
               "finish_reason" => response_message.tool_call? ? "tool_calls" : "stop"
             }
           ],
-          "usage" => {
-            "prompt_tokens" => response_message.input_tokens,
-            "completion_tokens" => response_message.output_tokens,
-            "total_tokens" => (response_message.input_tokens || 0) + (response_message.output_tokens || 0)
-          }
+          "usage" => usage_payload
         }
       end
     rescue StandardError => e

data/lib/raix/configuration.rb

@@ -51,12 +51,19 @@ module Raix
     DEFAULT_MAX_TOKENS = 1000
     DEFAULT_MAX_COMPLETION_TOKENS = 16_384
     DEFAULT_MODEL = "meta-llama/llama-3.3-8b-instruct:free"
-    DEFAULT_TEMPERATURE = 0.0
     DEFAULT_MAX_TOOL_CALLS = 25
 
     # Initializes a new instance of the Configuration class with default values.
+    #
+    # Note: temperature is intentionally not defaulted. Setting a non-nil
+    # temperature here would force it into every request payload, and some
+    # providers (e.g. Anthropic's Claude 4.7 family on OpenRouter) do not list
+    # `temperature` in their supported parameters. Combined with
+    # `provider.require_parameters: true` (which Raix sets when `json: true`),
+    # an injected default of 0.0 causes OpenRouter to reject the request with
+    # "No endpoints found that can handle the requested parameters." Callers
+    # who want a specific temperature should set one explicitly.
     def initialize(fallback: nil)
-      self.temperature = DEFAULT_TEMPERATURE
       self.max_completion_tokens = DEFAULT_MAX_COMPLETION_TOKENS
       self.max_tokens = DEFAULT_MAX_TOKENS
       self.model = DEFAULT_MODEL

data/lib/raix/function_tool_adapter.rb

@@ -7,10 +7,18 @@ module Raix
       tool_class = Class.new(RubyLLM::Tool) do
         description function_def[:description] if function_def[:description]
 
-        # Define parameters based on function definition
-        function_def[:parameters][:properties]&.each do |param_name, param_def|
-          required = function_def[:parameters][:required]&.include?(param_name)
-          param param_name.to_sym, type: param_def[:type], desc: param_def[:description], required:
+        # Forward the full JSON-schema parameter dict to RubyLLM rather than
+        # rebuilding it field-by-field via `param(...)`. The per-field path
+        # only carried `type` and `description`, which silently dropped richer
+        # schema like `additionalProperties`, `items`, `enum`, or nested
+        # `properties` — leaving providers (notably Gemini's structured output)
+        # to invent degenerate shapes for `type: object` arguments.
+        if function_def[:parameters].is_a?(Hash) && function_def[:parameters][:properties].present?
+          # RubyLLM's `params(schema)` path forwards the schema verbatim and, unlike the
+          # per-field `param(...)` path, does not inject the OpenAI strict-mode guards. Default
+          # them on so existing tools keep strict behavior, while letting a function declaration
+          # override either by setting it explicitly.
+          params({ additionalProperties: false, strict: true }.merge(function_def[:parameters]))
         end
 
         # Store reference to the instance and function name

data/lib/raix/multimodal_content_adapter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/indifferent_access"
+require "base64"
+require "stringio"
+
+module Raix
+  # Translates OpenAI-style multimodal content arrays (a `text` part plus one or
+  # more `image_url` parts) into a RubyLLM::Content so images survive the trip to
+  # the provider.
+  #
+  # RubyLLM's `add_message`/`ask` treat a raw array of OpenAI content hashes as
+  # plain text, so an `{ type: "image_url", image_url: { url: ... } }` part is
+  # silently dropped and a vision model receives text only. See
+  # https://github.com/OlympiaAI/raix/issues/51
+  #
+  # Anything that is not an array of hashes containing at least one `image_url`
+  # part is returned untouched, so existing text completions are unaffected.
+  class MultimodalContentAdapter
+    def self.translate(content)
+      new(content).translate
+    end
+
+    def initialize(content)
+      @content = content
+    end
+
+    def translate
+      return @content unless translatable?
+
+      parts = @content.map(&:with_indifferent_access)
+      attachments = parts.select { |part| part[:type].to_s == "image_url" }
+                         .filter_map { |part| attachment_source(part.dig(:image_url, :url)) }
+      return @content if attachments.empty?
+
+      text = parts.select { |part| part[:type].to_s == "text" }.filter_map { |part| part[:text] }.join("\n")
+      RubyLLM::Content.new(text.empty? ? nil : text, attachments)
+    end
+
+    private
+
+    def translatable?
+      @content.is_a?(Array) &&
+        @content.all? { |part| part.is_a?(Hash) } &&
+        @content.any? { |part| (part[:type] || part["type"]).to_s == "image_url" }
+    end
+
+    # RubyLLM::Attachment recognizes http(s) URLs, file paths, and IO objects, but
+    # not base64 `data:` URIs (it would treat one as a filesystem path). Decode
+    # those into a binary StringIO, which Attachment handles as an IO source.
+    def attachment_source(url)
+      return if url.nil? || url.empty?
+      return url unless url.start_with?("data:")
+
+      match = url.match(/\Adata:[^;,]*;base64,(.+)\z/m)
+      return url unless match
+
+      io = StringIO.new(Base64.decode64(match[1]))
+      io.set_encoding(Encoding::BINARY) if io.respond_to?(:set_encoding)
+      io
+    end
+  end
+end

data/lib/raix/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raix
-  VERSION = "2.0.3"
+  VERSION = "2.0.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.5
 platform: ruby
 authors:
 - Obie Fernandez
 bindir: exe
 cert_chain: []
-date: 2026-04-30 00:00:00.000000000 Z
+date: 2026-06-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -109,6 +109,7 @@ files:
 - lib/raix/mcp/stdio_client.rb
 - lib/raix/mcp/tool.rb
 - lib/raix/message_adapters/base.rb
+- lib/raix/multimodal_content_adapter.rb
 - lib/raix/predicate.rb
 - lib/raix/prompt_declarations.rb
 - lib/raix/response_format.rb