raix 0.5 → 0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7537dc5f13d858d6fdd7e5fcdeb60e1d5fd99e0f2aa84e618096f959f2c44ed1
-  data.tar.gz: 8af2e5eb06b2fdaf2c4da8e9b9df28750c6c449d63e5eec25478d61068de2742
+  metadata.gz: f6783ed9671864edec5d734f8003822accee2dd7b89d0453a2c6973d35ecf2bf
+  data.tar.gz: 90eac19ba012daaeed4ce898a2be3476d1dac9c6df2cbb66fbe88a5620b971c6
 SHA512:
-  metadata.gz: a76e3c1ac764735f05b603c83f6410c5d83274e0d8ef5b80e6a08dfb4ca2338ed324b14db3b4383399ebbd9a88d76615deed4ad8533592ac3dee2ccc84f1ab6d
-  data.tar.gz: c4c89a3d2feac21a80dd1be7f4c0626f48a09756af55b0f38dd0abc769ec4cdb989ae210baabcbbb896f869ec79dd1e26454cecd5df28ee3ff016661d612e7c3
+  metadata.gz: 6753d494dd65e960373308189d7324e973c347f627ed82463b9ae3d7079446a87b7e012949c5a69adf734a1e9f37e8684b51a04f3a7b39b6b9772b501908949a
+  data.tar.gz: 07f8d142ca423979013c17da2f8758a7113fc583fc2ee47b10cf64072a7be12aa7b53447821340239033866e8c108b1bea76ffc202fcd24e02cf814607df5989

data/.rubocop.yml

@@ -10,8 +10,10 @@ Style/StringLiteralsInInterpolation:
   Enabled: true
   EnforcedStyle: double_quotes
 
+Style/IfUnlessModifier:
+  Enabled: false
 Layout/LineLength:
-  Max: 180
+  Enabled: false
 
 Metrics/BlockLength:
   Enabled: false
@@ -30,3 +32,6 @@ Metrics/CyclomaticComplexity:
 
 Metrics/PerceivedComplexity:
   Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false

data/CHANGELOG.md

@@ -1,4 +1,27 @@
-## [Unreleased]
+## [0.7] - 2024-04-02
+- adds support for `until` condition in `PromptDeclarations` to control prompt looping
+- adds support for `if` and `unless` conditions in `PromptDeclarations` to control prompt execution
+- adds support for `success` callback in `PromptDeclarations` to handle prompt responses
+- adds support for `stream` handler in `PromptDeclarations` to control response streaming
+- adds support for `params` in `PromptDeclarations` to customize API parameters per prompt
+- adds support for `system` directive in `PromptDeclarations` to set per-prompt system messages
+- adds support for `call` in `PromptDeclarations` to delegate to callable prompt objects
+- adds support for `text` in `PromptDeclarations` to specify prompt content via lambda, string, or symbol
+- adds support for `raw` parameter in `PromptDeclarations` to return raw API responses
+- adds support for `openai` parameter in `PromptDeclarations` to use OpenAI directly
+- adds support for `prompt` parameter in `PromptDeclarations` to specify initial prompt
+- adds support for `last_response` in `PromptDeclarations` to access previous prompt responses
+- adds support for `current_prompt` in `PromptDeclarations` to access current prompt context
+- adds support for `MAX_LOOP_COUNT` in `PromptDeclarations` to prevent infinite loops
+- adds support for `execute_ai_request` in `PromptDeclarations` to handle API calls
+- adds support for `chat_completion_from_superclass` in `PromptDeclarations` to handle superclass calls
+- adds support for `model`, `temperature`, and `max_tokens` in `PromptDeclarations` to access prompt parameters
+- fixes function return values in `FunctionDispatch` to properly return results from tool calls (thanks @ttilberg)
+- Make automatic JSON parsing available to non-OpenAI providers that don't support the response_format parameter by scanning for json XML tags
+
+## [0.6.0] - 2024-11-12
+- adds `save_response` option to `chat_completion` to control transcript updates
+- fixes potential race conditions in transcript handling
 
 ## [0.1.0] - 2024-04-03
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    raix (0.5)
+    raix (0.7)
       activesupport (>= 6.0)
       open_router (~> 0.2)
       ruby-openai (~> 7.0)

data/README.llm

