bristow 0.5.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e0ca726d23b0633656cf1ee562ac3b501d970b84692b8cfdf91437dce4f5a48
-  data.tar.gz: 9016bcf5fa198bf1531ce1f0a49b7742e113f6bd7d15549d1c6af8dc61b07dd2
+  metadata.gz: dbaf55e16f138b6a46fe9b5795cdb38f929d000e61f928131f1660cd421bf147
+  data.tar.gz: 13e9d03c76093fe4193d6335fdea763a7dd31737bf838bd3ad9bc1046b63d1e4
 SHA512:
-  metadata.gz: edf58bbcf4cb2352863da1110c3358e501ac5163d22619235c840f4f17e020e381e5b8f1d2d2c5bab7863eb909a3c0c56f69d3a665b321c0b5ca32ce757aa3fc
-  data.tar.gz: 1b4504c7136d11e5d1b5d8d2b0175c9450c3ef28d3cf63cfa7990dff91a89cac5051776c081bed43a12093dd86cf3767911dd898a54f6e8b1990ac8c8342b509
+  metadata.gz: 87472c67f66015f8f7193a70f3fb17acc259c4c21a8380df294fef5696a1da7da5e95db6178bba75273e68c354dd22cd7f9815fe1bdd6ef0bfa0b822aacaa34d
+  data.tar.gz: 62f1fd087cd3c30544098de3a1fc786e0a947da6d909de42bc9537a372b252b86ea7cc66c8f8c6bcf6683ca7fa75315faa9d8869da8b1258f7a678d3530093e2

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 ## [Unreleased]
 
+## [1.0.0] - 2025-05-26
+
+- Drop support for ruby 3.0 and 3.1
+- Add Anthropic API support
+
 ## [0.5.1] - 2025-05-08
 
 - Improve publish script

data/examples/README.md

@@ -0,0 +1,33 @@
+# Bristow Examples
+
+This directory contains examples demonstrating various features of Bristow.
+
+## Provider Selection
+
+All examples support provider selection via the `BRISTOW_PROVIDER` environment variable:
+
+### OpenAI (default)
+```bash
+ruby basic_agent.rb
+# or explicitly
+BRISTOW_PROVIDER=openai ruby basic_agent.rb
+```
+
+### Anthropic (Claude)
+```bash
+BRISTOW_PROVIDER=anthropic ruby basic_agent.rb
+```
+
+Make sure to set the appropriate API key:
+- `OPENAI_API_KEY` for OpenAI
+- `ANTHROPIC_API_KEY` for Anthropic
+
+## Examples
+
+- **basic_agent.rb** - Simple agent that tells spy stories
+- **function_calls.rb** - Agent with function calling capabilities (weather lookup)
+- **basic_agency.rb** - Multi-agent system with supervisor coordination
+- **basic_termination.rb** - Agent with conversation termination conditions
+- **workflow_agency.rb** - Sequential workflow between agents
+
+All examples work identically across providers thanks to Bristow's universal function schema format.

data/examples/basic_agency.rb

@@ -1,5 +1,18 @@
 require_relative '../lib/bristow'
 
+Bristow.configure do |config|
+  # Set provider based on environment variable, default to OpenAI
+  provider = ENV['BRISTOW_PROVIDER']&.to_sym || :openai
+  config.default_provider = provider
+
+  case provider
+  when :anthropic
+    config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  when :openai
+    config.model = 'gpt-4o-mini'
+  end
+end
+
 class PirateTalker < Bristow::Agent
   agent_name "PirateSpeaker"
   description "Agent for translating input to pirate-speak"

data/examples/basic_agent.rb

@@ -1,7 +1,16 @@
 require_relative '../lib/bristow'
 
 Bristow.configure do |config|
+  # Set provider based on environment variable, default to OpenAI
+  provider = ENV['BRISTOW_PROVIDER']&.to_sym || :openai
+  config.default_provider = provider
+
+  case provider
+  when :anthropic
+    config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  when :openai
     config.model = 'gpt-4o-mini'
+  end
 end
 
 class Sydney < Bristow::Agent

data/examples/basic_termination.rb

@@ -1,5 +1,18 @@
 require_relative '../lib/bristow'
 
+Bristow.configure do |config|
+  # Set provider based on environment variable, default to OpenAI
+  provider = ENV['BRISTOW_PROVIDER']&.to_sym || :openai
+  config.default_provider = provider
+
+  case provider
+  when :anthropic
+    config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  when :openai
+    config.model = 'gpt-4o-mini'
+  end
+end
+
 class CountAgent < Bristow::Agent
   agent_name "CounterAgent"
   description "Knows how to count"

data/examples/function_calls.rb

@@ -1,7 +1,16 @@
 require_relative '../lib/bristow'
 
 Bristow.configure do |config|
+  # Set provider based on environment variable, default to OpenAI
+  provider = ENV['BRISTOW_PROVIDER']&.to_sym || :openai
+  config.default_provider = provider
+
+  case provider
+  when :anthropic
+    config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  when :openai
     config.model = 'gpt-4o-mini'
+  end
 end
 
 # Define functions that GPT can call
@@ -39,7 +48,7 @@ class WeatherAgent < Bristow::Agent
 end
 
 # Start a conversation
-messages = WeatherAgent.chat("What's the weather like in London?") do |part|
+messages = WeatherAgent.chat("What's the weather like in London, UK?") do |part|
   print part
 end
 

data/examples/workflow_agency.rb

@@ -1,5 +1,18 @@
 require_relative '../lib/bristow'
 
+Bristow.configure do |config|
+  # Set provider based on environment variable, default to OpenAI
+  provider = ENV['BRISTOW_PROVIDER']&.to_sym || :openai
+  config.default_provider = provider
+
+  case provider
+  when :anthropic
+    config.anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+  when :openai
+    config.model = 'gpt-4o-mini'
+  end
+end
+
 class TravelAgent < Bristow::Agent
   agent_name "TravelAgent"
   description "Agent for planning trips"

data/lib/bristow/agent.rb

@@ -6,12 +6,13 @@ module Bristow
     sgetter :description
     sgetter :system_message
     sgetter :functions, default: []
+    sgetter :provider, default: -> { Bristow.configuration.default_provider }
     sgetter :model, default: -> { Bristow.configuration.model }
-    sgetter :client, default: -> { Bristow.configuration.client }
+    sgetter :client, default: nil
     sgetter :logger, default: -> { Bristow.configuration.logger }
     sgetter :termination, default: -> { Bristow::Terminations::MaxMessages.new(100) }
     attr_reader :chat_history
-    
+
 
 
     def initialize(
@@ -19,6 +20,7 @@ module Bristow
       description: self.class.description,
       system_message: self.class.system_message,
       functions: self.class.functions.dup,
+      provider: self.class.provider,
       model: self.class.model,
       client: self.class.client,
       logger: self.class.logger,
@@ -28,8 +30,9 @@ module Bristow
       @description = description
       @system_message = system_message
       @functions = functions
+      @provider = provider
       @model = model
-      @client = client
+      @client = client || Bristow.configuration.client_for(@provider)
       @logger = logger
       @chat_history = []
       @termination = termination
@@ -41,8 +44,8 @@ module Bristow
       function.call(**arguments.transform_keys(&:to_sym))
     end
 
-    def functions_for_openai
-      functions.map(&:to_openai_schema)
+    def formatted_functions
+      client.format_functions(functions)
     end
 
     def self.chat(...)
@@ -65,38 +68,33 @@ module Bristow
         }
 
         if functions.any?
-          params[:functions] = functions_for_openai
-          params[:function_call] = "auto"
+          params.merge!(formatted_functions)
         end
 
-        logger.debug("Calling OpenAI API with params: #{params}")
+        logger.debug("Calling #{provider} API with params: #{params}")
         response_message = if block_given?
-          handle_streaming_chat(params, &block)
+          client.stream_chat(params, &block)
         else
-          response = client.chat(parameters: params)
-          response.dig("choices", 0, "message")
+          client.chat(params)
         end
 
         messages << response_message
         @chat_history << response_message
 
         # If there's no function call, we're done
-        break unless response_message["function_call"]
+        break unless client.is_function_call?(response_message)
 
         # Handle the function call and add its result to the messages
         result = handle_function_call(
-          response_message["function_call"]["name"],
-          JSON.parse(response_message["function_call"]["arguments"])
+          client.function_name(response_message),
+          client.function_arguments(response_message)
         )
 
-        yield "\n[Function Call: #{response_message["function_call"]["name"]}]\n" if block_given?
+        yield "\n[Function Call: #{response_message}]\n" if block_given?
         yield "#{result.to_json}\n" if block_given?
 
-        messages << {
-          "role" => "function",
-          "name" => response_message["function_call"]["name"],
-          "content" => result.to_json
-        }
+
+        messages << client.format_function_response(response_message, result)
       end
 
       messages
@@ -107,49 +105,7 @@ module Bristow
 
     private
 
-    def handle_streaming_chat(params)
-      full_content = ""
-      function_name = nil
-      function_args = ""
-
-      stream_proc = proc do |chunk|
-        delta = chunk.dig("choices", 0, "delta")
-        next unless delta
-
-        if delta["function_call"]
-          # Building function call
-          if delta.dig("function_call", "name")
-            function_name = delta.dig("function_call", "name")
-          end
-
-          if delta.dig("function_call", "arguments")
-            function_args += delta.dig("function_call", "arguments")
-          end
-        elsif delta["content"]
-          # Regular content
-          full_content += delta["content"]
-          yield delta["content"]
-        end
-      end
-
-      params[:stream] = stream_proc
-      client.chat(parameters: params)
 
