active_agent_rails 0.1.0

data/lib/active_agent/providers/openai.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+
+module ActiveAgent
+  module Provider
+    class OpenAI < Base
+      def chat(messages, tools: [], &block)
+        api_model = model || "gpt-4o-mini"
+        url = "https://api.openai.com/v1/chat/completions"
+
+        body = {
+          model: api_model,
+          messages: format_messages(messages)
+        }
+
+        if tools.any?
+          body[:tools] = format_tools(tools)
+        end
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}"
+        }
+
+        if block_given?
+          body[:stream] = true
+          text_accumulator = ""
+          tool_calls_accumulator = {}
+
+          post_request(url, headers, body) do |line|
+            next unless line.start_with?("data:")
+            json_str = line.sub("data:", "").strip
+            next if json_str == "[DONE]"
+            next if json_str.empty?
+
+            begin
+              chunk = JSON.parse(json_str)
+              choice = chunk.dig("choices", 0)
+              next unless choice
+
+              delta = choice["delta"]
+              next unless delta
+
+              if delta["content"]
+                text_accumulator += delta["content"]
+                yield(delta["content"])
+              end
+
+              if delta["tool_calls"]
+                delta["tool_calls"].each do |tc|
+                  index = tc["index"]
+                  tool_calls_accumulator[index] ||= { id: "", name: "", arguments_str: "" }
+                  
+                  tool_calls_accumulator[index][:id] = tc["id"] if tc["id"]
+                  tool_calls_accumulator[index][:name] = tc.dig("function", "name") if tc.dig("function", "name")
+                  
+                  if tc.dig("function", "arguments")
+                    tool_calls_accumulator[index][:arguments_str] += tc.dig("function", "arguments")
+                  end
+                end
+              end
+            rescue JSON::ParserError
+              # Ignore json parse errors for incomplete lines
+            end
+          end
+
+          # Format accumulated tool calls back to standard structure
+          tool_calls = tool_calls_accumulator.values.map do |tc|
+            args = {}
+            begin
+              args = JSON.parse(tc[:arguments_str], symbolize_names: true) unless tc[:arguments_str].empty?
+            rescue JSON::ParserError
+              ActiveAgent.logger.warn("OpenAI could not parse streaming arguments JSON: #{tc[:arguments_str]}")
+            end
+
+            {
+              id: tc[:id],
+              name: tc[:name],
+              args: args
+            }
+          end
+
+          result = { role: "assistant" }
+          result[:content] = text_accumulator unless text_accumulator.empty?
+          result[:tool_calls] = tool_calls if tool_calls.any?
+          result
+        else
+          response_json = post_request(url, headers, body)
+          parse_response(response_json)
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |tool|
+          properties = {}
+          tool.parameters.each do |name, info|
+            properties[name] = {
+              type: Tool.map_type(info[:type], uppercase: false),
+              description: info[:description]
+            }
+          end
+
+          {
+            type: "function",
+            function: {
+              name: tool.name,
+              description: tool.description,
+              parameters: {
+                type: "object",
+                properties: properties,
+                required: tool.required_parameters
+              }
+            }
+          }
+        end
+      end
+
+      private
+
+      def format_messages(messages)
+        messages.map do |msg|
+          formatted = {
+            role: msg[:role].to_s,
+            content: msg[:content]
+          }
+
+          if msg[:role].to_s == "assistant" && msg[:tool_calls]&.any?
+            formatted[:tool_calls] = msg[:tool_calls].map do |tc|
+              {
+                id: tc[:id] || tc[:name],
+                type: "function",
+                function: {
+                  name: tc[:name],
+                  arguments: tc[:args].to_json
+                }
+              }
+            end
+            formatted[:content] = nil # OpenAI requires content to be nil if tool_calls is present
+          elsif msg[:role].to_s == "tool"
+            formatted[:tool_call_id] = msg[:tool_call_id] || msg[:name]
+            formatted[:name] = msg[:name]
+          end
+
+          formatted
+        end
+      end
+
+      def parse_response(response)
+        choice = response.dig("choices", 0, "message")
+        return { role: "assistant", content: "Error: No response from model." } unless choice
+
+        result = { role: "assistant" }
+        result[:content] = choice["content"] if choice["content"]
+
+        if choice["tool_calls"]
+          result[:tool_calls] = choice["tool_calls"].map do |tc|
+            args_json = tc.dig("function", "arguments")
+            args = {}
+            begin
+              args = JSON.parse(args_json, symbolize_names: true) if args_json
+            rescue JSON::ParserError
+              ActiveAgent.logger.warn("OpenAI could not parse arguments JSON: #{args_json}")
+            end
+
+            {
+              id: tc["id"],
+              name: tc.dig("function", "name"),
+              args: args
+            }
+          end
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/active_agent/tool.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  class Tool
+    attr_reader :name, :description, :parameters, :required_parameters
+
+    def initialize(name, description: "", &block)
+      @name = name.to_s
+      @description = description
+      @parameters = {}
+      @required_parameters = []
+      instance_eval(&block) if block_given?
+    end
+
+    def parameter(param_name, type: :string, description: "", required: true)
+      @parameters[param_name.to_s] = {
+        type: type,
+        description: description
+      }
+      @required_parameters << param_name.to_s if required
+    end
+
+    # Translates ruby types to API-specific type strings
+    def self.map_type(type, uppercase: false)
+      mapped = case type.to_sym
+               when :string then "string"
+               when :integer then "integer"
+               when :number, :float then "number"
+               when :boolean then "boolean"
+               when :array then "array"
+               when :object then "object"
+               else "string"
+               end
+      uppercase ? mapped.upcase : mapped
+    end
+  end
+end