@@ -0,0 +1,106 @@
+# Raix (Ruby AI eXtensions)
+Raix adds LLM-based AI functionality to Ruby classes. It supports OpenAI or OpenRouter as providers and can work in non-Rails apps if you include ActiveSupport.
+
+## Chat Completion
+You must include `Raix::ChatCompletion`. It gives you a `transcript` array for messages and a `chat_completion` method that sends them to the AI.
+
+```ruby
+class MeaningOfLife
+  include Raix::ChatCompletion
+end
+
+ai = MeaningOfLife.new
+ai.transcript << { user: "What is the meaning of life?" }
+puts ai.chat_completion
+```
+
+You can add messages using either `{ user: "..." }` or `{ role: "user", content: "..." }`.
+
+### Predicted Outputs
+Pass `prediction` to support [Predicted Outputs](https://platform.openai.com/docs/guides/latency-optimization#use-predicted-outputs):
+```ruby
+ai.chat_completion(openai: "gpt-4o", params: { prediction: "..." })
+```
+
+### Prompt Caching
+When using Anthropic models, you can specify `cache_at`. Messages above that size get sent as ephemeral multipart segments.
+```ruby
+ai.chat_completion(params: { cache_at: 1000 })
+```
+
+## Function Dispatch
+Include `Raix::FunctionDispatch` to declare functions AI can call in a chat loop. Use `chat_completion(loop: true)` so the AI can call functions and generate more messages until it outputs a final text response.
+
+```ruby
+class WhatIsTheWeather
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :check_weather, "Check the weather for a location", location: { type: "string" } do |args|
+    "The weather in #{args[:location]} is hot and sunny"
+  end
+end
+```
+
+If the AI calls multiple functions at once, Raix handles them in sequence and returns an array of results. Call `stop_looping!` inside a function to end the loop.
+
+## Prompt Declarations
+Include `Raix::PromptDeclarations` to define a chain of prompts in order. Each prompt can be inline text or a callable class that also includes `ChatCompletion`.
+
+```ruby
+class PromptSubscriber
+  include Raix::ChatCompletion
+  include Raix::PromptDeclarations
+
+  prompt call: FetchUrlCheck
+  prompt call: MemoryScan
+  prompt text: -> { user_message.content }
+
+  def message_created(user_message)
+    chat_completion(loop: true, openai: "gpt-4o")
+  end
+end
+```
+
+## Predicate Module
+Include `Raix::Predicate` to handle yes/no/maybe questions. Define blocks with the `yes?`, `no?`, and `maybe?` methods.
+
+```ruby
+class Question
+  include Raix::Predicate
+
+  yes? { |explanation| puts "Affirmative: #{explanation}" }
+  no?  { |explanation| puts "Negative: #{explanation}" }
+
+end
+```
+
+## ResponseFormat (Experimental)
+Use `Raix::ResponseFormat` to enforce JSON schemas for structured responses.
+
+```ruby
+format = Raix::ResponseFormat.new("PersonInfo", {
+  name: { type: "string" },
+  age: { type: "integer" }
+})
+
+class StructuredResponse
+  include Raix::ChatCompletion
+
+  def analyze_person(name)
+    chat_completion(response_format: format)
+  end
+end
+```
+
+## Installation
+Add `gem "raix"` to your Gemfile or run `gem install raix`. Configure an OpenRouter or OpenAI client in an initializer:
+
+```ruby
+# config/initializers/raix.rb
+Raix.configure do |config|
+  config.openrouter_client = OpenRouter::Client.new
+end
+```
+Make sure you have valid API tokens for your chosen provider.
+```

data/README.md

@@ -24,6 +24,10 @@ end
 => "The question of the meaning of life is one of the most profound and enduring inquiries in philosophy, religion, and science.
     Different perspectives offer various answers..."
 
+By default, Raix will automatically add the AI's response to the transcript. This behavior can be controlled with the `save_response` parameter, which defaults to `true`. You may want to set it to `false` when making multiple chat completion calls during the lifecycle of a single object (whether sequentially or in parallel) and want to manage the transcript updates yourself:
+
+```ruby
+>> ai.chat_completion(save_response: false)
 ```
 
 #### Transcript Format
@@ -127,6 +131,24 @@ results = example.chat_completion(openai: "gpt-4o")
 # => ["Result from first tool", "Result from second tool"]
 ```
 
+Note that as of version 0.6.1, function return values are properly returned from tool calls, whether in single or multiple tool call scenarios. This means you can use the return values from your functions in your application logic.
+
+```ruby
+class DiceRoller
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :roll_dice, "Roll a die with specified number of faces", faces: { type: :integer } do |arguments|
+    rand(1..arguments[:faces])
+  end
+end
+
+roller = DiceRoller.new
+roller.transcript << { user: "Roll a d20 twice" }
+results = roller.chat_completion(openai: "gpt-4o")
+# => [15, 7] # Actual random dice roll results
+```
+
 #### Manually Stopping a Loop
 
 To loop AI components that don't interact with end users, at least one function block should invoke `stop_looping!` whenever you're ready to stop processing.
@@ -222,7 +244,6 @@ class PromptSubscriber
   end
 
   ...
-
 end
 
 class FetchUrlCheck
@@ -264,6 +285,80 @@ Notably, Olympia does not use the `FunctionDispatch` module in its primary conve
 
 Streaming of the AI's response to the end user is handled by the `ReplyStream` class, passed to the final prompt declaration as its `stream` parameter. [Patterns of Application Development Using AI](https://leanpub.com/patterns-of-application-development-using-ai) devotes a whole chapter to describing how to write your own `ReplyStream` class.
 
+#### Additional PromptDeclarations Options
+
+The `PromptDeclarations` module supports several additional options that can be used to customize prompt behavior:
+
+```ruby
+class CustomPromptExample
+  include Raix::ChatCompletion
+  include Raix::PromptDeclarations
+
+  # Basic prompt with text
+  prompt text: "Process this input"
+
+  # Prompt with system directive
+  prompt system: "You are a helpful assistant",
+        text: "Analyze this text"
+
+  # Prompt with conditions
+  prompt text: "Process this input",
+        if: -> { some_condition },
+        unless: -> { some_other_condition }
+
+  # Prompt with success callback
+  prompt text: "Process this input",
+        success: ->(response) { handle_response(response) }
+
+  # Prompt with custom parameters
+  prompt text: "Process with custom settings",
+        params: { temperature: 0.7, max_tokens: 1000 }
+
+  # Prompt with until condition for looping
+  prompt text: "Keep processing until complete",
+        until: -> { processing_complete? }
+
+  # Prompt with raw response
+  prompt text: "Get raw response",
+        raw: true
+
+  # Prompt using OpenAI directly
+  prompt text: "Use OpenAI",
+        openai: true
+end
+```
+
+The available options include:
+
+- `system`: Set a system directive for the prompt
+- `if`/`unless`: Control prompt execution with conditions
+- `success`: Handle prompt responses with callbacks
+- `params`: Customize API parameters per prompt
+- `until`: Control prompt looping
+- `raw`: Get raw API responses
+- `openai`: Use OpenAI directly
+- `stream`: Control response streaming
+- `call`: Delegate to callable prompt objects
+
+You can also access the current prompt context and previous responses:
+
+```ruby
+class ContextAwarePrompt
+  include Raix::ChatCompletion
+  include Raix::PromptDeclarations
+
+  def process_with_context
+    # Access current prompt
+    current_prompt.params[:temperature]
+
+    # Access previous response
+    last_response
+
+    chat_completion
+  end
+end
+```
+
 ## Predicate Module
 
 The `Raix::Predicate` module provides a simple way to handle yes/no/maybe questions using AI chat completion. It allows you to define blocks that handle different types of responses with their explanations. It is one of the concrete patterns described in the "Discrete Components" chapter of [Patterns of Application Development Using AI](https://leanpub.com/patterns-of-application-development-using-ai).
@@ -418,7 +513,7 @@ class StructuredResponse
     })
 
     transcript << { user: "Analyze the person named #{name}" }
-    chat_completion(response_format: format)
+    chat_completion(params: { response_format: format })
   end
 end
 

data/lib/raix/chat_completion.rb

@@ -40,11 +40,11 @@ module Raix
     #
     # @param params [Hash] The parameters for chat completion.
     # @option loop [Boolean] :loop (false) Whether to loop the chat completion after function calls.
-    # @option params [Boolean] :json (false) Whether to return the parse the response as a JSON object.
+    # @option params [Boolean] :json (false) Whether to return the parse the response as a JSON object. Will search for <json> tags in the response first, then fall back to the default JSON parsing of the entire response.
     # @option params [Boolean] :openai (false) Whether to use OpenAI's API instead of OpenRouter's.
     # @option params [Boolean] :raw (false) Whether to return the raw response or dig the text content.
     # @return [String|Hash] The completed chat response.
-    def chat_completion(params: {}, loop: false, json: false, raw: false, openai: false)
+    def chat_completion(params: {}, loop: false, json: false, raw: false, openai: false, save_response: true)
       # set params to default values if not provided
       params[:cache_at] ||= cache_at.presence
       params[:frequency_penalty] ||= frequency_penalty.presence
@@ -84,7 +84,10 @@ module Raix
       self.model ||= Raix.configuration.model
 
       adapter = MessageAdapters::Base.new(self)
