bristow 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e61544a71407814e6c09e22d56631df8ed7a0475cf8b182ba4d7bf86bcf68d4c
-  data.tar.gz: 29a5285d24236fbd6226bffebbdd34becd3a7c2ac81c33fafde0a35d0e8eaf31
+  metadata.gz: 41e9fcfe099defc5696c4ef49b8bce8b63091de906e7cd7558a9e89a98734360
+  data.tar.gz: c19e7c5f20f658d8bc9e669513a9df4f730bc8a6595009866d096011d85f0751
 SHA512:
-  metadata.gz: 2b9a904a1309e6d111ecf4b5172a4f07b6c57acfb7a8b219c4b890a6e914fcdc7e6bc9b7da5aa88b67aca1bffe57de185be2fe2583ab8fea8dedf416f67c1100
-  data.tar.gz: defc7c18b96063f1e1a4e88513ba7cc780c0fbf66aecf6f5eda74084721e4325a29a3f0ea3a50fec453309833280daa2db39aa3d782c548b86ee737dac1b92fe
+  metadata.gz: fa99a514a81713700df0e78f8dafedd26e49e511edb1e2fd4c83a56ad6310c082d05cf61f7183bd8c00f4844f94632251f1bb6db098e7b18a04e213e0c9454ac
+  data.tar.gz: 16ab56ba600e68525b5c12dd7186c9aa1b2d3be28913369a6b1eb50f8e14bf34daba9188dd9c77540de2eb0da1fa0a4bd48889c85f502a610d0b19883faa7581

data/.rspec

@@ -1,3 +1,2 @@
---format documentation
 --color
 --require spec_helper

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 ## [Unreleased]
 
+## [0.3.0] - 2025-02-01
+
+- Major update to the API. Now primarily class based.
+  Check the README for new details.
+
+- Require updating CHANGELOG.md in each PR, but only in PRs.
+
+## [0.2.1] - 2025-01-29
+
+- Fixed schema for supervisor agent function call
+
+## [0.2.0] - 2025-01-28
+
+- Refactored the schema for function calls
+
 ## [0.1.0] - 2025-01-21
 
 - Initial release

data/README.md

@@ -20,37 +20,20 @@ Or install it yourself as:
 
 ## Usage
 
