swarm-rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cae2fec017926fd78d147037ca44fa5f0d77118cf098e2dc47796f9d069f2dff
+  data.tar.gz: 64084bfbbb87381a25270868903338192f04e05df375286c11c2ad8dc2393c0a
+SHA512:
+  metadata.gz: d93372e43f1600086779e286783a90c9048318d01b6ad96a60210c77e49e114685b58b5a4106c96a5cb91be8a3522ceaa6d2e845d21c302ebdd6c82991285ab3
+  data.tar.gz: d6ad7fece31eb2bbe265da75a21fc79e4b2349e097073c13f311f3894bbfab2d1bcffb6b21fe5353d88a0df9a52adaf5d2f7c71f716234174929244137971c2d

data/Readme.md

@@ -0,0 +1,36 @@
+![Swarm Logo](assets/logo.png)
+
+# Swarm-RB (experimental, educational)
+
+An educational framework exploring ergonomic, lightweight multi-agent orchestration in Ruby. It is a port of [Swarm](https://github.com/openai/swarm/tree/main/swarm) created by Open AI.
+
+## Install
+
+```shell
+gem install swarm-rb
+```
+
+Or, if using Bundler, add this line to your application's Gemfile:
+
+```ruby
+gem 'swarm-rb', git: 'https://github.com/openai/swarm-rb.git'
+```
+
+And then execute:
+
+```shell
+bundle install
+```
+
+# Examples
+
+Check out `/examples` for inspiration!
+
+- [`basic`](examples/basic): Simple examples of fundamentals like setup, function calling, handoffs, and context variables.
+
+## Contributing
+
+Everyone is welcome to contribute to this. This gem was created just because I wanted to use Open AI's swarm framework in Ruby. There is likly a ton of 🍌s code in this repo since I relied heavily on LLMs to create this gem in < 2 days.
+
+It needs more testing, documentation clean up and expantion on the examples to parity the Open AI's [Swarm](https://github.com/openai/swarm) library.
+

data/lib/swarm/core.rb

@@ -0,0 +1,199 @@
+require "openai"
+require "json"
+require_relative "util"
+require_relative "types"
+
+module Swarm
+  class Swarm
+    CTX_VARS_NAME = "context_variables"
+
+    def initialize(client = nil)
+      @client = client || OpenAI::Client.new
+    end
+
+    def get_chat_completion(
+      agent:,
+      history:,
+      context_variables:,
+      model_override: nil,
+      stream: false,
+      debug: false
+    )
+      context_variables = context_variables.dup
+      instructions = if agent.instructions.respond_to?(:call)
+        agent.instructions.call(context_variables)
+      else
+        agent.instructions
+      end
+
+      messages = [{"role" => "system", "content" => instructions}] + history
+      Util.debug_print(debug, "Getting chat completion for:", messages)
+
+      tools = agent.functions.map { |f| Util.function_to_json(f) }
+
+      # Hide context_variables from the model
+      tools.each do |tool|
+        puts tool
+        params = tool["parameters"]
+        params["properties"]&.delete(CTX_VARS_NAME)
+        params["required"]&.delete(CTX_VARS_NAME)
+      end
+
+      parameters = {
+        model: model_override || agent.model,
+        messages: messages
+      }
+
+      parameters[:functions] = tools unless tools.empty?
+      parameters[:function_call] = agent.tool_choice if agent.tool_choice
+      parameters[:stream] = stream
+
+      Util.debug_print(debug, "Chat parameters:", parameters)
+
+      begin
+        if stream
+          @client.chat(parameters: parameters) do |chunk|
+            # Handle streaming response if needed
+          end
+        else
+          response = @client.chat(parameters: parameters)
+          Util.debug_print(debug, "API Response:", response)
+          response
+        end
+      rescue OpenAI::Error => e
+        Util.debug_print(true, "OpenAI API Error:", e.message)
+        raise
+      end
+    end
+
+    def handle_function_result(result, debug)
+      case result
+      when Result
+        result
+      when Agent
+        Result.new(value: {"assistant" => result.name}.to_json, agent: result)
+      else
+        begin
+          Result.new(value: result.to_s)
+        rescue => e
+          error_message = "Failed to cast response to string: #{result}. Make sure agent functions return a string or Result object. Error: #{e.message}"
+          Util.debug_print(debug, error_message)
+          raise TypeError, error_message
+        end
+      end
+    end
+
+    def handle_tool_calls(tool_calls, functions, context_variables, debug)
+      function_map = functions.map { |f| [f.name.to_s, f] }.to_h
+      partial_response = Response.new(messages: [], agent: nil, context_variables: {})
+
+      tool_calls.each do |tool_call|
+        name = tool_call["name"]
+        unless function_map.key?(name)
+          Util.debug_print(debug, "Tool #{name} not found in function map.")
+          partial_response.messages << {
+            "role" => "function",
+            "name" => name,
+            "content" => "Error: Tool #{name} not found."
+          }
+          next
+        end
+
+        args = JSON.parse(tool_call["arguments"] || "{}")
+        Util.debug_print(debug, "Processing tool call: #{name} with arguments #{args}")
+
+        func = function_map[name]
+        # Pass context_variables to agent functions
+        if func.parameters.map(&:last).include?(CTX_VARS_NAME.to_sym)
+          args[CTX_VARS_NAME] = context_variables
+        end
+
+        raw_result = func.call(**args.transform_keys(&:to_sym))
+        result = handle_function_result(raw_result, debug)
+        partial_response.messages << {
+          "role" => "function",
+          "name" => name,
+          "content" => result.value
+        }
+        partial_response.context_variables.merge!(result.context_variables)
+        partial_response.agent ||= result.agent
+      end
+
+      partial_response
+    end
+
+    def run(
+      agent:,
+      messages:,
+      context_variables: {},
+      model_override: nil,
+      stream: false,
+      debug: false,
+      max_turns: Float::INFINITY,
+      execute_tools: true
+    )
+      if stream
+        run_and_stream(
+          agent: agent,
+          messages: messages,
+          context_variables: context_variables,
+          model_override: model_override,
+          debug: debug,
+          max_turns: max_turns,
+          execute_tools: execute_tools
+        )
+      else
+        active_agent = agent
+        context_variables = context_variables.dup
+        history = messages.dup
+        init_len = messages.length
+
+        while (history.length - init_len) < max_turns && active_agent
+          completion = get_chat_completion(
+            agent: active_agent,
+            history: history,
+            context_variables: context_variables,
+            model_override: model_override,
+            stream: stream,
+            debug: debug
+          )
+
+          message = completion["choices"][0]["message"]
+          Util.debug_print(debug, "Received completion:", message)
+          message["sender"] = active_agent.name
+          history << message
+
+          unless message["function_call"] && execute_tools
+            Util.debug_print(debug, "Ending turn.")
+            break
+          end
+
+          tool_calls = [message["function_call"]]
+          partial_response = handle_tool_calls(
+            tool_calls, active_agent.functions, context_variables, debug
+          )
+          history.concat(partial_response.messages)
+          context_variables.merge!(partial_response.context_variables)
+          active_agent = partial_response.agent if partial_response.agent
+        end
+
+        Response.new(
+          messages: history[init_len..],
+          agent: active_agent,
+          context_variables: context_variables
+        )
+      end
+    end
+
+    def run_and_stream(
+      agent:,
+      messages:,
+      context_variables: {},
+      model_override: nil,
+      debug: false,
+      max_turns: Float::INFINITY,
+      execute_tools: true
+    )
+    end
+  end
+end

data/lib/swarm/repl.rb

@@ -0,0 +1,97 @@
+require "json"
+require_relative "core"
+require "dotenv/load"
+
+module Swarm
+  module Repl
+    def self.process_and_print_streaming_response(response)
+      content = ""
+      last_sender = ""
+
+      response.each do |chunk|
+        if chunk["sender"]
+          last_sender = chunk["sender"]
+        end
+
+        if chunk["content"]
+          if content.empty? && last_sender
+            print "\e[94m#{last_sender}:\e[0m "
+            last_sender = ""
+          end
+          print chunk["content"]
+          content += chunk["content"]
+        end
+
+        chunk["tool_calls"]&.each do |tool_call|
+          func = tool_call["function"]
+          name = func["name"]
+          next unless name
+          puts "\e[94m#{last_sender}: \e[95m#{name}\e[0m()"
+        end
+
+        if chunk["delim"] == "end" && !content.empty?
+          puts
+          content = ""
+        end
+
+        return chunk["response"] if chunk["response"]
+      end
+    end
+
+    def self.pretty_print_messages(messages)
+      messages.each do |message|
+        next unless message["role"] == "assistant"
+
+        # Print agent name in blue
+        print "\e[94m#{message["sender"]}\e[0m: "
+
+        puts message["content"] if message["content"]
+
+        tool_calls = message["tool_calls"] || []
+        puts if tool_calls.length > 1
+        tool_calls.each do |tool_call|
+          func = tool_call["function"]
+          name = func["name"]
+          args = JSON.parse(func["arguments"] || "{}").map { |k, v| "#{k}=#{v}" }.join(", ")
+          puts "\e[95m#{name}\e[0m(#{args})"
+        end
+      end
+    end
+
+    def self.run_demo_loop(
+      starting_agent,
+      context_variables = nil,
+      stream = false,
+      debug = false
+    )
+      client = Swarm.new
+      puts "Starting Swarm CLI \u{1F41D}"
+
+      messages = []
+      agent = starting_agent
+
+      loop do
+        print "\e[90mUser\e[0m: "
+        user_input = gets.chomp
+        messages << {"role" => "user", "content" => user_input}
+
+        response = client.run(
+          agent: agent,
+          messages: messages,
+          context_variables: context_variables || {},
+          stream: stream,
+          debug: debug
+        )
+
+        if stream
+          response = process_and_print_streaming_response(response)
+        else
+          pretty_print_messages(response.messages)
+        end
+
+        messages.concat(response.messages)
+        agent = response.agent
+      end
+    end
+  end
+end

data/lib/swarm/types.rb

@@ -0,0 +1,41 @@
+module Swarm
+  class Agent
+    attr_accessor :name, :model, :instructions, :functions, :tool_choice, :parallel_tool_calls
+
+    def initialize(
+      name: "Agent",
+      model: "gpt-4",
+      instructions: "You are a helpful agent.",
+      functions: [],
+      tool_choice: nil,
+      parallel_tool_calls: true
+    )
+      @name = name
+      @model = model
+      @instructions = instructions
+      @functions = functions
+      @tool_choice = tool_choice
+      @parallel_tool_calls = parallel_tool_calls
+    end
+  end
+
+  class Response
+    attr_accessor :messages, :agent, :context_variables
+
+    def initialize(messages: [], agent: nil, context_variables: {})
+      @messages = messages
+      @agent = agent
+      @context_variables = context_variables
+    end
+  end
+
+  class Result
+    attr_accessor :value, :agent, :context_variables
+
+    def initialize(value: "", agent: nil, context_variables: {})
+      @value = value
+      @agent = agent
+      @context_variables = context_variables
+    end
+  end
+end

data/lib/swarm/util.rb

@@ -0,0 +1,71 @@
+require "time"
+require "json"
+
+module Swarm
+  module Util
+    def self.debug_print(debug, *args)
+      return unless debug
+      timestamp = Time.now.strftime("%Y-%m-%d %H:%M:%S")
+      message = args.join(" ")
+      puts "\e[97m[\e[90m#{timestamp}\e[97m]\e[90m #{message}\e[0m"
+    end
+
+    def self.merge_fields(target, source)
+      source.each do |key, value|
+        if value.is_a?(String)
+          target[key] += value
+        elsif value.is_a?(Hash)
+          merge_fields(target[key], value)
+        end
+      end
+    end
+
+    def self.merge_chunk(final_response, delta)
+      delta.delete("role")
+      merge_fields(final_response, delta)
+
+      tool_calls = delta["tool_calls"]
+      if tool_calls && !tool_calls.empty?
+        index = tool_calls[0].delete("index")
+        merge_fields(final_response["tool_calls"][index], tool_calls[0])
+      end
+    end
+
+    def self.function_to_json(func)
+      type_map = {
+        String => "string",
+        Integer => "integer",
+        Float => "number",
+        TrueClass => "boolean",
+        FalseClass => "boolean",
+        Array => "array",
+        Hash => "object",
+        NilClass => "null"
+      }
+
+      parameters = {}
+      required = []
+
+      func.parameters.each do |type, name|
+        param_type = type_map[name.class] || "string" # Default to 'string' if type is unknown
+
+        if name.to_s == "context_variables" && type == :keyreq
+          param_type = "object"
+        end
+
+        parameters[name.to_s] = {"type" => param_type}
+        required << name.to_s if type == :req || type == :keyreq
+      end
+
+      {
+        "name" => func.name.to_s,
+        "description" => "",
+        "parameters" => {
+          "type" => "object",
+          "properties" => parameters,
+          "required" => required
+        }
+      }
+    end
+  end
+end

data/lib/swarm.rb

@@ -0,0 +1,9 @@
+require "dotenv"
+Dotenv.load
+
+module Swarm
+  require_relative "swarm/core"
+  require_relative "swarm/types"
+  require_relative "swarm/util"
+  require_relative "swarm/repl"
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: swarm-rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Landon gray
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  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: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !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'
+description: A Ruby implementation of the Swarm library for managing AI agent interactions
+email: landon.gray@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Readme.md
+- lib/swarm.rb
+- lib/swarm/core.rb
+- lib/swarm/repl.rb
+- lib/swarm/types.rb
+- lib/swarm/util.rb
+homepage: https://rubygems.org/gems/swarm-rb
+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.3.7
+signing_key:
+specification_version: 4
+summary: 'Swarm-rb: A Ruby gem for AI agent interactions'
+test_files: []