rach 0.2.0 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54430271658860452dad9e146c8aed72752de64c546a888b5784724bc47fb1c8
-  data.tar.gz: 34ea312840fa1b5aa08104f3f3696cacad5a2488039bd1d99e87c48c7949650b
+  metadata.gz: 9e0ae465e2ccd6c5f2c56690cd7ee0a7c7fd7dd892df5e08091f678a9c2a9f32
+  data.tar.gz: d9f5054384e3b7d510f7046ff306a99b5a84b1831ca9dbafe1189c750d268b4d
 SHA512:
-  metadata.gz: b7ced2382782e8f422d1c959f5ca6a7348110f542fd9d50cd9a350c3177575583a26641599ff5b584fba4f8fe6219b27bf2a610966a6bb941404026f97919516
-  data.tar.gz: 718302171ac286fe03df1030f745bcdac07e3b319bb09f15abb034d6258bf2f32a7c46ac2dfb6063d7ff385d4935968eb94ffd4a00a3f4b03708e57318f07d60
+  metadata.gz: f34a357311318ab7086b8cdf42e75ad070897bb1b9bfdad8b07394d85e5894a908e58a96ac51774cfe9334e26c29b2d3b7a7b7c7954004b7fedd188a5cb54ace
+  data.tar.gz: 87ae8011f8c9efcfb025d4019e6343764175915b162b68c281be9b528ef05898cbf1c88384dc865ab79be1ec1b88597b81faec288a6196c214d2da9a058317fa

data/README.md

@@ -26,9 +26,10 @@ $ gem install rach
 
 ```ruby
 require 'rach'
-client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY)
+client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY, model: "gpt-4o")
 response = client.chat("Hello, how are you?")
 puts response.content
+# => "Hello! I'm just a computer program, so I don't have feelings, but I'm here and ready to help you. How can I assist you today?"
 ```
 
 ### Conversations
@@ -38,7 +39,7 @@ Rach supports stateful conversations with memory:
 ```ruby
 require 'rach'
 
-client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY)
+client = Rach::Client.new(access_token: YOUR_OPENAI_API_KEY, model: "gpt-4o")
 convo = Rach::Conversation.new
 convo.system "You teach the German language."
 convo.user "Translate: There are two birds singing outside my window."
@@ -47,17 +48,19 @@ response = client.chat(convo)
 response.content
 # => "Es gibt zwei Vögel, die draußen vor meinem Fenster singen."
 
-convo.add_response(response)
-
 # Continue the conversation...
+convo.add_response(response)
 convo.user "What are the verbs in your translation?"
-client.chat(convo)
-
+response = client.chat(convo)
+response.content
+# => "The verbs in the translation \"Es gibt zwei Vögel, die vor meinem Fenster singen\" are \"gibt\" and \"singen.\""
 
 # Remove the last message from the conversation history and continue
 convo.pop
 convo.user "Explain the structure of your translation."
-client.chat(convo)
+response = client.chat(convo)
+response.content
+# => "Your last message to me was: \"Translate: There are two birds singing outside my window.\""
 ```
 
 ### Response Formatting