-### Simple Agent
-
-You can create agents without functions for basic tasks:
-
 ```ruby
 require 'bristow'
 
-storyteller = Bristow::Agent.new(
-  name: 'Sydney',
-  description: 'Agent for telling spy stories',
-  system_message: 'Given a topic, you will tell a brief spy story',
-)
-
-# Either stream the response with a block:
-storyteller.chat('Tell me a story about Cold War era Berlin') do |response_chunk|
-  print response_chunk # response_chunk will be the next chunk of text in the response from the model
+# Configure Bristow
+Bristow.configure do |config|
+  config.api_key = ENV['OPENAI_API_KEY']
 end
 
-# Or work with the entire conversation once it's complete:
-conversation = storyteller.chat('Tell me a story about Cold War era Berlin')
-puts conversation.last['content'] 
-```
-
-### Basic Agent with Functions
-
-```ruby
 # Define functions that the model can call
-weather = Bristow::Function.new(
-  name: "get_weather",
-  description: "Get the current weather for a location",
-  parameters: { 
+class WeatherLookup < Bristow::Function
+  name "get_weather"
+  description "Get the current weather for a location"
+  system_message "You are a weather forecast assistant. Given a location, you will look up the weather forecast and provide a brief description."
+  parameters { 
     properties: {
       location: {
         type: "string",
@@ -64,52 +47,74 @@ weather = Bristow::Function.new(
     },
     required: ["location"]
   }
-) do |location:, unit: 'celsius'|
-  # Implement your application logic here
-  { temperature: 22, unit: unit }
+
+  def perform(location:, unit: 'celsius')
+    # Implement your application logic here
+    { temperature: 22, unit: unit }
+  end
 end
 
 # Create an agent with access to the function
-weather_agent = Bristow::Agent.new(
-  name: "WeatherAssistant",
-  description: "Helps with weather-related queries",
-  functions: [weather]
-)
+class Forecaster < Bristow::Agent
+  name "WeatherAssistant"
+  description "Helps with weather-related queries"
+  system_message "You are a weather forecast assistant. Given a location, you will look up the weather forecast and provide a brief description."
+  functions [WeatherLookup]
+end
 
 # Chat with the agent
-weather_agent.chat("What's the weather like in London?") do |response_chunk|
+forecaster_agent = Forecaster.new
+forecaster_agent.chat("What's the weather like in London?") do |response_chunk|
+  # As the agent streams the response, print each chunk
   print response_chunk 
 end
-```
-
-The `parameters` hash is passed directly through to OpenAI's API. You can see details about how to define parameters in [OpenAI's documentation for defining functions](https://platform.openai.com/docs/guides/function-calling#defining-functions).
-
 
-### Multi-Agent System
-
-You can coordinate multiple agents using `Bristow::Agency`. Bristow includes a few common patterns, including the one like [langchain's multi-agent supervisor](https://langchain-ai.github.io/langgraph/tutorials/multi_agent/agent_supervisor/). Here's how to use the supervisor agency:
+# Create a more complex agent that can access multiple functions
+class WeatherDatabase < Bristow::Function
+  name "store_weather"
+  description "Store weather data in the database"
+  parameters {
+    properties: {
+      location: {
+        type: "string",
+        description: "The city and state, e.g. San Francisco, CA"
+      },
+      temperature: {
+        type: "number",
+        description: "The temperature in the specified unit"
+      },
+      unit: {
+        type: "string",
+        enum: ["celsius", "fahrenheit"],
+        description: "The unit of temperature"
+      }
+    },
+    required: ["location", "temperature", "unit"]
+  }
 
-```ruby
-# Create specialized agents. These can be configured with functions, as well.
-pirate_talker = Bristow::Agent.new(
-  name: "PirateSpeaker",
-  description: "Agent for translating input to pirate-speak",
-  system_message: 'Given a text, you will translate it to pirate-speak.',
-)
+  def self.perform(location:, temperature:, unit:)
+    # Store the weather data in your database
+    { status: "success", message: "Weather data stored for #{location}" }
+  end
+end
 
-travel_agent = Bristow::Agent.new(
-  name: "TravelAgent",
-  description: "Agent for planning trips",
-  system_message: 'Given a destination, you will respond with a detailed itenerary that includes only dates, times, and locations.',
-)
+class WeatherManager < Bristow::Agent
+  name "WeatherManager"
+  description "Manages weather data collection and storage"
+  system_message "You are a weather data management assistant. You can look up weather data and store it in the database."
+  functions [WeatherLookup, WeatherDatabase]
+end
 
-# Create a supervisor agency to coordinate the agents
-agency = Bristow::Agencies::Supervisor.create(agents: [pirate_talker, travel_agent])
+# Create an agency to coordinate multiple agents. The supervisor agent is a
+# pre-configured agency that includes a supervisor agent that knows how to
+# delegate tasks to other agents
+class WeatherAgency < Bristow::Agencies::Supervisor
+  agents [Forecaster, WeatherManager]
+end
 
-# The supervisor will automatically delegate to the appropriate agent as needed before generating a response for the user.
-agency.chat([
-  { role: "user", content: "I want to go to New York. Tell me about it as if you were a pirate." }
-]) do |response_chunk|
+# Use the agency to coordinate multiple agents
+agency = WeatherAgency.new
+agency.chat("Can you check the weather in London and store it in the database?") do |response_chunk|
   print response_chunk
 end
 ```
@@ -128,7 +133,7 @@ Bristow.configure do |config|
   config.openai_api_key = 'your-api-key'
   
   # The default model to use (defaults to 'gpt-4o-mini')
-  config.default_model = 'gpt-4o'
+  config.model = 'gpt-4o'
   
   # Logger to use (defaults to Logger.new(STDOUT))
   config.logger = Rails.logger

data/examples/agency.rb

@@ -1,23 +1,27 @@
-require_relative "../lib/bristow"
+require_relative '../lib/bristow'
 
-pirate_talker = Bristow::Agent.new(
-    name: "PirateSpeaker",
-    description: "Agent for translating input to pirate-speak",
-    system_message: 'Given a text, you will translate it to pirate-speak.',
-)
-
-travel_agent = Bristow::Agent.new(
-    name: "TravelAgent",
-    description: "Agent for planning trips",
-    system_message: 'Given a destination, you will plan a trip. You will respond with an itinerary that includes dates, times, and locations only.',
-)
+class PirateTalker < Bristow::Agent
+  name "PirateSpeaker"
+  description "Agent for translating input to pirate-speak"
+  system_message 'Given a text, you will translate it to pirate-speak.'
+end
 
-agency = Bristow::Agencies::Supervisor.create(agents: [pirate_talker, travel_agent])
+class TravelAgent < Bristow::Agent
+  name "TravelAgent"
+  description "Agent for planning trips"
+  system_message 'Given a destination, you will plan a trip. You will respond with an itinerary that includes dates, times, and locations only.'
+end
 
-messages = agency.chat([
-    { role: "user", content: "I want to go to New York. Please plan my trip and tell me about it as if you were a pirate." }
-]) do |part|
-    print part
+class PirateTravelAgency < Bristow::Agencies::Supervisor
+  agents [PirateTalker, TravelAgent]
+  custom_instructions "Once you know the destination, you should call the TravelAgent to plan the itenerary, then translate the itenerary to pirate-speak using PirateSpeaker before returning it to the user."
 end
 
-puts messages
+begin
+  messages = PirateTravelAgency.chat("I want to go to New York") do |part|
+      print part
+  end
+rescue SystemStackError => e
+  puts e.backtrace.join("\n")
+end
+pp messages

data/examples/basic_agent.rb

@@ -1,15 +1,22 @@
-require_relative "../lib/bristow"
+require_relative '../lib/bristow'
 
 Bristow.configure do |config|
-    config.default_model = 'gpt-4o-mini'
+    config.model = 'gpt-4o-mini'
 end
 
-sydney = Bristow::Agent.new(
-  name: 'Sydney',
-  description: 'Agent for telling spy stories',
-  system_message: 'Given a topic, you will tell a brief spy story',
-)
+class Sydney < Bristow::Agent
+  name 'Sydney'
+  description 'Agent for telling spy stories'
+  system_message 'Given a topic, you will tell a brief spy story'
+end
+
+sydney = Sydney.new
 
-sydney.chat([{role: 'user', content: 'Cold war era Berlin'}]) do |part|
-  print part
-end
+begin
+  sydney.chat([{role: 'user', content: 'Cold war era Berlin'}]) do |part|
+    print part
+  end
+
+rescue SystemStackError => e
+  puts e.backtrace.join("\n")
+end

data/examples/function_calls.rb

@@ -1,14 +1,14 @@
-require_relative "../lib/bristow"
+require_relative '../lib/bristow'
 
 Bristow.configure do |config|
-    config.default_model = 'gpt-4o-mini'
+    config.model = 'gpt-4o-mini'
 end
 
 # Define functions that GPT can call
-weather = Bristow::Function.new(
-  name: "get_weather",
-  description: "Get the current weather for a location",
-  parameters: {
+class WeatherLookup < Bristow::Function
+  name "get_weather"
+  description "Get the current weather for a location"
+  parameters ({
     type: "object",
     properties: {
       location: {
@@ -22,25 +22,24 @@ weather = Bristow::Function.new(
       }
     },
     required: [:location]
-  }
-) do |location:, unit: 'celsius'|
-  # Your weather API call here
-  { temperature: 22, unit: unit }
+  })
+
+  def perform(location:, unit: 'celsius')
+    # Your weather API call here
+    { temperature: 22, unit: unit }
+  end
 end
 
 # Create an agent with these functions
-weather_agent = Bristow::Agent.new(
-  name: "WeatherAssistant",
-  description: "Helps with weather-related queries",
-  functions: [weather]
-)
+class WeatherAgent < Bristow::Agent
+  name "WeatherAssistant"
+  description "Helps with weather-related queries"
+  system_message "You are a helpful weather assistant. You'll be asked about the weather, and should use the get_weather function to respond."
+  functions [WeatherLookup]
+end
 
 # Start a conversation
-messages = [
-  { "role" => "user", "content" => "What's the weather like in London?" }
-]
-
-messages_from_chat = weather_agent.chat(messages) do |part|
+messages = WeatherAgent.chat("What's the weather like in London?") do |part|
   print part
 end
 

data/lib/bristow/agencies/supervisor.rb

@@ -1,30 +1,26 @@
 module Bristow
   module Agencies
     class Supervisor < Agency
-      attr_accessor :supervisor
+      attr_reader :supervisor
 
-      def self.create(agents: [])
-        agency = new(agents: agents)
-        supervisor = Agents::Supervisor.new(
-          available_agents: agents,
-          agency: agency
-        )
-        agency.supervisor = supervisor
-        agency.agents << supervisor
-        agency
-      end
+      sgetter :custom_instructions, default: nil
 
-      def initialize(agents: [])
+      def initialize(agents: self.class.agents.dup)
+        @custom_instructions = self.class.custom_instructions
         @agents = agents
-        @supervisor = nil  # Will be set by create
+        @supervisor = Agents::Supervisor.new(
+          child_agents: agents,
+          agency: self,
+          custom_instructions: custom_instructions
+        )
       end
 
       def chat(messages, &block)
-        raise "No supervisor set" unless supervisor
+        raise "Supervisor not set" unless supervisor
 
         # Convert string message to proper format
         messages = [{ role: "user", content: messages }] if messages.is_a?(String)
-        
+
         supervisor.chat(messages, &block)
       end
     end

data/lib/bristow/agency.rb

@@ -1,17 +1,26 @@
 module Bristow
   class Agency
-    attr_reader :agents
+    include Bristow::Sgetter
 
-    def initialize(agents: [])
+    sgetter :agents, default: []
+
+    def initialize(agents: self.class.agents.dup)
       @agents = agents
     end
 
+    def self.chat(...)
+      new.chat(...)
+    end
+
     def chat(messages, &block)
-      raise NotImplementedError, "Agency#chat must be implemented by a subclass"
+      raise NotImplementedError, "#{self.class.name}#chat must be implemented"
     end
 
     def find_agent(name)
-      agents.find { |agent| agent.name == name }
+      agent = agents.find { |agent| agent_name(agent) == name }
+      return nil unless agent
+      
+      agent.is_a?(Class) ? agent.new : agent
     end
 
     protected
@@ -20,5 +29,11 @@ module Bristow
       response = agent.chat(messages, &block)
       response.last # Return just the last message
     end
+
+    private
+
+    def agent_name(agent)
+      agent.is_a?(Class) ? agent.name : agent.class.name
+    end
   end
 end

data/lib/bristow/agent.rb

@@ -1,19 +1,32 @@
-require 'openai'
-require 'logger'
-require 'json'
-
 module Bristow
   class Agent
-    attr_reader :name, :description, :functions, :system_message, :chat_history
-
-    def initialize(name:, description:, system_message: nil, functions: [], model: Bristow.configuration.default_model)
+    include Bristow::Sgetter
+
+    sgetter :name
+    sgetter :description
+    sgetter :system_message
+    sgetter :functions, default: []
+    sgetter :model, default: -> { Bristow.configuration.model }
+    sgetter :client, default: -> { Bristow.configuration.client }
+    sgetter :logger, default: -> { Bristow.configuration.logger }
+    attr_reader :chat_history
+
+    def initialize(
+      name: self.class.name,
+      description: self.class.name,
+      system_message: self.class.system_message,
+      functions: self.class.functions.dup,
+      model: self.class.model,
+      client: self.class.client,
+      logger: self.class.logger
+    )
       @name = name
       @description = description
       @system_message = system_message
       @functions = functions
-      @logger = Bristow.configuration.logger
-      @client = Bristow.configuration.client
       @model = model
+      @client = client
+      @logger = logger
       @chat_history = []
     end
 
@@ -24,9 +37,11 @@ module Bristow
     end
 
     def functions_for_openai
-      functions.map do |function|
-        function.to_openai_schema
-      end
+      functions.map(&:to_openai_schema)
+    end
+
+    def self.chat(...)
+      new.chat(...)
     end
 
     def chat(messages, &block)
@@ -40,7 +55,7 @@ module Bristow
 
       loop do
         params = {
-          model: @model,
+          model: model,
           messages: messages
         }
 
@@ -49,10 +64,11 @@ module Bristow
           params[:function_call] = "auto"
         end
 
+        logger.debug("Calling OpenAI API with params: #{params}")
         response_message = if block_given?
           handle_streaming_chat(params, &block)
         else
-          response = @client.chat(parameters: params)
+          response = client.chat(parameters: params)
           response.dig("choices", 0, "message")
         end
 
@@ -80,7 +96,7 @@ module Bristow
 
       messages
     rescue Faraday::BadRequestError, Faraday::ResourceNotFound => e
-      @logger.error("Error calling OpenAI API: #{e.response[:body]}")
+      logger.error("Error calling OpenAI API: #{e.response[:body]}")
       raise
     end
 
@@ -100,6 +116,7 @@ module Bristow
           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
@@ -111,7 +128,7 @@ module Bristow
       end
 
       params[:stream] = stream_proc
-      @client.chat(parameters: params)
+      client.chat(parameters: params)
 
       if function_name
         {
@@ -135,20 +152,5 @@ module Bristow
         "content" => system_message
       }
     end
-
-    def parameter_type_for(type)
-      case type.to_s
-      when "Integer", "Fixnum"
-        { type: "integer" }
-      when "Float"
-        { type: "number" }
-      when "String"
-        { type: "string" }
-      when "TrueClass", "FalseClass", "Boolean"
-        { type: "boolean" }
-      else
-        { type: "string" }
-      end
-    end
   end
 end

data/lib/bristow/agents/supervisor.rb

@@ -1,17 +1,37 @@
+# frozen_string_literal: true
+
 module Bristow
   module Agents
     class Supervisor < Agent
-      attr_accessor :agency
-
-      def initialize(available_agents:, agency: nil, name: "Supervisor", description: "A supervisor agent that coordinates between specialized agents", model: Bristow.configuration.default_model)
-        super(
-          name: name,
-          description: description,
-          system_message: build_system_message(available_agents),
-          functions: [delegate_function],
-          model: model
-        )
+      attr_reader :agency
+
+      name "Supervisor"
+      description "A supervisor agent that coordinates between specialized agents"
+      system_message <<~MESSAGE
+        You are a supervisor agent that coordinates between specialized agents.
+        Your role is to:
+        1. Understand the user's request
+        2. Choose the most appropriate agent to handle it
+        3. Delegate using the delegate_to function
+        4. Review the agent's response
+        5. Either return the response to the user or delegate to another agent
+
+        After receiving a response, you can either:
+        1. Return it to the user if it fully answers their request
+        2. Delegate to another agent if more work is needed
+        3. Add your own clarification or summary if needed
+      MESSAGE
+
+      sgetter :custom_instructions, default: nil
+
+      def initialize(child_agents:, agency:, custom_instructions: nil)
+        super()
+        @custom_instructions = custom_instructions || self.class.custom_instructions
+        @system_message = build_system_message(child_agents)
         @agency = agency
+        @custom_instructions = custom_instructions || self.class.custom_instructions
+        agency.agents << self
+        functions << Functions::Delegate.new(self, agency)
       end
 
       private
@@ -22,48 +42,16 @@ module Bristow
         end.join("\n")
 
         <<~MESSAGE
-          You are a supervisor agent that coordinates between specialized agents.
-          Your role is to:
-          1. Understand the user's request
-          2. Choose the most appropriate agent to handle it
-          3. Delegate using the delegate_to function
-          4. Review the agent's response
-          5. Either return the response to the user or delegate to another agent
+          #{self.class.system_message}
+
+          #{custom_instructions.nil? ? "" : custom_instructions}
 
           Available agents:
           #{agent_descriptions}
 
           Always use the delegate_to function to work with other agents.
-          After receiving a response, you can either:
-          1. Return it to the user if it fully answers their request
-          2. Delegate to another agent if more work is needed
-          3. Add your own clarification or summary if needed
         MESSAGE
       end
-
-      def delegate_function
-        Function.new(
-          name: "delegate_to",
-          description: "Delegate a task to a specialized agent",
-          parameters: {
-            agent_name: String,
-            message: String
-          }
-        ) do |agent_name:, message:|
-          raise "No agency set for supervisor" unless agency
-
-          if agent_name == name
-            { error: "Cannot delegate to self" }
-          else
-            agent = agency.find_agent(agent_name)
-            raise ArgumentError, "Agent #{agent_name} not found" unless agent
-
-            Bristow.configuration.logger.info("Delegating to #{agent_name}: #{message}")
-            response = agent.chat([{ "role" => "user", "content" => message }])
-            { response: response.last["content"] }
-          end
-        end
-      end
     end
   end
-end
+end

data/lib/bristow/configuration.rb

@@ -1,14 +1,11 @@
-require 'logger'
-require 'openai'
-
 module Bristow
   class Configuration
-    attr_accessor :openai_api_key, :default_model, :logger
+    attr_accessor :openai_api_key, :model, :logger
     attr_reader :client
 
     def initialize
       @openai_api_key = ENV['OPENAI_API_KEY']
-      @default_model = 'gpt-4o-mini'
+      @model = 'gpt-4o-mini'
       @logger = Logger.new(STDOUT)
       reset_client
     end

data/lib/bristow/function.rb

@@ -2,39 +2,42 @@
 
 module Bristow
   class Function
-    attr_reader :name, :description, :parameters
-
-    def initialize(name:, description:, parameters:, &block)
-      raise ArgumentError, "block is required" unless block_given?
-      @name = name
-      @description = description
-      @parameters = parameters
-      @block = block
-
-      if !parameters.has_key?(:type)
-        parameters[:type] = "object"
-      end
-    end
+    include Bristow::Sgetter
+    include Bristow::Delegate
 
-    def call(**kwargs)
-      validate_required_parameters!(kwargs)
-      @block.call(**kwargs)
-    end
+    sgetter :name
+    sgetter :description
+    sgetter :parameters, default: {}
 
-    def to_openai_schema
+    def self.to_openai_schema
       {
         name: name,
         description: description,
         parameters: parameters
       }
     end
+    delegate :to_openai_schema, to: :class
+
+    def self.call(...)
+      new.call(...)
+    end
+
+    def call(**kwargs)
+      validation_errors = validate_required_parameters!(kwargs)
+      return validation_errors unless validation_errors.nil?
+      perform(**kwargs)
+    end
+
+    def perform(...)
+      raise NotImplementedError, "#{self.class.name}#perform must be implemented"
+    end
 
     private
 
     def validate_required_parameters!(kwargs)
-      required_params = parameters.dig(:required) || []
+      required_params = self.class.parameters.dig(:required) || []
       missing = required_params.map(&:to_sym) - kwargs.keys.map(&:to_sym)
-      raise ArgumentError, "missing keyword: #{missing.first}" if missing.any?
+      "missing parameters: #{missing.inspect}" if missing.any?
     end
   end
 end

data/lib/bristow/functions/delegate.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Bristow
+  module Functions
+    class Delegate < Function
+      def self.name
+        "delegate_to"
+      end
+
+      def self.description
+        "Delegate a task to a specialized agent"
+      end
+
+      def self.parameters
+        {
+          type: "object",
+          properties: {
+            agent_name: {
+              type: "string",
+              description: "The name of the agent to delegate to"
+            },
+            message: {
+              type: "string",
+              description: "The instructions for the agent being delegated to"
+            }
+          },
+          required: ["agent_name", "message"]
+        }
+      end
+
+      def name
+        self.class.name
+      end
+
+      def description
+        self.class.description
+      end
+
+      def parameters
+        self.class.parameters
+      end
+
+      def initialize(agent, agency)
+        raise ArgumentError, "Agent must not be nil" if agent.nil?
+
+        @agent = agent
+        @agency = agency
+      end
+
+      def agency=(agency)
+        @agency = agency
+      end
+
+      def perform(agent_name:, message:)
+        raise "Agency not set" if @agency.nil?
+
+        if agent_name == @agent.name
+          { error: "Cannot delegate to self" }
+        else
+          agent = @agency.find_agent(agent_name)
+          raise ArgumentError, "Agent #{agent_name} not found" unless agent
+
+          Bristow.configuration.logger.info("Delegating to #{agent_name}: #{message}")
+          response = agent.chat([{ "role" => "user", "content" => message }])
+          last_message = response&.last
+          { response: last_message&.[]("content") }
+        end
+      end
+    end
+  end
+end

data/lib/bristow/helpers/delegate.rb

@@ -0,0 +1,17 @@
+module Bristow
+  module Delegate
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def delegate(*methods, to:)
+        methods.each do |method|
+          define_method(method) do
+            send(to).send(method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bristow/helpers/sgetter.rb

@@ -0,0 +1,42 @@
+# A helper to define a getter/setter method
+# This will let you define a class level getter/setter method with an instance reader
+#
+# Example:
+# class Agent
+#   include Bristow::Sgetter
+#   sgetter :name
+#   sgetter :model, default: -> { Bristow.configuration.model }
+# end
+#
+# class Sydney < Agent
+#   name 'Sydney'
+# end
+#
+# sydney = Sydney.new
+# sydney.name # => 'Sydney'
+module Bristow
+  module Sgetter
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def sgetter(attr, default: nil)
+        # Define the method that allows for both getter/setter syntax
+        define_singleton_method(attr) do |val = nil|
+          if val.nil?
+            return instance_variable_get("@#{attr}") if instance_variable_defined?("@#{attr}")
+            default.respond_to?(:call) ? default.call : default
+          else
+            instance_variable_set("@#{attr}", val)
+          end
+        end
+
+        # Instance-level reader
+        define_method(attr) do
+          instance_variable_get("@#{attr}")
+        end
+      end
+    end
+  end
+end

data/lib/bristow/version.rb

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

data/lib/bristow.rb

@@ -1,8 +1,15 @@
 # frozen_string_literal: true
+require 'debug'
+require 'openai'
+require 'logger'
+require 'json'
 
 require_relative "bristow/version"
+require_relative "bristow/helpers/sgetter"
+require_relative "bristow/helpers/delegate"
 require_relative "bristow/configuration"
 require_relative "bristow/function"
+require_relative "bristow/functions/delegate"
 require_relative "bristow/agent"
 require_relative "bristow/agents/supervisor"
 require_relative "bristow/agency"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: bristow
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Hampton
 bindir: bin
 cert_chain: []
-date: 2025-01-29 00:00:00.000000000 Z
+date: 2025-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai
@@ -133,6 +133,9 @@ files:
 - lib/bristow/agents/supervisor.rb
 - lib/bristow/configuration.rb
 - lib/bristow/function.rb
+- lib/bristow/functions/delegate.rb
+- lib/bristow/helpers/delegate.rb
+- lib/bristow/helpers/sgetter.rb
 - lib/bristow/version.rb
 homepage: https://github.com/andrewhampton/bristow
 licenses:
@@ -158,7 +161,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A Ruby framework for creating systems of cooperative AI agents with function
   calling capabilities