raix 0.4.0 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 318057e8ece37b63c06884a61c37dc1ef15f38cee2c05d5305bcaf6d3697420e
-  data.tar.gz: 250229d71a808203689b87cea7c1ce8dd31b085c92b54dce392787299cd420d6
+  metadata.gz: cd88f295667264948d2710fb7eb0bcd74e5ab0177e76678314c34958e79fa6bd
+  data.tar.gz: b86495b4b67c5259915a7ef20502005d90ededf6be991821703d1d83e876c572
 SHA512:
-  metadata.gz: dc51d8fab907f8ffa5e95df2ef308ee3cd5fc443f46803e8a6f184be80e12719be2d25aeb51349a7912b35df55866db66cdec532c0258bc66a97aeabbc4017d0
-  data.tar.gz: 7b393143a5da05ba75ac11a8a77e31b0e61c1e7e9cb564fc6c986a4f63e2f98a24d43056f613e8e4685baab85251c9e819bcf99fcdc22ee7428b50eb9895d4e7
+  metadata.gz: cf1982b065312860c046a363486169a3d4572b65bd5ded3e82e270e3cbb689a173d6ff94cbcc897d6d8e5f27ef7e6558193ea3b266c18cc5bd1a8f2ca54fa6cd
+  data.tar.gz: 58eb7f54eb7d3a2656dbdd3e44a977c04b1dfb5ef5f7bd549ece96ecce9a931007edea5d364f189a1916883838c6a674e794799365914a1a5cab2402994da5f1

data/CHANGELOG.md

@@ -14,3 +14,7 @@
 
 ## [0.4.0] - 2024-10-18
 - adds support for Anthropic-style prompt caching
+- defaults to `max_completion_tokens` when using OpenAI directly
+
+## [0.4.2] - 2024-11-05
+- adds support for [Predicted Outputs](https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs) with the `prediction` option for OpenAI

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    raix (0.3.2)
+    raix (0.4.2)
       activesupport (>= 6.0)
       open_router (~> 0.2)
 

data/README.md

@@ -42,6 +42,14 @@ transcript << { role: "user", content: "What is the meaning of life?" }
 
 One of the advantages of OpenRouter and the reason that it is used by default by this library is that it handles mapping message formats from the OpenAI standard to whatever other model you're wanting to use (Anthropic, Cohere, etc.)
 
