raix 0.6 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bb905086f308c10375b54337b9cb4effe9387ed7e7a6a0dd84875176984e29c
-  data.tar.gz: dbc3b0d67aa91d8dc9b8ba9504b84d52617529c2a8e69fd0d21f3ad4e59df31d
+  metadata.gz: 9a2990e8225edcfbcc5007aae41a0dd69987bff18bd085bb9c486561e5597044
+  data.tar.gz: 60ef3efa8eb6cbe1b445afd09fc65a4b1d6fc62c872588956baee46b511d79d3
 SHA512:
-  metadata.gz: cbbaebe7bd8d18d2cd82b41b7a4bcf468eda1483485b2a707ff980d51068dea1e9ef5e20510dc7dd46bf1982fc7db14054399919842a28930cb12e37fa016022
-  data.tar.gz: 61037ede25456a15053e96dc1bae11125a9d3e0d5dc08e255087c9b69a2c4d096fc2e95d27f600a955bd93b421d8ed703b7c7b0df8de35812b82dbf9f0818858
+  metadata.gz: dfa0a7dfed2782d49c95f749c847b024ef41097b4ab318b34f9eabbfd9f754cf49c6eb859c1b14534332efea930d707df457e2d24a4c1f30f043d7dacb3c801c
+  data.tar.gz: 2e291a98b2ed5e25c2381a30d609e4277cb94458531c03e77b79fc95e70ee92e40c0d9cacb31809a1f7acca860550e4d02698856321869144dc56a4d794ea3d8

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

data/CHANGELOG.md

@@ -1,4 +1,22 @@
-## [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
+- 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

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    raix (0.6)
+    raix (0.7.1)
       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
@@ -74,6 +78,26 @@ Note that there is a limit of four breakpoints, and the cache will expire within
     },
 ```
 
+### JSON Mode
+
+Raix supports JSON mode for chat completions, which ensures that the AI model's response is valid JSON. This is particularly useful when you need structured data from the model.
+
+When using JSON mode with OpenAI models, Raix will automatically set the `response_format` parameter on requests accordingly, and attempt to parse the entire response body as JSON.
+When using JSON mode with other models (e.g. Anthropic) that don't support `response_format`, Raix will look for JSON content inside of <json> XML tags in the response, before
+falling back to parsing the entire response body. Make sure you tell the AI to reply with JSON inside of XML tags.
+
+```ruby
+>> my_class.chat_completion(json: true)
+=> { "key": "value" }
+```
+
+When using JSON mode with non-OpenAI providers, Raix automatically sets the `require_parameters` flag to ensure proper JSON formatting. You can also combine JSON mode with other parameters:
+
+```ruby
+>> my_class.chat_completion(json: true, openai: "gpt-4o")
+=> { "key": "value" }
+```
+
 ### Use of Tools/Functions
 
 The second (optional) module that you can add to your Ruby classes after `ChatCompletion` is `FunctionDispatch`. It lets you declare and implement functions to be called at the AI's discretion as part of a chat completion "loop" in a declarative, Rails-like "DSL" fashion.
@@ -105,26 +129,39 @@ Note that for security reasons, dispatching functions only works with functions
 
 #### Multiple Tool Calls
 
-Some AI models (like GPT-4) can make multiple tool calls in a single response. When this happens, Raix will automatically handle all the function calls sequentially and return an array of their results. Here's an example:
+Some AI models (like GPT-4) can make multiple tool calls in a single response. When this happens, Raix will automatically handle all the function calls sequentially.
+If you need to capture the arguments to the function calls, do so in the block passed to `function`. The response from `chat_completion` is always the final text
+response from the assistant, and is not affected by function calls.
 
 ```ruby
 class MultipleToolExample
   include Raix::ChatCompletion
   include Raix::FunctionDispatch
 
+  attr_reader :invocations
+
   function :first_tool do |arguments|
+    @invocations << :first
     "Result from first tool"
   end
 
   function :second_tool do |arguments|
+    @invocations << :second
     "Result from second tool"
   end
+
+  def initialize
+    @invocations = []
+  end
 end
 
 example = MultipleToolExample.new
 example.transcript << { user: "Please use both tools" }
-results = example.chat_completion(openai: "gpt-4o")
-# => ["Result from first tool", "Result from second tool"]
+example.chat_completion(openai: "gpt-4o")
+# => "I used both tools, as requested"
+
+example.invocations
+# => [:first, :second]
 ```
 
 #### Manually Stopping a Loop
@@ -222,7 +259,6 @@ class PromptSubscriber
   end
 
   ...
-
 end
 
 class FetchUrlCheck
@@ -264,6 +300,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 +528,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,7 +40,7 @@ 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.
@@ -124,9 +124,12 @@ module Raix
           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/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.6"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: '0.6'
+  version: 0.7.1
 platform: ruby
 authors:
 - Obie Fernandez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-04-14 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