@@ -120,6 +123,69 @@ response.tool_calls
 #   "function"=>{"name"=>"get_current_weather", "arguments"=>"{\"location\":\"San Francisco, CA\",\"unit\":\"celsius\"}"}}]
 ```
 
+### Multiple Providers
+
+Rach supports using multiple providers in your application. You can configure different providers and their parameters when creating a client:
+
+```ruby
+client = Rach::Client.new(
+  providers: {
+    openai: {
+      access_token: YOUR_OPENAI_API_KEY
+    },
+    anthropic: {
+      access_token: YOUR_ANTHROPIC_API_KEY
+    }
+  }
+)
+
+# Use specific provider
+response = client.chat("Hello!", model: "gpt-4o")
+puts response.content
+
+# Switch to another provider
+response = client.chat("Hi there!", model: "claude-3-5-sonnet-20241022")
+puts response.content
+```
+
+### Logging
+
+Rach supports logging of API calls and their parameters. You can provide any logger that responds to the `info` method:
+
+```ruby
+require 'logger'
+
+# Create a logger that writes to STDOUT
+logger = Logger.new(STDOUT)
+
+# Pass the logger when creating the client
+client = Rach::Client.new(
+  access_token: YOUR_OPENAI_API_KEY,
+  model: "gpt-4",
+  logger: logger
+)
+
+# Now when you make API calls, parameters will be logged
+client.chat("Hello!")
+# [2024-01-20T10:30:00.000Z] INFO: Making API call to openai
+# [2024-01-20T10:30:00.000Z] INFO: Request parameters: {:model=>"gpt-4", :messages=>[{:role=>"user", :content=>"Hello!"}], :temperature=>1.0}
+```
+
+You can also use your own custom logger as long as it responds to the `info` method:
+
+```ruby
+class CustomLogger
+  def info(message)
+    puts "[RACH] #{message}"
+  end
+end
+
+client = Rach::Client.new(
+  access_token: YOUR_OPENAI_API_KEY,
+  model: "gpt-4",
+  logger: CustomLogger.new
+)
+```
 
 ## License
 

data/lib/rach/client.rb

@@ -1,44 +1,57 @@
 module Rach
   class Client
-    attr_reader :tracker, :client, :model
+    attr_reader :tracker, :client, :model, :providers
+    attr_accessor :logger
 
-    def initialize(access_token:, model: "gpt-4o-mini")
-      @client = OpenAI::Client.new(log_errors: true, access_token: access_token)
-      @model = model
+    def initialize(providers: nil, access_token: nil, model: nil, logger: nil, **kwargs)
       @tracker = UsageTracker.new
+      @providers = {}
+      @logger = logger
+      @default_model = model
+
+      if providers
+        setup_providers(providers)
+      elsif access_token && model
+        provider = Provider.for(model)
+        setup_providers({ provider.key => { access_token: access_token } })
+      else
+        raise ArgumentError, "Either (providers) or (access_token AND model) must be provided"
+      end
     end
 
-    def chat(prompt, response_format: nil, tools: nil)
-      messages = format_messages(prompt)
-      formatted_tools = tools&.map(&:function_schema)
-      
-      response = Response.new(
-        @client.chat(
-          parameters: {
-            model: @model,
-            messages:,
-            response_format:,
-            tools: formatted_tools,
-          }.compact
-        )
-      )
-      
-      @tracker.track(response)
+    def chat(input, **options)
+      prompt = input.is_a?(Prompt) ? input : Prompt.new(input, **options)
+      model = prompt.model || @default_model
+
+      raise ArgumentError, "No model specified" unless model
+
+      provider_key = Provider.for(model).key
+      client = @providers[provider_key]
+
+      # Filter out options that are already handled by Prompt
+      filtered_options = options.reject { |k, _| [:model, :temperature, :response_format, :tools].include?(k) }
+
+      request_params = {
+        model:,
+        messages: prompt.to_messages,
+        response_format: prompt.response_format,
+        temperature: prompt.temperature,
+        tools: prompt.tools&.map(&:function_schema),
+        **filtered_options  # Pass through remaining options to the underlying client
+      }.compact
+
+
+      response = client.chat(parameters: request_params)
+      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"
+    def setup_providers(provider_configs)
+      provider_configs.each do |provider_key, config|
+        provider_class = Provider.get_provider_class(provider_key)
+        @providers[provider_class.key] = provider_class.new(logger: @logger, **config)
       end
     end
   end

data/lib/rach/prompt.rb

@@ -0,0 +1,26 @@
+module Rach
+  class Prompt
+    attr_reader :content, :model, :temperature, :response_format, :tools
+
+    def initialize(content, model: nil, temperature: 0, response_format: nil, tools: nil)
+      @content = content
+      @model = model
+      @temperature = temperature
+      @response_format = response_format
+      @tools = tools
+    end
+
+    def to_messages
+      case content
+      when String
+        [{ role: "user", content: content }]
+      when Message
+        [content.to_h]
+      when Conversation
+        content.to_a
+      else
+        raise ArgumentError, "content must be a String, Message, or Conversation"
+      end
+    end
+  end
+end

data/lib/rach/provider/anthropic.rb

@@ -0,0 +1,140 @@
+require 'securerandom'
+require 'json'
+
+module Rach
+  module Provider
+    class Anthropic < Base
+
+      def initialize(access_token: nil, logger: nil, **kwargs)
+        @client = create_client(access_token, **kwargs)
+        @logger = logger
+      end
+
+      def chat(**parameters)
+        # Extract system message if present
+        messages = parameters.dig(:parameters, :messages) || []
+        system_message = messages.find { |msg| msg[:role] == "system" }
+
+        # Remove system message from messages array if present
+        messages = messages.reject { |msg| msg[:role] == "system" } if system_message
+
+        # Convert messages to Anthropic format
+        messages = messages.map do |msg|
+          {
+            role: msg[:role] == "assistant" ? "assistant" : "user",
+            content: msg[:content]
+          }
+        end
+
+        temperature = (parameters.dig(:parameters, :temperature) || 1).clamp(0, 1)
+        max_tokens = parameters.dig(:parameters, :max_tokens) || 1024
+        tools = convert_tools(parameters.dig(:parameters, :tools))
+
+        anthropic_params = {
+          model: parameters.dig(:parameters, :model),
+          messages:,
+          temperature:,
+          max_tokens:,
+          tools:,
+          tool_choice: convert_tool_choice(tools),
+          system: system_message&.[](:content)
+        }.compact
+
+        if @logger
+          @logger.info("Making API call to Anthropic")
+          @logger.info("Request parameters: #{anthropic_params.inspect}")
+        end
+
+        raw_response = @client.messages(
+          parameters: anthropic_params.compact
+          # parameters: {
+          #   model: anthropic_params[:model],
+          #   messages: anthropic_params[:messages],
+          #   system: anthropic_params[:system],
+          #   temperature: anthropic_params[:temperature],
+          #   max_tokens: anthropic_params[:max_tokens],
+          #   tools: anthropic_params[:tools],
+          #   tool_choice: anthropic_params[:tool_choice],
+          # }.compact
+        )
+
+        if @logger
+          @logger.info("Request to Anthropic: #{JSON.pretty_generate(anthropic_params)}")
+          @logger.info("Response: #{JSON.pretty_generate(raw_response)}")
+        end
+
+        Response.new(
+          id: raw_response["id"],
+          model: raw_response["model"],
+          content: raw_response.dig("content", 0, "text"),
+          tool_calls: convert_tool_calls(raw_response["content"]),
+          usage: {
+            "prompt_tokens" => raw_response["usage"]["input_tokens"],
+            "completion_tokens" => raw_response["usage"]["output_tokens"],
+            "total_tokens" => raw_response["usage"]["input_tokens"] + raw_response["usage"]["output_tokens"]
+          },
+          raw_response: raw_response
+        )
+      end
+
+      def self.supports?(model)
+        model.start_with?("claude")
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        ::Anthropic::Client.new(
+          access_token: access_token,
+          **kwargs
+        )
+      end
+
+      def convert_tools(functions)
+        return nil if functions.nil?
+
+        functions.map do |fn|
+          {
+            name: fn[:function][:name],
+            description: fn[:function][:description],
+            input_schema: {
+              type: "object",
+              properties: fn[:function][:parameters][:properties],
+              required: fn[:function][:parameters][:required]
+            }
+          }
+        end
+      end
+
+      def convert_tool_calls(content)
+        return nil if content.nil?
+
+        tool_calls = content.select { |c| c["type"] == "tool_use" }
+        return nil if tool_calls.empty?
+
+        tool_calls.map do |call|
+          {
+            "id" => call["id"],
+            "type" => "function",
+            "function" => {
+              "name" => call["name"],
+              "arguments" => call["input"].to_json
+            }
+          }
+        end
+      end
+
+      def convert_tool_choice(tools)
+        if tools
+          if tools.size == 1
+            { type: "tool", name: tools.first[:name] }
+          else
+            { type: "any" }
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rach/provider/base.rb

@@ -0,0 +1,27 @@
+module Rach
+  module Provider
+    class Base
+      def initialize(access_token, **kwargs)
+        @client = create_client(access_token, **kwargs)
+      end
+
+      def self.key
+        name.split("::").last.downcase.to_sym
+      end
+
+      def self.supports?(model)
+        raise NotImplementedError
+      end
+
+      def chat(**parameters)
+        raise NotImplementedError
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rach/provider/openai.rb

@@ -0,0 +1,54 @@
+module Rach
+  module Provider
+    class OpenAI < Base
+
+      def initialize(access_token: nil, logger: nil, **kwargs)
+        @client = create_client(access_token, **kwargs)
+        @logger = logger
+      end
+
+      def chat(**parameters)
+        raw_response = @client.chat(**parameters)
+
+        if @logger
+          @logger.info("Request to OpenAI: #{JSON.pretty_generate(parameters)}")
+          @logger.info("Response: #{JSON.pretty_generate(raw_response)}")
+        end
+
+        Response.new(
+          id: raw_response["id"],
+          model: raw_response["model"],
+          created_at: Time.at(raw_response["created"]),
+          content: raw_response.dig("choices", 0, "message", "content"),
+          tool_calls: raw_response.dig("choices", 0, "message", "tool_calls"),
+          usage: raw_response["usage"],
+          system_fingerprint: raw_response["system_fingerprint"],
+          raw_response: raw_response
+        )
+      end
+
+      def self.supports?(model)
+        model.start_with?("gpt", "o1")
+      end
+
+      private
+
+      def create_client(access_token, **kwargs)
+        ::OpenAI::Client.new(
+          access_token: access_token,
+          log_errors: true,
+          **kwargs
+        )
+      end
+
+      def convert_params(parameters)
+        {
+          parameters: {
+            **parameters[:parameters],
+            tool_choice: parameters.dig(:parameters, :tools) ? "required" : nil
+          }.compact
+        }
+      end
+    end
+  end
+end

data/lib/rach/provider.rb

@@ -0,0 +1,27 @@
+module Rach
+  module Provider
+
+    AVAILABLE_PROVIDERS = [
+      Provider::OpenAI,
+      Provider::Anthropic
+    ].to_h { |p| [p.key, p] }.freeze
+
+    def self.for(model)
+      _key, provider_class = AVAILABLE_PROVIDERS.find { |_, p| p.supports?(model) }
+      raise ArgumentError, "Unsupported model: #{model}" unless provider_class
+
+      provider_class
+    end
+
+    def self.create_client(provider_key, access_token)
+      provider_class = get_provider_class(provider_key)
+      provider_class.new(access_token:)
+    end
+
+    def self.get_provider_class(key)
+      provider_class = AVAILABLE_PROVIDERS[key.to_sym]
+      raise ArgumentError, "Unknown provider: #{key}" unless provider_class
+      provider_class
+    end
+  end
+end

data/lib/rach/response.rb

@@ -1,17 +1,18 @@
 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")
+    attr_reader :id, :model, :created_at, :content, :tool_calls, :usage, 
+                :system_fingerprint, :raw_response, :request_params
+
+    def initialize(**options)
+      @id = options[:id]
+      @model = options[:model]
+      @created_at = options[:created_at]
+      @content = options[:content]
+      @tool_calls = options[:tool_calls]
+      @usage = options[:usage]
+      @system_fingerprint = options[:system_fingerprint]
+      @raw_response = options[:raw_response]
+      @request_params = options[:request_params]
     end
 
     def function_call?
@@ -30,10 +31,6 @@ module Rach
       raise ParseError, "Function arguments are not valid JSON"
     end
 
-    def usage
-      @raw_response["usage"]
-    end
-
     def prompt_tokens
       usage&.fetch("prompt_tokens", 0)
     end
@@ -65,10 +62,6 @@ module Rach
 
     private
 
-    def message
-      @raw_response.dig("choices", 0, "message")
-    end
-
     def to_json
       JSON.parse(content)
     rescue JSON::ParserError

data/lib/rach/version.rb

@@ -1,3 +1,4 @@
 module Rach
-  VERSION = "0.2.0"
+  VERSION = "0.2.6"
 end
+

data/lib/rach.rb

@@ -1,4 +1,5 @@
 require 'openai'
+require 'anthropic'
 
 require_relative "rach/version"
 require_relative "rach/client"
@@ -10,6 +11,11 @@ require_relative "rach/response_format"
 require_relative "rach/conversation"
 require_relative "rach/usage_tracker"
 require_relative "rach/function"
+require_relative "rach/provider/base"
+require_relative "rach/provider/openai"
+require_relative "rach/provider/anthropic"
+require_relative "rach/provider"
+require_relative "rach/prompt"
 
 module Rach
   # Your code goes here...

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rach
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.6
 platform: ruby
 authors:
 - Roger Garcia
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-02 00:00:00.000000000 Z
+date: 2025-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -58,6 +58,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: json-schema_builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: ruby-openai
   requirement: !ruby/object:Gem::Requirement
@@ -87,6 +115,11 @@ files:
 - lib/rach/function.rb
 - lib/rach/message.rb
 - lib/rach/message_template.rb
+- lib/rach/prompt.rb
+- lib/rach/provider.rb
+- lib/rach/provider/anthropic.rb
+- lib/rach/provider/base.rb
+- lib/rach/provider/openai.rb
 - lib/rach/response.rb
 - lib/rach/response_format.rb
 - lib/rach/usage_tracker.rb
@@ -110,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Orchestrate AI agents like a virtuoso