raix 0.4.3 → 0.4.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 65adb56d006baa2b25193eaa5f87f52b24366876139d1e023c9031e7707f62ea
-  data.tar.gz: 545da8c28e699f87e53547b53d07fb934727948945f45998f3af5d34752a2854
+  metadata.gz: 27b3ab0bd21ca08ecf0b23985b1e04b1787cfdb60e534744ff32234869930989
+  data.tar.gz: 822f7fe8ac7c76ce77aefff637b9d5e3163b904073329bcfb99e6d3661d38c48
 SHA512:
-  metadata.gz: 71a14254199a7e0eeb8195b842fe212516091743ab4799f349caadfeffa654eede58dc066813e4d1360c24b2384406f934086d9b167b45db70a618470c94df84
-  data.tar.gz: 3d5a8033107bc8037862d11cd88fb3cd7a67a6884b4f7d2d8756244ac676e938094a6580bd55275b353c0b12389f292cbe958138d8d13f2d1001c5befb81662d
+  metadata.gz: 2d469ff07f10f1085c40f4bc456c91f753e65b09304757eb95e77fe73df13c5ba334bdfa22f3649160c863e6ff268cde4e595f92221556a7d2761667e2a35d3c
+  data.tar.gz: a8e367b6e85adee53056ead496c97806deaba156dcab82634763c773f52e8d4e5c60c213669bdc3d8620c301e22b24862ec7f01fe77ee7c880b633b3d919b30c

data/CHANGELOG.md

@@ -21,3 +21,10 @@
 
 ## [0.4.3] - 2024-11-11
 - adds support for `Predicate` module
+
+## [0.4.4] - 2024-11-11
+- adds support for multiple tool calls in a single response
+
+## [0.4.5] - 2024-11-11
+- adds support for `ResponseFormat`
+- added some missing requires to support String#squish

data/Gemfile.lock

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

data/README.md

@@ -101,6 +101,30 @@ RSpec.describe WhatIsTheWeather do
 end
 ```
 
+#### 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:
+
+```ruby
+class MultipleToolExample
+  include Raix::ChatCompletion
+  include Raix::FunctionDispatch
+
+  function :first_tool do |arguments|
+    "Result from first tool"
+  end
+
+  function :second_tool do |arguments|
+    "Result from second tool"
+  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"]
+```
+
 #### 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.
@@ -309,6 +333,97 @@ question.ask("Any question")
 # => RuntimeError: Please define a yes and/or no block
 ```
 
+## Response Format (Experimental)
+
+The `ResponseFormat` class provides a way to declare a JSON schema for the response format of an AI chat completion. It's particularly useful when you need structured responses from AI models, ensuring the output conforms to your application's requirements.
+
+### Features
+
+- Converts Ruby hashes and arrays into JSON schema format
+- Supports nested structures and arrays
+- Enforces strict validation with `additionalProperties: false`
+- Automatically marks all top-level properties as required
+- Handles both simple type definitions and complex nested schemas
+
+### Basic Usage
+
+```ruby
+# Simple schema with basic types
+format = Raix::ResponseFormat.new("PersonInfo", {
+  name: { type: "string" },
+  age: { type: "integer" }
+})
+
+# Use in chat completion
+my_ai.chat_completion(response_format: format)
+```
+
+### Complex Structures
+
+```ruby
+# Nested structure with arrays
+format = Raix::ResponseFormat.new("CompanyInfo", {
+  company: {
+    name: { type: "string" },
+    employees: [
+      {
+        name: { type: "string" },
+        role: { type: "string" },
+        skills: ["string"]
+      }
+    ],
+    locations: ["string"]
+  }
+})
+```
+
+### Generated Schema
+
+The ResponseFormat class generates a schema that follows this structure:
+
+```json
+{
+  "type": "json_schema",
+  "json_schema": {
+    "name": "SchemaName",
+    "schema": {
+      "type": "object",
+      "properties": {
+        "property1": { "type": "string" },
+        "property2": { "type": "integer" }
+      },
+      "required": ["property1", "property2"],
+      "additionalProperties": false
+    },
+    "strict": true
+  }
+}
+```
+
+### Using with Chat Completion
+
+When used with chat completion, the AI model will format its response according to your schema:
+
+```ruby
+class StructuredResponse
+  include Raix::ChatCompletion
+
+  def analyze_person(name)
+    format = Raix::ResponseFormat.new("PersonAnalysis", {
+      full_name: { type: "string" },
+      age_estimate: { type: "integer" },
+      personality_traits: ["string"]
+    })
+
+    transcript << { user: "Analyze the person named #{name}" }
+    chat_completion(response_format: format)
+  end
+end
+
+response = StructuredResponse.new.analyze_person("Alice")
+# Returns a hash matching the defined schema
+```
+
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:

data/lib/raix/chat_completion.rb

@@ -2,6 +2,7 @@
 
 require "active_support/concern"
 require "active_support/core_ext/object/blank"
+require "active_support/core_ext/string/filters"
 require "open_router"
 require "openai"
 
@@ -12,10 +13,22 @@ module Raix
   # with the OpenRouter Chat Completion API via its client. The module includes a few
   # methods that allow you to build a transcript of messages and then send them to
   # the API for completion. The API will return a response that you can use however
-  # you see fit. If the response includes a function call, the module will dispatch
-  # the function call and return the result. Which implies that function calls need
-  # to be defined on the class that includes this module. (Note: You should probably
-  # use the `FunctionDispatch` module to define functions instead of doing it manually.)
+  # you see fit.
+  #
+  # If the response includes a function call, the module will dispatch the function
+  # call and return the result. Which implies that function calls need to be defined
+  # on the class that includes this module. The `FunctionDispatch` module provides a
+  # Rails-like DSL for declaring and implementing tool functions at the top of your
+  # class instead of having to manually implement them as instance methods. The
+  # primary benefit of using the `FunctionDispatch` module is that it handles
+  # adding the function call results to the ongoing conversation transcript for you.
+  # It also triggers a new chat completion automatically if you've set the `loop`
+  # option to `true`, which is useful for implementing conversational chatbots that
+  # include tool calls.
+  #
+  # Note that some AI models can make more than a single tool function call in a
+  # single response. When that happens, the module will dispatch all of the function
+  # calls sequentially and return an array of results.
   module ChatCompletion
     extend ActiveSupport::Concern
 
@@ -92,13 +105,13 @@ module Raix
         # TODO: add a standardized callback hook for usage events
         # broadcast(:usage_event, usage_subject, self.class.name.to_s, response, premium?)
 
-        # TODO: handle parallel tool calls
-        if (function = response.dig("choices", 0, "message", "tool_calls", 0, "function"))
-          @current_function = function["name"]
-          # dispatch the called function
-          arguments = JSON.parse(function["arguments"].presence || "{}")
-          arguments[:bot_message] = bot_message if respond_to?(:bot_message)
-          return send(function["name"], arguments.with_indifferent_access)
+        tool_calls = response.dig("choices", 0, "message", "tool_calls") || []
+        if tool_calls.any?
+          return tool_calls.map do |tool_call|
+            # dispatch the called function
+            arguments = JSON.parse(tool_call["function"]["arguments"].presence || "{}")
+            send(tool_call["function"]["name"], arguments.with_indifferent_access)
+          end
         end
 
         response.tap do |res|

data/lib/raix/prompt_declarations.rb

@@ -1,6 +1,7 @@
 # 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

data/lib/raix/response_format.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/deep_dup"
+require "active_support/core_ext/string/filters"
 
 module Raix
   # Handles the formatting of responses for AI interactions.

data/lib/raix/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: raix
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.5
 platform: ruby
 authors:
 - Obie Fernandez