+### Predicted Outputs
+
+Raix supports [Predicted Outputs](https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs) with the `prediction` parameter for OpenAI.
+
+```ruby
+>> ai.chat_completion(openai: "gpt-4o", params: { prediction: })
+```
+
 ### Prompt Caching
 
 Raix supports [Anthropic-style prompt caching](https://openrouter.ai/docs/prompt-caching#anthropic-claude) when using Anthropic's Claud family of models. You can specify a `cache_at` parameter when doing a chat completion. If the character count for the content of a particular message is longer than the cache_at parameter, it will be sent to Anthropic as a multipart message with a cache control "breakpoint" set to "ephemeral".

data/lib/raix/chat_completion.rb

@@ -2,10 +2,11 @@
 
 require "active_support/concern"
 require "active_support/core_ext/object/blank"
-require "raix/message_adapters/base"
 require "open_router"
 require "openai"
 
+require_relative "message_adapters/base"
+
 module Raix
   # The `ChatCompletion`` module is a Rails concern that provides a way to interact
   # with the OpenRouter Chat Completion API via its client. The module includes a few
@@ -19,7 +20,7 @@ module Raix
     extend ActiveSupport::Concern
 
     attr_accessor :cache_at, :frequency_penalty, :logit_bias, :logprobs, :loop, :min_p, :model, :presence_penalty,
-                  :repetition_penalty, :response_format, :stream, :temperature, :max_completion_tokens,
+                  :prediction, :repetition_penalty, :response_format, :stream, :temperature, :max_completion_tokens,
                   :max_tokens, :seed, :stop, :top_a, :top_k, :top_logprobs, :top_p, :tools, :tool_choice, :provider
 
     # This method performs chat completion based on the provided transcript and parameters.
@@ -39,6 +40,7 @@ module Raix
       params[:max_completion_tokens] ||= max_completion_tokens.presence || Raix.configuration.max_completion_tokens
       params[:max_tokens] ||= max_tokens.presence || Raix.configuration.max_tokens
       params[:min_p] ||= min_p.presence
+      params[:prediction] = { type: "content", content: params[:prediction] || prediction } if params[:prediction] || prediction.present?
       params[:presence_penalty] ||= presence_penalty.presence
       params[:provider] ||= provider.presence
       params[:repetition_penalty] ||= repetition_penalty.presence
@@ -149,8 +151,12 @@ module Raix
     private
 
     def openai_request(params:, model:, messages:)
-      # deprecated in favor of max_completion_tokens
-      params.delete(:max_tokens)
+      if params[:prediction]
+        params.delete(:max_completion_tokens)
+      else
+        params[:max_completion_tokens] ||= params[:max_tokens]
+        params.delete(:max_tokens)
+      end
 
       params[:stream] ||= stream.presence
       params[:stream_options] = { include_usage: true } if params[:stream]

data/lib/raix/message_adapters/base.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/delegation"
+
+module Raix
+  module MessageAdapters
+    # Transforms messages into the format expected by the OpenAI API
+    class Base
+      attr_accessor :context
+
+      delegate :cache_at, :model, to: :context
+
+      def initialize(context)
+        @context = context
+      end
+
+      def transform(message)
+        return message if message[:role].present?
+
+        if message[:function].present?
+          { role: "assistant", name: message.dig(:function, :name), content: message.dig(:function, :arguments).to_json }
+        elsif message[:result].present?
+          { role: "function", name: message[:name], content: message[:result] }
+        else
+          content(message)
+        end
+      end
+
+      protected
+
+      def content(message)
+        case message
+        in { system: content }
+          { role: "system", content: }
+        in { user: content }
+          { role: "user", content: }
+        in { assistant: content }
+          { role: "assistant", content: }
+        else
+          raise ArgumentError, "Invalid message format: #{message.inspect}"
+        end.tap do |msg|
+          # convert to anthropic multipart format if model is claude-3 and cache_at is set
+          if model.to_s.include?("anthropic/claude-3") && cache_at && msg[:content].to_s.length > cache_at.to_i
+            msg[:content] = [{ type: "text", text: msg[:content], cache_control: { type: "ephemeral" } }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/raix/response_format.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/deep_dup"
+
+module Raix
+  # Handles the formatting of responses for AI interactions.
+  #
+  # This class is responsible for converting input data into a JSON schema
+  # that can be used to structure and validate AI responses. It supports
+  # nested structures and arrays, ensuring that the output conforms to
+  # the expected format for AI model interactions.
+  #
+  # @example
+  #   input = { name: { type: "string" }, age: { type: "integer" } }
+  #   format = ResponseFormat.new("PersonInfo", input)
+  #   schema = format.to_schema
+  #
+  # @attr_reader [String] name The name of the response format
+  # @attr_reader [Hash] input The input data to be formatted
+  class ResponseFormat
+    def initialize(name, input)
+      @name = name
+      @input = input
+    end
+
+    def to_json(*)
+      JSON.pretty_generate(to_schema)
+    end
+
+    def to_schema
+      {
+        type: "json_schema",
+        json_schema: {
+          name: @name,
+          schema: {
+            type: "object",
+            properties: decode(@input.deep_dup),
+            required: @input.keys,
+            additionalProperties: false
+          },
+          strict: true
+        }
+      }
+    end
+
+    private
+
+    def decode(input)
+      {}.tap do |response|
+        case input
+        when Array
+          properties = {}
+          input.each { |item| properties.merge!(decode(item)) }
+
+          response[:type] = "array"
+          response[:items] = {
+            type: "object",
+            properties:,
+            required: properties.keys.select { |key| properties[key].delete(:required) },
+            additionalProperties: false
+          }
+        when Hash
+          input.each do |key, value|
+            response[key] = if value.is_a?(Hash) && value.key?(:type)
+                              value
+                            else
+                              decode(value)
+                            end
+          end
+        else
+          raise "Invalid input"
+        end
+      end
+    end
+  end
+end

data/lib/raix/version.rb

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

data/lib/raix.rb

@@ -4,6 +4,7 @@ require_relative "raix/version"
 require_relative "raix/chat_completion"
 require_relative "raix/function_dispatch"
 require_relative "raix/prompt_declarations"
+require_relative "raix/response_format"
 
 # The Raix module provides configuration options for the Raix gem.
 module Raix

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Obie Fernandez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-19 00:00:00.000000000 Z
+date: 2024-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,7 +58,9 @@ files:
 - lib/raix.rb
 - lib/raix/chat_completion.rb
 - lib/raix/function_dispatch.rb
+- lib/raix/message_adapters/base.rb
 - lib/raix/prompt_declarations.rb
+- lib/raix/response_format.rb
 - lib/raix/version.rb
 - raix.gemspec
 - sig/raix.rbs
@@ -84,7 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.21
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Ruby AI eXtensions