raix 0.8.1 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2de11b289a7c245c49e865735e1abc67ff671f02a9f23fb89d262d3ff83e6157
-  data.tar.gz: f8cd493f6f018ddd6b981f944786635b6800ca9beac4480e0a4c3c08bb7b8392
+  metadata.gz: 29fc354187c6971947ca178f55eae07ec23af8f2f3435dec89e58a9231de5a94
+  data.tar.gz: 70c5289b69f81f741b3e41fd1bb69d081f22e78aa65de34e8cb11c6190e700c3
 SHA512:
-  metadata.gz: 4d26f6ffad99abb7eaf6c8ef072393d75625e4762206d0d1f94c811e9d44747fa2e9048d5a8951484ded2861ecd5ebac69ea39bf6163432a411e2f9e427b0533
-  data.tar.gz: 893d062ab1f23b6c6a47dc715a7c98a3886dbe092645642e74bdb97ad80b2b4f637305b95acc6e6a8984cfe6defcdf020410233f5f818cba16bbbd0c5f49b5ed
+  metadata.gz: 4fbeb53566e02702163055d966e4ed14e8bc4a76a2ebb76191bcfea6175e250943c55817e1cbe4325c42a890c261365231f984bf1ce3855af6929a640457ca15
+  data.tar.gz: 942185162e40960170e64c5c4d93edc58ba37429efb0b19ded2f997fa60d70d2aaafad1788694d964ba5173e0ef0dfbab781b6e61c17f6e996f7dad083984197

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.8.3] - 2025-04-30
+- Adds optional ActiveSupport Cache parameter to `dispatch_tool_function` for caching tool calls
+
+## [0.8.2] - 2025-04-29
+- Extracts function call dispatch into a public `dispatch_tool_function` that can be overridden in subclasses
+- Uses `public_send` instead of `send` for better security and explicitness
+
 ## [0.8.1] - 2025-04-24
 Added ability to filter tool functions (or disable completely) when calling `chat_completion`. Thanks to @parruda for the contribution.
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    raix (0.8.1)
+    raix (0.8.3)
       activesupport (>= 6.0)
       faraday-retry (~> 2.0)
       open_router (~> 0.2)

data/README.md

@@ -206,6 +206,59 @@ example.invocations
 # => [:first, :second]
 ```
 
+#### Customizing Function Dispatch
+
+You can customize how function calls are handled by overriding the `dispatch_tool_function` in your class. This is useful if you need to add logging, caching, error handling, or other custom behavior around function calls.
+
+```ruby
+class CustomDispatchExample
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :example_tool do |arguments|
+    "Result from example tool"
+  end
+
+  def dispatch_tool_function(function_name, arguments)
+    puts "Calling #{function_name} with #{arguments}"
+    result = super
+    puts "Result: #{result}"
+    result
+  end
+end
+
+#### Function Call Caching
+
+You can use ActiveSupport's Cache to cache function call results, which can be particularly useful for expensive operations or external API calls that don't need to be repeated frequently.
+
+```ruby
+class CachedFunctionExample
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :expensive_operation do |arguments|
+    "Result of expensive operation with #{arguments}"
+  end
+  
+  # Override dispatch_tool_function to enable caching for all functions
+  def dispatch_tool_function(function_name, arguments)
+    # Pass the cache to the superclass implementation
+    super(function_name, arguments, cache: Rails.cache)
+  end
+end
+```
+
+The caching mechanism works by:
+1. Passing the cache object through `dispatch_tool_function` to the function implementation
+2. Using the function name and arguments as cache keys
+3. Automatically fetching from cache when available or executing the function when not cached
+
+This is particularly useful for:
+- Expensive database operations
+- External API calls
+- Resource-intensive computations
+- Functions with deterministic outputs for the same inputs
+
 #### 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.

data/lib/raix/chat_completion.rb

@@ -132,7 +132,7 @@ module Raix
             function_name = tool_call["function"]["name"]
             raise "Unauthorized function call: #{function_name}" unless self.class.functions.map { |f| f[:name].to_sym }.include?(function_name.to_sym)
 
-            send(function_name, arguments.with_indifferent_access)
+            dispatch_tool_function(function_name, arguments.with_indifferent_access)
           end
         end
 
@@ -189,6 +189,17 @@ module Raix
       @transcript ||= []
     end
 
+    # Dispatches a tool function call with the given function name and arguments.
+    # This method can be overridden in subclasses to customize how function calls are handled.
+    #
+    # @param function_name [String] The name of the function to call
+    # @param arguments [Hash] The arguments to pass to the function
+    # @param cache [ActiveSupport::Cache] Optional cache object
+    # @return [Object] The result of the function call
+    def dispatch_tool_function(function_name, arguments, cache: nil)
+      public_send(function_name, arguments, cache)
+    end
+
     private
 
     def filtered_tools(tool_names)

data/lib/raix/function_dispatch.rb

@@ -54,35 +54,41 @@ module Raix
           end
         end
 
-        define_method(name) do |arguments|
+        define_method(name) do |arguments, cache|
           id = SecureRandom.uuid[0, 23]
-          instance_exec(arguments, &block).tap do |content|
-            # add in one operation to prevent race condition and potential wrong
-            # interleaving of tool calls in multi-threaded environments
-            transcript << [
-              {
-                role: "assistant",
-                content: nil,
-                tool_calls: [
-                  {
-                    id:,
-                    type: "function",
-                    function: {
-                      name:,
-                      arguments: arguments.to_json
-                    }
+
+          content = if cache.present?
+                      cache.fetch([name, arguments]) do
+                        instance_exec(arguments, &block)
+                      end
+                    else
+                      instance_exec(arguments, &block)
+                    end
+
+          # add in one operation to prevent race condition and potential wrong
+          # interleaving of tool calls in multi-threaded environments
+          transcript << [
+            {
+              role: "assistant",
+              content: nil,
+              tool_calls: [
+                {
+                  id:,
+                  type: "function",
+                  function: {
+                    name:,
+                    arguments: arguments.to_json
                   }
-                ]
-              },
-              {
-                role: "tool",
-                tool_call_id: id,
-                name:,
-                content: content.to_s
-              }
-            ]
-            # TODO: add on_error handler as optional parameter to function
-          end
+                }
+              ]
+            },
+            {
+              role: "tool",
+              tool_call_id: id,
+              name:,
+              content: content.to_s
+            }
+          ]
 
           chat_completion(**chat_completion_args) if loop
         end

data/lib/raix/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.8.3
 platform: ruby
 authors:
 - Obie Fernandez
 bindir: exe
 cert_chain: []
-date: 2025-04-25 00:00:00.000000000 Z
+date: 2025-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport