rach 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7f427f0e11f94e869ea14d6d7ed35bd5d73311212fd958daa52b1d8964886fc3
+  data.tar.gz: b0fbf4e2dfcc18c9aa39c6e23b8ebc5edafa62deb125a4b0d25bb0c0eeb5ba4c
+SHA512:
+  metadata.gz: 0abf7aa58e283fa66cf18b322c9711f250365760b6f77b25d1276e77daf28a0f0640f98050b0bc2ccee38b181735398572e21c95d3f0872a770e6f545ce40cd5
+  data.tar.gz: 2a2553158981ff4f425ada8381c3e61635f302faf5b88c9d952247a60ea126dda4ddc91440dd32324194a94a80d86aad283d0a74bc2a1b3c48066348447f96ae

data/README.md

@@ -0,0 +1,12 @@
+# Rach
+
+A lightweight Ruby framework for OpenAI interactions, focusing on simplicity and clean design.
+
+
+## Configuration
+
+1. Copy the example environment file:
+```
+cp .env.example .env
+```
+2. Set your OpenAI API key in the `.env` file.

data/lib/rach/client.rb

@@ -0,0 +1,44 @@
+module Rach
+  class Client
+    attr_reader :tracker, :client, :model
+
+    def initialize(access_token:, model: "gpt-4o-mini")
+      @client = OpenAI::Client.new(log_errors: true, access_token: access_token)
+      @model = model
+      @tracker = UsageTracker.new
+    end
+
+    def chat(prompt, response_format: nil, tools: nil)
+      messages = format_messages(prompt)
+      
+      response = Response.new(
+        @client.chat(
+          parameters: {
+            model: @model,
+            messages:,
+            response_format:,
+            tools:,
+          }.compact
+        )
+      )
+      
+      @tracker.track(response)
+      response
+    end
+
+    private
+
+    def format_messages(prompt)
+      case prompt
+      when String
+        [{ role: "user", content: prompt }]
+      when Message
+        [prompt.to_h]
+      when Conversation
+        prompt.to_a
+      else
+        raise ArgumentError, "prompt must be a String, Message, or Conversation"
+      end
+    end
+  end
+end

data/lib/rach/conversation.rb

@@ -0,0 +1,49 @@
+module Rach
+  class Conversation
+    def initialize
+      @messages = []
+    end
+
+    def add_message(message)
+      raise ArgumentError, "Expected Message object" unless message.is_a?(Message)
+      @messages << message
+      self
+    end
+
+    def add_response(response)
+      assistant(response.content)
+    end
+
+    def add(content, role: "user")
+      add_message(Message.new(content: content, role: role))
+    end
+
+    def system(content)
+      add(content, role: "system")
+      self
+    end
+
+    def user(content)
+      add(content, role: "user")
+      self
+    end
+
+    def assistant(content)
+      add(content, role: "assistant")
+      self
+    end
+
+    def to_a
+      @messages.map(&:to_h)
+    end
+
+    def clear
+      @messages.clear
+      self
+    end
+
+    def empty?
+      @messages.empty?
+    end
+  end
+end

data/lib/rach/errors.rb

@@ -0,0 +1,4 @@
+module Rach
+  class Error < StandardError; end
+  class ParseError < Error; end
+end

data/lib/rach/function.rb

@@ -0,0 +1,84 @@
+module Rach
+  module Function
+    def self.included(base)
+      require 'json/schema_builder'
+      base.include JSON::SchemaBuilder
+      base.extend ClassMethods
+      
+      # Register the function when included
+      functions << base
+    end
+
+    # Add function registry
+    def self.functions
+      @functions ||= []
+    end
+
+    # Add function lookup method
+    def self.find_by_name(name)
+      functions.find { |func| func.new.function_name == name }
+    end
+
+    module ClassMethods
+      def function_schema
+        schema = new.schema
+        {
+          type: "function",
+          function: {
+            name: new.function_name,
+            description: new.function_description,
+            parameters: prepare_schema_for_function(schema)
+          }
+        }
+      end
+
+      private
+
+      def prepare_schema_for_function(schema)
+        schema.additional_properties(false)
+        schema_hash = schema.as_json.deep_symbolize_keys
+        
+        # Set required fields and additional properties
+        deep_set_object_properties(schema_hash)
+        
+        schema_hash
+      end
+
+      def deep_set_object_properties(schema_hash)
+        return unless schema_hash.is_a?(Hash)
+
+        if schema_hash[:type] == "object"
+          schema_hash[:additionalProperties] = false
+          if schema_hash[:properties]
+            schema_hash[:required] = schema_hash[:properties].keys
+          end
+        end
+
+        schema_hash.each_value do |value|
+          if value.is_a?(Hash)
+            deep_set_object_properties(value)
+          elsif value.is_a?(Array)
+            value.each { |item| deep_set_object_properties(item) }
+          end
+        end
+      end
+    end
+
+    # Instance methods that must be implemented by including class
+    def schema
+      raise NotImplementedError, "#{self.class} must implement #schema"
+    end
+
+    def execute(**args)
+      raise NotImplementedError, "#{self.class} must implement #execute"
+    end
+
+    def function_name
+      raise NotImplementedError, "#{self.class} must implement #function_name"
+    end
+
+    def function_description
+      raise NotImplementedError, "#{self.class} must implement #function_description"
+    end
+  end
+end

data/lib/rach/message.rb

@@ -0,0 +1,17 @@
+module Rach
+  class Message
+    attr_reader :role, :content
+
+    def initialize(content:, role: "user")
+      @content = content
+      @role = role
+    end
+
+    def to_h
+      {
+        role: role,
+        content: content
+      }
+    end
+  end
+end

data/lib/rach/message_template.rb