-      if function_name
-        {
-          "role" => "assistant",
-          "function_call" => {
-            "name" => function_name,
-            "arguments" => function_args
-          }
-        }
-      else
-        {
-          "role" => "assistant",
-          "content" => full_content
-        }
-      end
-    end
 
     def system_message_hash
       {

data/lib/bristow/configuration.rb

@@ -1,24 +1,72 @@
 module Bristow
   class Configuration
-    attr_accessor :openai_api_key, :model, :logger
-    attr_reader :client
+    attr_accessor :openai_api_key, :anthropic_api_key, :google_api_key, 
+                  :default_provider, :default_model, :logger
+    attr_reader :clients
 
     def initialize
       @openai_api_key = ENV['OPENAI_API_KEY']
-      @model = 'gpt-4o-mini'
+      @anthropic_api_key = ENV['ANTHROPIC_API_KEY']
+      @google_api_key = ENV['GOOGLE_API_KEY']
+      @default_provider = :openai
+      @default_model = nil  # Will use provider's default
       @logger = Logger.new(STDOUT)
-      reset_client
+      @clients = {}
     end
 
     def openai_api_key=(key)
       @openai_api_key = key
-      reset_client
+      reset_client(:openai)
+    end
+
+    def anthropic_api_key=(key)
+      @anthropic_api_key = key
+      reset_client(:anthropic)
+    end
+
+    def google_api_key=(key)
+      @google_api_key = key
+      reset_client(:google)
+    end
+
+    def client_for(provider)
+      @clients[provider] ||= build_client_for(provider)
+    end
+
+    # Backward compatibility
+    def client
+      client_for(default_provider)
+    end
+
+    # Backward compatibility  
+    def model
+      @default_model || client_for(default_provider).default_model
+    end
+
+    def model=(model)
+      @default_model = model
     end
 
     private
 
-    def reset_client
-      @client = OpenAI::Client.new(access_token: @openai_api_key)
+    def build_client_for(provider)
+      case provider
+      when :openai
+        raise ArgumentError, "OpenAI API key not configured" unless @openai_api_key
+        Providers::Openai.new(api_key: @openai_api_key)
+      when :anthropic
+        raise ArgumentError, "Anthropic API key not configured" unless @anthropic_api_key
+        Providers::Anthropic.new(api_key: @anthropic_api_key)
+      when :google
+        raise ArgumentError, "Google API key not configured" unless @google_api_key
+        Providers::Google.new(api_key: @google_api_key)
+      else
+        raise ArgumentError, "Unknown provider: #{provider}"
+      end
+    end
+
+    def reset_client(provider)
+      @clients.delete(provider)
     end
   end
 

data/lib/bristow/function.rb

@@ -19,14 +19,14 @@ module Bristow
       @parameters = parameters
     end
 
-    def self.to_openai_schema
+    def self.to_schema
       {
         name: function_name,
         description: description,
         parameters: parameters
       }
     end
-    delegate :to_openai_schema, to: :class
+    delegate :to_schema, to: :class
 
     def self.call(...)
       new.call(...)

data/lib/bristow/providers/anthropic.rb

@@ -0,0 +1,184 @@
+module Bristow
+  module Providers
+    class Anthropic < Base
+      def initialize(api_key:)
+        super
+        @client = ::Anthropic::Client.new(api_key: api_key)
+      end
+
+      def chat(params)
+        # Convert messages format for Anthropic
+        anthropic_params = convert_params(params)
+
+        response = @client.messages.create(anthropic_params)
+
+        # Convert response back to standard format
+        if response.content.any? { |content| content.type == "tool_use" }
+          # Handle tool use response
+          tool_use = response.content.find { |content| content.type == "tool_use" }
+          {
+            "role" => "assistant",
+            "function_call" => {
+              "name" => tool_use.name,
+              "arguments" => tool_use.input.to_json
+            }
+          }
+        else
+          # Handle text response
+          text_content = response.content.find { |content| content.type == "text" }&.text || ""
+          {
+            "role" => "assistant",
+            "content" => text_content
+          }
+        end
+      end
+
+      def stream_chat(params, &block)
+        anthropic_params = convert_params(params)
+
+        full_content = ""
+        tool_use = {}
+        tool_use_content_json = ""
+
+        stream = @client.messages.stream_raw(anthropic_params)
+        stream.each do |event|
+          case event.type
+          when :content_block_delta
+            if event.delta.type == :text_delta
+              text = event.delta.text
+              full_content += text
+              yield text if block_given?
+            elsif event.delta.type == :input_json_delta
+              # Accumulate tool input JSON fragments
+              tool_use_content_json += event.delta.partial_json || ""
+            end
+          when :content_block_start
+            if event.content_block.type == :tool_use
+              tool_use = event.content_block
+            end
+          end
+        end
+
+        if tool_use.to_hash.any?
+          {
+            "role" => "assistant",
+            content: [tool_use.to_hash.merge({input: JSON.parse(tool_use_content_json)})]
+          }
+        else
+          {
+            "role" => "assistant",
+            "content" => full_content
+          }
+        end
+      end
+
+      def format_functions(functions)
+        {
+          tools: functions.map { |func| convert_function_to_tool(func.to_schema) }
+        }
+      end
+
+      def is_function_call?(response)
+        response.dig(:content, 0, :type) == :tool_use
+      end
+
+      def function_name(response)
+        # TODO: support parallel function calls
+        response[:content][0][:name]
+      end
+
+      def function_arguments(response)
+        # TODO: support parallel function calls
+        response[:content][0][:input]
+      end
+
+      def format_function_response(response, result)
+        {
+          role: :user,
+          content: [{
+            type: "tool_result",
+            tool_use_id: response[:content][0][:id],
+            content: result.to_json
+          }]
+        }
+      end
+
+      def default_model
+        "claude-3-5-sonnet-20241022"
+      end
+
+      private
+
+      def convert_params(params)
+        # Extract system messages and regular messages
+        messages = params[:messages] || []
+        system_messages = messages.select { |msg| msg["role"] == "system" || msg[:role] == "system" }
+        other_messages = messages.reject { |msg| msg["role"] == "system" || msg[:role] == "system" }
+
+        anthropic_params = {
+          model: params[:model] || default_model,
+          max_tokens: params[:max_tokens] || 1024,
+          messages: convert_messages(other_messages)
+        }
+
+        # Add system message if present
+        if system_messages.any?
+          anthropic_params[:system] = system_messages.map { |msg| msg["content"] || msg[:content] }.join("\n")
+        end
+
+        # Add tools if present
+        if params[:tools]
+          anthropic_params[:tools] = params[:tools]
+        elsif params[:functions]
+          anthropic_params[:tools] = params[:functions].map { |func| convert_function_to_tool(func) }
+        end
+
+        anthropic_params
+      end
+
+      def convert_messages(messages)
+        messages.map do |msg|
+          role = msg["role"] || msg[:role]
+          case role
+          when "function"
+            # Convert function result to user message
+            {
+              "role" => "user",
+              "content" => "Function result: #{msg['content'] || msg[:content]}"
+            }
+          else
+            # Handle regular user/assistant messages
+            function_call = msg["function_call"] || msg[:function_call]
+            if function_call
+              # Convert function call to tool use format
+              {
+                "role" => "assistant",
+                "content" => [
+                  {
+                    "type" => "tool_use",
+                    "id" => "call_#{rand(1000000)}",
+                    "name" => function_call["name"] || function_call[:name],
+                    "input" => JSON.parse(function_call["arguments"] || function_call[:arguments])
+                  }
+                ]
+              }
+            else
+              {
+                "role" => role,
+                "content" => msg["content"] || msg[:content]
+              }
+            end
+          end
+        end
+      end
+
+      def convert_function_to_tool(func_schema)
+        {
+          "name" => func_schema[:name],
+          "description" => func_schema[:description],
+          "input_schema" => func_schema[:parameters]
+        }
+      end
+    end
+  end
+end

data/lib/bristow/providers/base.rb

@@ -0,0 +1,49 @@
+module Bristow
+  module Providers
+    class Base
+      attr_reader :api_key
+
+      def initialize(api_key:)
+        @api_key = api_key
+        raise ArgumentError, "API key is required" if api_key.nil? || api_key.empty?
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def chat(params)
+        raise NotImplementedError, "Subclasses must implement #chat"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def stream_chat(params, &block)
+        raise NotImplementedError, "Subclasses must implement #stream_chat"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def format_functions(functions)
+        raise NotImplementedError, "Subclasses must implement #format_functions"
+      end
+
+      # Abstract method - must be implemented by subclasses
+      def default_model
+        raise NotImplementedError, "Subclasses must implement #default_model"
+      end
+
+      def is_function_call?(response)
+        raise NotImplementedError, "Subclasses must implement #is_function_call?"
+      end
+
+      def function_name(response)
+        raise NotImplementedError, "Subclasses must implement #function_name"
+      end
+
+      def function_arguments(response)
+        raise NotImplementedError, "Subclasses must implement #function_arguments"
+      end
+
+      def format_function_response(response, result)
+        raise NotImplementedError, "Subclasses must implement #format_function_response"
+      end
+
+    end
+  end
+end

data/lib/bristow/providers/google.rb

@@ -0,0 +1,29 @@
+module Bristow
+  module Providers
+    class Google < Base
+      def initialize(api_key:)
+        super
+        # Will implement Google client when gem is available  
+        @client = nil # Placeholder for Google::GenerativeAI::Client.new(api_key: api_key)
+      end
+
+      def chat(params)
+        raise NotImplementedError, "Google provider not yet implemented"
+      end
+
+      def stream_chat(params, &block)
+        raise NotImplementedError, "Google provider not yet implemented"
+      end
+
+      def format_functions(functions)
+        # Google uses function declarations format
+        # Will implement when Google client is added
+        raise NotImplementedError, "Google provider not yet implemented"
+      end
+
+      def default_model
+        "gemini-pro"
+      end
+    end
+  end
+end

data/lib/bristow/providers/openai.rb

@@ -0,0 +1,90 @@
+module Bristow
+  module Providers
+    class Openai < Base
+      def initialize(api_key:)
+        super
+        @client = OpenAI::Client.new(access_token: api_key)
+      end
+
+      def chat(params)
+        response = @client.chat(parameters: params)
+        response.dig("choices", 0, "message")
+      end
+
+      def stream_chat(params, &block)
+        full_content = ""
+        function_name = nil
+        function_args = ""
+
+        stream_proc = proc do |chunk|
+          delta = chunk.dig("choices", 0, "delta")
+          next unless delta
+
+          if delta["function_call"]
+            # Building function call
+            if delta.dig("function_call", "name")
+              function_name = delta.dig("function_call", "name")
+            end
+
+            if delta.dig("function_call", "arguments")
+              function_args += delta.dig("function_call", "arguments")
+            end
+          elsif delta["content"]
+            # Regular content
+            full_content += delta["content"]
+            yield delta["content"]
+          end
+        end
+
+        params[:stream] = stream_proc
+        @client.chat(parameters: params)
+
+        if function_name
+          {
+            "role" => "assistant",
+            "function_call" => {
+              "name" => function_name,
+              "arguments" => function_args
+            }
+          }
+        else
+          {
+            "role" => "assistant",
+            "content" => full_content
+          }
+        end
+      end
+
+      def format_functions(functions)
+        {
+          functions: functions.map(&:to_schema),
+          function_call: "auto"
+        }
+      end
+
+      def default_model
+        "gpt-4o-mini"
+      end
+
+      def is_function_call?(response)
+        response["function_call"]
+      end
+
+      def function_name(response)
+        response["function_call"]["name"]
+      end
+
+      def function_arguments(response)
+        JSON.parse(response["function_call"]["arguments"])
+      end
+
+      def format_function_response(response, result)
+        message_hash = {
+          "role" => "function",
+          "name" => response["function_call"]["name"],
+          "content" => result.to_json
+        }
+      end
+    end
+  end
+end

data/lib/bristow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Bristow
-  VERSION = "0.5.1"
+  VERSION = "1.0.0"
 end

data/lib/bristow.rb

@@ -1,11 +1,16 @@
 # frozen_string_literal: true
 require 'openai'
+require 'anthropic'
 require 'logger'
 require 'json'
 
 require_relative "bristow/version"
 require_relative "bristow/helpers/sgetter"
 require_relative "bristow/helpers/delegate"
+require_relative "bristow/providers/base"
+require_relative "bristow/providers/openai"
+require_relative "bristow/providers/anthropic"
+require_relative "bristow/providers/google"
 require_relative "bristow/configuration"
 require_relative "bristow/function"
 require_relative "bristow/functions/delegate"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bristow
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Andrew Hampton
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: debug
   requirement: !ruby/object:Gem::Requirement
@@ -109,6 +123,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- examples/README.md
 - examples/basic_agency.rb
 - examples/basic_agent.rb
 - examples/basic_termination.rb
@@ -125,6 +140,10 @@ files:
 - lib/bristow/functions/delegate.rb
 - lib/bristow/helpers/delegate.rb
 - lib/bristow/helpers/sgetter.rb
+- lib/bristow/providers/anthropic.rb
+- lib/bristow/providers/base.rb
+- lib/bristow/providers/google.rb
+- lib/bristow/providers/openai.rb
 - lib/bristow/termination.rb
 - lib/bristow/terminations/can_not_stop_will_not_stop.rb
 - lib/bristow/terminations/max_messages.rb