-      messages = transcript.flatten.compact.map { |msg| adapter.transform(msg) }
+
+      # duplicate the transcript to avoid race conditions in situations where
+      # chat_completion is called multiple times in parallel
+      messages = transcript.flatten.compact.map { |msg| adapter.transform(msg) }.dup
       raise "Can't complete an empty transcript" if messages.blank?
 
       begin
@@ -119,8 +122,14 @@ module Raix
 
         response.tap do |res|
           content = res.dig("choices", 0, "message", "content")
+
+          transcript << { assistant: content } if save_response
+          content = content.squish
+
           if json
-            content = content.squish
+            # Make automatic JSON parsing available to non-OpenAI providers that don't support the response_format parameter
+            content = content.match(%r{<json>(.*?)</json>}m)[1] if content.include?("<json>")
+
             return JSON.parse(content)
           end
 

data/lib/raix/function_dispatch.rb

@@ -70,7 +70,7 @@ module Raix
               }
             ]
           }
-          instance_exec(arguments, &block).tap do |content|
+          result = instance_exec(arguments, &block).tap do |content|
             transcript << {
               role: "tool",
               tool_call_id: id,
@@ -81,6 +81,10 @@ module Raix
           end
 
           chat_completion(**chat_completion_args) if loop
+
+          # Return the result of the function call in case that's what the caller wants
+          # https://github.com/OlympiaAI/raix/issues/16
+          result
         end
       end
     end

data/lib/raix/prompt_declarations.rb

@@ -1,119 +1,176 @@
 # frozen_string_literal: true
 
 require "ostruct"
-require "active_support/core_ext/string/filters"
-
-module Raix
-  # The PromptDeclarations module provides a way to chain prompts and handle
-  # user responses in a serialized manner (in the order they were defined),
-  # with support for functions if the FunctionDispatch module is also included.
-  module PromptDeclarations
-    extend ActiveSupport::Concern
-    extend ChatCompletion
-
-    module ClassMethods # rubocop:disable Style/Documentation
-      # Adds a prompt to the list of prompts.
-      #
-      # @param system [Proc] A lambda that generates the system message.
-      # @param text [Proc] A lambda that generates the prompt text. (Required)
-      # @param success [Proc] The block of code to execute when the prompt is answered.
-      # @param parameters [Hash] Additional parameters for the completion API call
-      # @param stream [Boolean] Whether to stream the response.
-      def prompt(text:, system: nil, success: nil, params: {}, stream: false)
-        name = Digest::SHA256.hexdigest(text.inspect)[0..7]
-        prompts << begin
-          OpenStruct.new({ name:, system:, text:, success:, params:, stream: })
-        end
-
-        define_method(name) do |response|
-          if Rails.env.local?
-            puts "_" * 80
-            puts "PromptDeclarations#response:"
-            puts "#{text.source_location} (#{name})"
-            puts response
-            puts "_" * 80
-          end
-
-          return response if success.nil?
-          return send(success, response) if success.is_a?(Symbol)
-
-          instance_exec(response, &success)
-        end
-      end
 
-      # the list of prompts declared at class level
-      def prompts
-        @prompts ||= []
-      end
+# This module provides a way to chain prompts and handle
+# user responses in a serialized manner, with support for
+# functions if the FunctionDispatch module is also included.
+module PromptDeclarations
+  extend ActiveSupport::Concern
 
-      # getter/setter for system prompt declared at class level
-      def system_prompt(prompt = nil)
-        prompt ? @system_prompt = prompt.squish : @system_prompt
+  module ClassMethods # rubocop:disable Style/Documentation
+    # Adds a prompt to the list of prompts. At minimum, provide a `text` or `call` parameter.
+    #
+    # @param system [Proc] A lambda that generates the system message.
+    # @param call [ChatCompletion] A callable class that includes ChatCompletion. Will be passed a context object when initialized.
+    # @param text Accepts 1) a lambda that returns the prompt text, 2) a string, or 3) a symbol that references a method.
+    # @param stream [Proc] A lambda stream handler
+    # @param success [Proc] The block of code to execute when the prompt is answered.
+    # @param params [Hash] Additional parameters for the completion API call
+    # @param if [Proc] A lambda that determines if the prompt should be executed.
+    def prompt(system: nil, call: nil, text: nil, stream: nil, success: nil, params: {}, if: nil, unless: nil, until: nil)
+      name = Digest::SHA256.hexdigest(text.inspect)[0..7]
+      prompts << OpenStruct.new({ name:, system:, call:, text:, stream:, success:, if:, unless:, until:, params: })
+
+      define_method(name) do |response|
+        puts "_" * 80
+        puts "PromptDeclarations#response:"
+        puts "#{text&.source_location} (#{name})"
+        puts response
+        puts "_" * 80
+
+        return response if success.nil?
+        return send(success, response) if success.is_a?(Symbol)
+
+        instance_exec(response, &success)
       end
     end
 
-    # Executes the chat completion process based on the class-level declared prompts.
-    # The response to each prompt is added to the transcript automatically and returned.
-    #
-    # Prompts require at least a `text` lambda parameter.
-    #
-    # @param params [Hash] Parameters for the chat completion override those defined in the current prompt.
-    # @option params [Boolean] :raw (false) Whether to return the raw response or dig the text content.
-    #
-    # Uses system prompt in following order of priority:
-    #   - system lambda specified in the prompt declaration
-    #   - system_prompt instance method if defined
-    #   - system_prompt class-level declaration if defined
-    #
-    #  TODO: shortcut syntax passes just a string prompt if no other options are needed.
-    #
-    # @raise [RuntimeError] If no prompts are defined.
-    #
-    def chat_completion(params: {}, raw: false)
-      raise "No prompts defined" unless self.class.prompts.present?
-
-      current_prompts = self.class.prompts.clone
+    def prompts
+      @prompts ||= []
+    end
+  end
 
-      while (@current_prompt = current_prompts.shift)
-        __system_prompt = instance_exec(&@current_prompt.system) if @current_prompt.system.present? # rubocop:disable Lint/UnderscorePrefixedVariableName
+  attr_reader :current_prompt, :last_response
+
+  MAX_LOOP_COUNT = 5
+
+  # Executes the chat completion process based on the class-level declared prompts.
+  # The response to each prompt is added to the transcript automatically and returned.
+  #
+  # Raises an error if there are not enough prompts defined.
+  #
+  # Uses system prompt in following order of priority:
+  #   - system lambda specified in the prompt declaration
+  #   - system_prompt instance method if defined
+  #   - system_prompt class-level declaration if defined
+  #
+  #  Prompts require a text lambda to be defined at minimum.
+  #  TODO: shortcut syntax passes just a string prompt if no other options are needed.
+  #
+  # @raise [RuntimeError] If no prompts are defined.
+  #
+  # @param prompt [String] The prompt to use for the chat completion.
+  # @param params [Hash] Parameters for the chat completion.
+  # @param raw [Boolean] Whether to return the raw response.
+  #
+  # TODO: SHOULD NOT HAVE A DIFFERENT INTERFACE THAN PARENT
+  def chat_completion(prompt = nil, params: {}, raw: false, openai: false)
+    raise "No prompts defined" unless self.class.prompts.present?
+
+    loop_count = 0
+
+    current_prompts = self.class.prompts.clone
+
+    while (@current_prompt = current_prompts.shift)
+      next if @current_prompt.if.present? && !instance_exec(&@current_prompt.if)
+      next if @current_prompt.unless.present? && instance_exec(&@current_prompt.unless)
+
+      input = case current_prompt.text
+              when Proc
+                instance_exec(&current_prompt.text)
+              when String
+                current_prompt.text
+              when Symbol
+                send(current_prompt.text)
+              else
+                last_response.presence || prompt
+              end
+
+      if current_prompt.call.present?
+        Rails.logger.debug "Calling #{current_prompt.call} with input: #{input}"
+        current_prompt.call.new(self).call(input).tap do |response|
+          if response.present?
+            transcript << { assistant: response }
+            @last_response = send(current_prompt.name, response)
+          end
+        end
+      else
+        __system_prompt = instance_exec(&current_prompt.system) if current_prompt.system.present? # rubocop:disable Lint/UnderscorePrefixedVariableName
         __system_prompt ||= system_prompt if respond_to?(:system_prompt)
         __system_prompt ||= self.class.system_prompt.presence
         transcript << { system: __system_prompt } if __system_prompt
-        transcript << { user: instance_exec(&@current_prompt.text) } # text is required
+        transcript << { user: instance_exec(&current_prompt.text) } # text is required
 
-        params = @current_prompt.params.merge(params)
+        params = current_prompt.params.merge(params)
 
         # set the stream if necessary
-        self.stream = instance_exec(&@current_prompt.stream) if @current_prompt.stream.present?
+        self.stream = instance_exec(&current_prompt.stream) if current_prompt.stream.present?
 
-        super(params:, raw:).then do |response|
-          transcript << { assistant: response }
-          @last_response = send(@current_prompt.name, response)
-        end
+        execute_ai_request(params:, raw:, openai:, transcript:, loop_count:)
       end
 
-      @last_response
+      next unless current_prompt.until.present? && !instance_exec(&current_prompt.until)
+
+      if loop_count >= MAX_LOOP_COUNT
+        Honeybadger.notify(
+          "Max loop count reached in chat_completion. Forcing return.",
+          context: {
+            current_prompts:,
+            prompt:,
+            usage_subject: usage_subject.inspect,
+            last_response: Current.or_response
+          }
+        )
+
+        return last_response
+      else
+        current_prompts.unshift(@current_prompt) # put it back at the front
+        loop_count += 1
+      end
     end
 
-    # Returns the model parameter of the current prompt or the default model.
-    #
-    # @return [Object] The model parameter of the current prompt or the default model.
-    def model
-      @current_prompt.params[:model] || super
-    end
+    last_response
+  end
 
-    # Returns the temperature parameter of the current prompt or the default temperature.
-    #
-    # @return [Float] The temperature parameter of the current prompt or the default temperature.
-    def temperature
-      @current_prompt.params[:temperature] || super
+  def execute_ai_request(params:, raw:, openai:, transcript:, loop_count:)
+    chat_completion_from_superclass(params:, raw:, openai:).then do |response|
+      transcript << { assistant: response }
+      @last_response = send(current_prompt.name, response)
+      self.stream = nil # clear it again so it's not used for the next prompt
     end
+  rescue Conversation::StreamError => e
+    # Bubbles the error up the stack if no loops remain
+    raise Faraday::ServerError.new(nil, { status: e.status, body: e.response }) if loop_count >= MAX_LOOP_COUNT
 
-    # Returns the max_tokens parameter of the current prompt or the default max_tokens.
-    #
-    # @return [Integer] The max_tokens parameter of the current prompt or the default max_tokens.
-    def max_tokens
-      @current_prompt.params[:max_tokens] || super
-    end
+    sleep 1.second # Wait before continuing
+  end
+
+  # Returns the model parameter of the current prompt or the default model.
+  #
+  # @return [Object] The model parameter of the current prompt or the default model.
+  def model
+    @current_prompt.params[:model] || super
+  end
+
+  # Returns the temperature parameter of the current prompt or the default temperature.
+  #
+  # @return [Float] The temperature parameter of the current prompt or the default temperature.
+  def temperature
+    @current_prompt.params[:temperature] || super
+  end
+
+  # Returns the max_tokens parameter of the current prompt or the default max_tokens.
+  #
+  # @return [Integer] The max_tokens parameter of the current prompt or the default max_tokens.
+  def max_tokens
+    @current_prompt.params[:max_tokens] || super
+  end
+
+  protected
+
+  # workaround for super.chat_completion, which is not available in ruby
+  def chat_completion_from_superclass(*args, **kargs)
+    method(:chat_completion).super_method.call(*args, **kargs)
   end
 end

data/lib/raix/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: '0.5'
+  version: '0.7'
 platform: ruby
 authors:
 - Obie Fernandez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-10 00:00:00.000000000 Z
+date: 2025-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -68,6 +68,7 @@ files:
 - Gemfile.lock
 - Guardfile
 - LICENSE.txt
+- README.llm
 - README.md
 - Rakefile
 - lib/raix.rb