@@ -0,0 +1,21 @@
+module Rach
+  class MessageTemplate
+    def initialize(template, role: "user")
+      @template = template
+      @role = role
+    end
+
+    def render(variables = {})
+      interpolated = interpolate(@template, variables)
+      Message.new(content: interpolated, role: @role)
+    end
+
+    private
+
+    def interpolate(text, variables)
+      variables.reduce(text) do |result, (key, value)|
+        result.gsub(/\{\{#{key}\}\}/, value.to_s)
+      end
+    end
+  end
+end

data/lib/rach/response.rb

@@ -0,0 +1,61 @@
+module Rach
+  class Response
+    attr_reader :raw_response
+
+    def initialize(response)
+      @raw_response = response
+    end
+
+    def content
+      message&.dig("content")
+    end
+
+    def tool_calls
+      message&.dig("tool_calls")
+    end
+
+    def function_call?
+      !tool_calls.nil? && !tool_calls.empty?
+    end
+
+    def function_name
+      return nil unless function_call?
+      tool_calls.first.dig("function", "name")
+    end
+
+    def function_arguments
+      return nil unless function_call?
+      JSON.parse(tool_calls.first.dig("function", "arguments"))
+    rescue JSON::ParserError
+      raise ParseError, "Function arguments are not valid JSON"
+    end
+
+    def usage
+      @raw_response["usage"]
+    end
+
+    def prompt_tokens
+      usage&.fetch("prompt_tokens", 0)
+    end
+
+    def completion_tokens
+      usage&.fetch("completion_tokens", 0)
+    end
+
+    def total_tokens
+      usage&.fetch("total_tokens", 0)
+    end
+
+    private
+
+    def message
+      @raw_response.dig("choices", 0, "message")
+    end
+
+    def to_json
+      JSON.parse(content)
+    rescue JSON::ParserError
+      raise ParseError, "Response is not valid JSON"
+    end
+  end
+end

data/lib/rach/response_format.rb

@@ -0,0 +1,57 @@
+module Rach
+  module ResponseFormat
+    def self.included(base)
+      require 'json/schema_builder'
+      base.include JSON::SchemaBuilder
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def render(schema_name)
+        base_schema = new.public_send(schema_name)
+        schema = prepare_schema_for_api(base_schema)
+        
+        {
+          type: "json_schema",
+          json_schema: {
+            name: schema_name.to_s,
+            schema:,
+            strict: true
+          },
+        }
+      end
+
+      private
+
+      def prepare_schema_for_api(schema)
+        schema.additional_properties(false)
+        schema_hash = schema.as_json.deep_symbolize_keys
+        
+        # Recursively set additional_properties: false and required for all objects
+        deep_set_object_properties(schema_hash)
+        
+        schema_hash
+      end
+
+      def deep_set_object_properties(schema_hash)
+        return unless schema_hash.is_a?(Hash)
+
+        if schema_hash[:type] == "object"
+          schema_hash[:additionalProperties] = false
+          # Set required to include all properties if properties exist
+          if schema_hash[:properties]
+            schema_hash[:required] = schema_hash[:properties].keys
+          end
+        end
+
+        schema_hash.each_value do |value|
+          if value.is_a?(Hash)
+            deep_set_object_properties(value)
+          elsif value.is_a?(Array)
+            value.each { |item| deep_set_object_properties(item) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rach/usage_tracker.rb

@@ -0,0 +1,35 @@
+module Rach
+  class UsageTracker
+    def initialize
+      @total_prompt_tokens = 0
+      @total_completion_tokens = 0
+      @total_tokens = 0
+      @total_cached_tokens = 0
+      @total_reasoning_tokens = 0
+      @request_count = 0
+    end
+
+    def track(response)
+      return unless response.usage
+
+      @total_prompt_tokens += response.prompt_tokens
+      @total_completion_tokens += response.completion_tokens
+      @total_tokens += response.total_tokens
+      @total_cached_tokens += response.usage.dig("prompt_tokens_details", "cached_tokens") || 0
+      @total_reasoning_tokens += response.usage.dig("completion_tokens_details", "reasoning_tokens") || 0
+      @request_count += 1
+    end
+
+    def stats
+      {
+        prompt_tokens: @total_prompt_tokens,
+        completion_tokens: @total_completion_tokens,
+        total_tokens: @total_tokens,
+        cached_tokens: @total_cached_tokens,
+        reasoning_tokens: @total_reasoning_tokens,
+        request_count: @request_count,
+        average_tokens_per_request: @request_count > 0 ? (@total_tokens.to_f / @request_count).round(2) : 0
+      }
+    end
+  end
+end

data/lib/rach/version.rb

@@ -0,0 +1,3 @@
+module Rach
+  VERSION = "0.1.0"
+end

data/lib/rach.rb

@@ -0,0 +1,16 @@
+require 'openai'
+
+require_relative "rach/version"
+require_relative "rach/client"
+require_relative "rach/errors"
+require_relative "rach/response"
+require_relative "rach/message"
+require_relative "rach/message_template"
+require_relative "rach/response_format"
+require_relative "rach/conversation"
+require_relative "rach/usage_tracker"
+require_relative "rach/function"
+
+module Rach
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: rach
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Roger Garcia
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '7.3'
+description: Rach is a lightweight framework for orchestrating AI agents
+email:
+- rach@rogergarcia.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/rach.rb
+- lib/rach/client.rb
+- lib/rach/conversation.rb
+- lib/rach/errors.rb
+- lib/rach/function.rb
+- lib/rach/message.rb
+- lib/rach/message_template.rb
+- lib/rach/response.rb
+- lib/rach/response_format.rb
+- lib/rach/usage_tracker.rb
+- lib/rach/version.rb
+homepage: https://github.com/roginn/rach
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Orchestrate AI agents like a virtuoso
+test_files: []