data/lib/active_agent/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  VERSION = "0.1.0"
+end

data/lib/active_agent.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/core_ext"
+
+require_relative "active_agent/version"
+require_relative "active_agent/configuration"
+require_relative "active_agent/tool"
+require_relative "active_agent/memory/base"
+require_relative "active_agent/provider"
+require_relative "active_agent/base"
+
+if defined?(Rails)
+  require_relative "active_agent/engine"
+end
+
+module ActiveAgent
+  # Global helper to resolve an agent class by name or symbol
+  def self.find_agent(name)
+    agent_class_name = "#{name.to_s.camelize}Agent"
+    agent_class_name.constantize
+  rescue NameError
+    raise "Could not find agent class: #{agent_class_name}. Ensure it is defined in app/agents/."
+  end
+end

data/lib/active_agent_rails.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "active_agent"

data/lib/generators/active_agent/agent/agent_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module ActiveAgent
+  module Generators
+    class AgentGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("templates", __dir__)
+
+      def create_agent_file
+        template "agent.rb.erb", "app/agents/#{file_name}_agent.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_agent/agent/templates/agent.rb.erb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class <%= class_name %>Agent < ActiveAgent::Base
+  # Configure provider and model (defaults to configuration settings if omitted)
+  provider :gemini # Options: :gemini, :openai, :anthropic
+  model "gemini-2.5-flash"
+
+  system_prompt "You are a helpful assistant."
+
+  # Expose tools to the agent using the `tool` DSL.
+  # Example:
+  #
+  # tool :get_current_time, description: "Retrieve the current server time and timezone" do
+  #   # Parameters are documented for the LLM
+  #   parameter :format, type: :string, description: "Optional strftime format", required: false
+  # end
+  #
+  # # Define the tool implementation as a standard Ruby instance method:
+  # def get_current_time(format: "%Y-%m-%d %H:%M:%S %Z")
+  #   Time.current.strftime(format)
+  # end
+end

data/lib/generators/active_agent/install/install_generator.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/migration"
+
+module ActiveAgent
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      def self.next_migration_number(path)
+        next_num = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        begin
+          ActiveRecord::Generators::Base.next_migration_number(path)
+        rescue StandardError
+          next_num
+        end
+      end
+
+      def create_initializer
+        template "active_agent.rb", "config/initializers/active_agent.rb"
+      end
+
+      def create_migration_file
+        migration_template "create_active_agent_messages.rb", "db/migrate/create_active_agent_messages.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_agent/install/templates/active_agent.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+ActiveAgent.configure do |config|
+  # Default provider: :gemini, :openai, or :anthropic
+  config.default_provider = :gemini
+
+  # API Keys for providers (recommend storing in Rails credentials or environment variables)
+  config.gemini_api_key = ENV["GEMINI_API_KEY"]
+  config.openai_api_key = ENV["OPENAI_API_KEY"]
+  config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+
+  # Memory store for chat conversations: :in_memory or :active_record
+  # Note: If using :active_record, ensure you run: rails db:migrate
+  config.memory_store = :active_record
+end

data/lib/generators/active_agent/install/templates/create_active_agent_messages.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class CreateActiveAgentMessages < ActiveRecord::Migration[<%= ActiveRecord::VERSION::MAJOR %>.<%= ActiveRecord::VERSION::MINOR %>]
+  def change
+    create_table :active_agent_messages do |t|
+      t.string :conversation_id, null: false
+      t.string :role, null: false
+      t.text :content
+      t.string :tool_call_id
+      t.string :name
+      t.text :tool_calls # serialized JSON array
+
+      t.timestamps
+    end
+
+    add_index :active_agent_messages, :conversation_id
+  end
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: active_agent_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shiboshree Roy
+- Antigravity AI
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+description: ActiveAgent provides a clean, unified interface to build AI agents with
+  automatic tool/function calling, ActiveRecord-backed conversation memory, and an
+  engine to stream real-time responses to a floating UI widget in your views.
+email:
+- support@example.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/active_agent/chats_controller.rb
+- app/helpers/active_agent/chat_helper.rb
+- config/routes.rb
+- lib/active_agent.rb
+- lib/active_agent/base.rb
+- lib/active_agent/configuration.rb
+- lib/active_agent/engine.rb
+- lib/active_agent/memory/active_record.rb
+- lib/active_agent/memory/base.rb
+- lib/active_agent/memory/in_memory.rb
+- lib/active_agent/provider.rb
+- lib/active_agent/providers/anthropic.rb
+- lib/active_agent/providers/gemini.rb
+- lib/active_agent/providers/openai.rb
+- lib/active_agent/tool.rb
+- lib/active_agent/version.rb
+- lib/active_agent_rails.rb
+- lib/generators/active_agent/agent/agent_generator.rb
+- lib/generators/active_agent/agent/templates/agent.rb.erb
+- lib/generators/active_agent/install/install_generator.rb
+- lib/generators/active_agent/install/templates/active_agent.rb
+- lib/generators/active_agent/install/templates/create_active_agent_messages.rb
+homepage: https://github.com/active-agent/active_agent_rails
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  source_code_uri: https://github.com/active-agent/active_agent_rails
+  changelog_uri: https://github.com/active-agent/active_agent_rails/releases
+  bug_tracker_uri: https://github.com/active-agent/active_agent_rails/issues
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.11
+specification_version: 4
+summary: A Rails-like framework to integrate LLMs, AI agents, and custom tools into
+  Ruby on Rails applications easily.
+test_files: []