rcrewai-rails 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a983bc15d53694f94c8730ff76d92b4d2b51c5526d4ce72b3e8df78251328f16
-  data.tar.gz: 30cf57ab32d034b63fd3ff3f94a26afe3db2d6b2db02261378a59a9dd0bb6ce5
+  metadata.gz: 2d2402d751d591a36e40134763d02f9c45d3b9fe3f3e38bfbcda988f08764269
+  data.tar.gz: d1e38e88b3effbba297ea931df56a7499912d8c2f7c7d4dd02b1b9c4e71fba1b
 SHA512:
-  metadata.gz: e30e0d23b8dac34e84eb157cb5ac9478f3025ffb48805001e16548b0d238f93f2b631ed585484dd6aca17f126fce967ee1754edc07ab3a3c5c2655149d6ddc12
-  data.tar.gz: dcda024dbcfec7f39e84c6e40aab2a3f8e9c1b53e9aa0a8d80f0220bd2a84be0b2a118a40296c5a96afff12b0dc9b0b829961e9643c7cd383f01603935643765
+  metadata.gz: bdaa9583e0b28908b9b44ae811dcb9c48e3fa5e25f929028c09e26911abc825f2867245b83a62112676c8b431cd83c7185320d43c65ee683b5e7d415bb9a6529
+  data.tar.gz: 425ebe18b1e13d9963887e5906f47574ade7c882347d4086ff1f9b32b9814424379f6e9193248e7febc433649ff63624008bcc9434473653e4d345be21f2729d

data/app/jobs/rcrewai/rails/crew_execution_job.rb

@@ -13,52 +13,63 @@ module RcrewAI
 
         begin
           execution.start!
-          execution.log("info", "Starting crew execution", { crew_id: crew.id })
+          execution.log("info", "Starting crew execution", { crew_id: crew.id, inputs: inputs })
 
-          # Convert Rails models to RcrewAI objects
           rcrew = crew.to_rcrew
-          
-          # Execute the crew with logging
-          result = execute_with_logging(rcrew, inputs, execution)
-          
+
+          result = rcrew.execute(stream: stream_sink_for(execution))
+
           execution.complete!(result)
-          execution.log("info", "Crew execution completed successfully", { result: result })
-          
-          # Trigger callbacks if configured
+          execution.log("info", "Crew execution completed", { result: result })
+
           notify_completion(crew, execution, result)
-          
+
           result
         rescue => e
           execution.fail!(e)
-          execution.log("error", "Crew execution failed", { 
+          execution.log("error", "Crew execution failed", {
             error: e.message,
-            backtrace: e.backtrace.first(5)
+            backtrace: e.backtrace&.first(5)
           })
-          
-          # Re-raise for ActiveJob retry mechanism
+
           raise
         end
       end
 
       private
 
-      def execute_with_logging(rcrew, inputs, execution)
-        # Set up logging callbacks
-        rcrew.before_task do |task|
-          execution.log("info", "Starting task: #{task.description}")
-        end
-
-        rcrew.after_task do |task, output|
-          execution.log("info", "Completed task: #{task.description}", { output: output })
+      # Build a stream sink that translates rcrewai events into ExecutionLog rows.
+      # Note: the gem currently builds the sink but does not yet thread it down
+      # to per-agent execution, so this is wired up for forward-compatibility.
+      def stream_sink_for(execution)
+        lambda do |event|
+          case event
+          when RCrewAI::Events::IterationStart
+            execution.log("debug", "Iteration #{event.iteration_index} start", { agent: event.agent })
+          when RCrewAI::Events::IterationEnd
+            execution.log("debug", "Iteration end", { agent: event.agent, finish_reason: event.finish_reason })
+          when RCrewAI::Events::ToolCallStart
+            execution.log("info", "Tool call: #{event.tool}", { args: event.args, agent: event.agent })
+          when RCrewAI::Events::ToolCallResult
+            execution.log("info", "Tool result: #{event.tool}", { duration_ms: event.duration_ms, agent: event.agent })
+          when RCrewAI::Events::ToolCallError
+            execution.log("error", "Tool error: #{event.tool}", { error: event.error, agent: event.agent })
+          when RCrewAI::Events::Usage
+            execution.log("debug", "Usage", {
+              prompt_tokens: event.prompt_tokens,
+              completion_tokens: event.completion_tokens,
+              total_tokens: event.total_tokens,
+              cost_usd: event.cost_usd,
+              agent: event.agent
+            })
+          when RCrewAI::Events::Error
+            execution.log("error", "Crew error", { error: event.error, agent: event.agent })
+          end
         end
-
-        # Execute the crew
-        rcrew.kickoff(inputs)
       end
 
       def notify_completion(crew, execution, result)
-        # Send notifications if configured
-        if crew.notification_webhook_url.present?
+        if crew.respond_to?(:notification_webhook_url) && crew.notification_webhook_url.present?
           NotificationJob.perform_later(
             crew.notification_webhook_url,
             {
@@ -70,7 +81,6 @@ module RcrewAI
           )
         end
 
-        # Trigger Rails events
         ActiveSupport::Notifications.instrument("crew_execution.completed", {
           crew: crew,
           execution: execution,
@@ -79,4 +89,4 @@ module RcrewAI
       end
     end
   end
-end
+end

data/app/jobs/rcrewai/rails/task_execution_job.rb

@@ -17,17 +17,25 @@ module RcrewAI
           rcrew_task = task.to_rcrew_task
           rcrew_agent = agent.to_rcrew_agent
 
-          # Execute the task
-          result = rcrew_agent.execute_task(rcrew_task, context: inputs)
+          # Execute the task. Agent#execute_task returns a hash:
+          #   { content:, tool_calls_history:, usage:, iterations:, finish_reason: }
+          # `inputs` is recorded by the caller and made available as task context
+          # via the Task#context column; the gem does not accept it as a kwarg.
+          result = rcrew_agent.execute_task(rcrew_task)
+          content = result.is_a?(Hash) ? result[:content].to_s : result.to_s
 
           execution_log[:completed_at] = Time.current
           execution_log[:status] = "completed"
-          execution_log[:result] = result
+          execution_log[:result] = content
+          if result.is_a?(Hash)
+            execution_log[:usage] = result[:usage]
+            execution_log[:tool_calls] = result[:tool_calls_history]
+            execution_log[:iterations] = result[:iterations]
+            execution_log[:finish_reason] = result[:finish_reason]
+          end
 
           # Save result if configured
-          if task.output_file.present?
-            save_output_to_file(task.output_file, result)
-          end
+          save_output_to_file(task.output_file, content) if task.output_file.present?
 
           # Log success
           ::Rails.logger.info "Task #{task.id} completed successfully by agent #{agent.id}"

data/app/models/rcrewai/rails/agent.rb

@@ -17,16 +17,14 @@ module RcrewAI
 
       def to_rcrew_agent
         RCrewAI::Agent.new(
+          name: name,
           role: role,
           goal: goal,
           backstory: backstory,
-          memory: memory_enabled,
           verbose: verbose,
           allow_delegation: allow_delegation,
           tools: instantiated_tools,
-          max_iter: max_iterations,
-          max_rpm: max_rpm,
-          llm: llm_config
+          max_iterations: max_iterations
         )
       end
 

data/app/models/rcrewai/rails/crew.rb

@@ -18,14 +18,9 @@ module RcrewAI
 
       def to_rcrew
         crew = RCrewAI::Crew.new(
-          name: name,
-          description: description,
+          name,
           process: process_type.to_sym,
-          verbose: verbose,
-          memory: memory_enabled,
-          cache: cache_enabled,
-          max_rpm: max_rpm,
-          manager_llm: manager_llm
+          verbose: verbose
         )
 
         agents.each do |agent|

data/app/models/rcrewai/rails/task.rb

@@ -20,14 +20,12 @@ module RcrewAI
 
       def to_rcrew_task
         RCrewAI::Task.new(
+          name: rcrew_task_name,
           description: description,
           expected_output: expected_output,
           agent: agent&.to_rcrew_agent,
           context: context,
-          async_execution: async_execution,
-          output_json: output_json,
-          output_pydantic: output_pydantic,
-          output_file: output_file,
+          async: async_execution,
           tools: instantiated_tools,
           callback: callback_method
         )
@@ -54,6 +52,13 @@ module RcrewAI
 
       private
 
+      def rcrew_task_name
+        return "task_#{id}" if id
+        return description.to_s.parameterize.first(40).presence || "task" if description.present?
+
+        "task"
+      end
+
       def callback_method
         return nil unless callback_class.present? && callback_method_name.present?
         

data/lib/generators/rcrew_a_i/rails/crew/crew_generator.rb

@@ -0,0 +1,42 @@
+require "rails/generators"
+
+module RcrewAI
+  module Rails
+    module Generators
+      class CrewGenerator < ::Rails::Generators::NamedBase
+        source_root File.expand_path("templates", __dir__)
+
+        argument :process_type, type: :string, default: "sequential", banner: "sequential|hierarchical"
+
+        class_option :agents, type: :array, default: [], desc: "List of agents to create"
+        class_option :description, type: :string, desc: "Crew description"
+
+        def create_crew_file
+          template "crew.rb.erb", "app/crews/#{file_name}_crew.rb"
+        end
+
+        def create_agent_files
+          options[:agents].each do |agent_name|
+            @agent_name = agent_name
+            template "agent.rb.erb", "app/crews/agents/#{agent_name.underscore}_agent.rb"
+          end
+        end
+
+        def display_next_steps
+          say "\n✅ Created #{class_name}Crew!", :green
+          say "\nNext steps:", :yellow
+          say "  1. Configure your crew in app/crews/#{file_name}_crew.rb"
+          say "  2. Define tasks for your crew"
+          say "  3. Run your crew with: #{class_name}Crew.new.execute"
+          say "\n"
+        end
+
+        private
+
+        def crew_description
+          options[:description] || "#{class_name} crew for AI task orchestration"
+        end
+      end
+    end
+  end
+end

data/lib/generators/rcrew_a_i/rails/crew/templates/agent.rb.erb

@@ -0,0 +1,45 @@
+class <%= @agent_name.camelize %>Agent
+  include RcrewAI::Rails::AgentBuilder
+
+  def initialize
+    @agent = RcrewAI::Agent.new(
+      role: role,
+      goal: goal,
+      backstory: backstory,
+      memory: true,
+      verbose: true,
+      allow_delegation: false,
+      tools: tools,
+      max_iter: 25,
+      max_rpm: 10
+    )
+  end
+
+  def role
+    "<%= @agent_name.humanize %> Specialist"
+  end
+
+  def goal
+    "Perform <%= @agent_name.humanize.downcase %> tasks efficiently and accurately"
+  end
+
+  def backstory
+    <<~BACKSTORY
+      You are a highly skilled <%= @agent_name.humanize.downcase %> specialist with extensive experience.
+      Your expertise allows you to handle complex <%= @agent_name.humanize.downcase %> challenges effectively.
+    BACKSTORY
+  end
+
+  def tools
+    [
+      # Add your tools here
+      # RcrewAI::Tools::WebSearch.new,
+      # RcrewAI::Tools::FileReader.new,
+      # CustomTool.new
+    ]
+  end
+
+  def to_agent
+    @agent
+  end
+end

data/lib/generators/rcrew_a_i/rails/crew/templates/crew.rb.erb

@@ -0,0 +1,72 @@
+class <%= class_name %>Crew
+  include RcrewAI::Rails::CrewBuilder
+
+  def initialize
+    @crew = RcrewAI::Rails::Crew.create!(
+      name: "<%= file_name %>",
+      description: "<%= crew_description %>",
+      process_type: "<%= process_type %>",
+      verbose: true,
+      memory_enabled: false,
+      cache_enabled: true
+    )
+
+    setup_agents
+    setup_tasks
+  end
+
+  def execute(inputs = {})
+    # Execute asynchronously via ActiveJob
+    @crew.execute_async(inputs)
+    
+    # Or execute synchronously:
+    # @crew.execute_sync(inputs)
+  end
+
+  private
+
+  def setup_agents
+    # Define your agents here
+    # Example:
+    # @researcher = @crew.agents.create!(
+    #   name: "researcher",
+    #   role: "Senior Research Analyst",
+    #   goal: "Uncover cutting-edge developments in AI and data science",
+    #   backstory: "You are an expert researcher with years of experience",
+    #   verbose: true,
+    #   allow_delegation: false
+    # )
+    <% options[:agents].each do |agent_name| %>
+    
+    @<%= agent_name.underscore %> = @crew.agents.create!(
+      name: "<%= agent_name.underscore %>",
+      role: "<%= agent_name.humanize %> Agent",
+      goal: "Perform <%= agent_name.humanize.downcase %> tasks",
+      backstory: "You are an expert <%= agent_name.humanize.downcase %> agent",
+      verbose: true,
+      allow_delegation: false
+    )
+    <% end %>
+  end
+
+  def setup_tasks
+    # Define your tasks here
+    # Example:
+    # @research_task = @crew.tasks.create!(
+    #   description: "Research the latest AI trends",
+    #   expected_output: "A comprehensive report on AI trends",
+    #   position: 1
+    # )
+    # @research_task.agents << @researcher
+    
+    # Task dependencies can be set like:
+    # @analysis_task.add_dependency(@research_task)
+  end
+
+  # Add any helper methods here
+  
+  # Example callback for task completion:
+  # def task_completed(output)
+  #   Rails.logger.info "Task completed with output: #{output}"
+  # end
+end

data/lib/generators/rcrew_a_i/rails/install/install_generator.rb

@@ -0,0 +1,40 @@
+require "rails/generators"
+require "rails/generators/migration"
+
+module RcrewAI
+  module Rails
+    module Generators
+      class InstallGenerator < ::Rails::Generators::Base
+        include ::Rails::Generators::Migration
+
+        source_root File.expand_path("templates", __dir__)
+
+        def self.next_migration_number(dirname)
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+
+        def create_migration_file
+          migration_template "create_rcrewai_tables.rb", "db/migrate/create_rcrewai_tables.rb", migration_class_name: "CreateRcrewaiTables"
+        end
+
+        def create_initializer
+          template "rcrewai.rb", "config/initializers/rcrewai.rb"
+        end
+
+        def add_routes
+          route "mount RcrewAI::Rails::Engine => '/rcrewai'"
+        end
+
+        def display_post_install_message
+          say "\n✅ RcrewAI Rails has been installed!", :green
+          say "\nNext steps:", :yellow
+          say "  1. Run migrations: rails db:migrate"
+          say "  2. Configure your settings in config/initializers/rcrewai.rb"
+          say "  3. Set your LLM API keys in environment variables"
+          say "  4. Visit /rcrewai for the web UI (if enabled)"
+          say "\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/rcrew_a_i/rails/install/templates/create_rcrewai_tables.rb

@@ -0,0 +1,109 @@
+class CreateRcrewaiTables < ActiveRecord::Migration[7.0]
+  def change
+    create_table :rcrewai_crews do |t|
+      t.string :name, null: false
+      t.text :description
+      t.string :process_type, default: "sequential"
+      t.boolean :verbose, default: false
+      t.boolean :memory_enabled, default: false
+      t.boolean :cache_enabled, default: false
+      t.integer :max_rpm
+      t.string :manager_llm
+      t.text :config
+      t.text :memory
+      t.boolean :active, default: true
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_crews, :name
+    add_index :rcrewai_crews, :active
+
+    create_table :rcrewai_agents do |t|
+      t.references :crew, null: false, foreign_key: { to_table: :rcrewai_crews }
+      t.string :name, null: false
+      t.string :role, null: false
+      t.text :goal
+      t.text :backstory
+      t.boolean :memory_enabled, default: false
+      t.boolean :verbose, default: false
+      t.boolean :allow_delegation, default: false
+      t.text :tools
+      t.integer :max_iterations, default: 25
+      t.integer :max_rpm
+      t.text :llm_config
+      t.boolean :active, default: true
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_agents, :name
+
+    create_table :rcrewai_tasks do |t|
+      t.references :crew, null: false, foreign_key: { to_table: :rcrewai_crews }
+      t.text :description, null: false
+      t.text :expected_output, null: false
+      t.boolean :async_execution, default: false
+      t.text :context
+      t.text :output_json
+      t.text :output_pydantic
+      t.string :output_file
+      t.text :tools
+      t.string :callback_class
+      t.string :callback_method_name
+      t.integer :position
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_tasks, :position
+
+    create_table :rcrewai_task_assignments do |t|
+      t.references :task, null: false, foreign_key: { to_table: :rcrewai_tasks }
+      t.references :agent, null: false, foreign_key: { to_table: :rcrewai_agents }
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_task_assignments, [:task_id, :agent_id], unique: true
+
+    create_table :rcrewai_task_dependencies do |t|
+      t.references :task, null: false, foreign_key: { to_table: :rcrewai_tasks }
+      t.references :dependency, null: false, foreign_key: { to_table: :rcrewai_tasks }
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_task_dependencies, [:task_id, :dependency_id], unique: true
+
+    create_table :rcrewai_executions do |t|
+      t.references :crew, null: false, foreign_key: { to_table: :rcrewai_crews }
+      t.string :status, null: false
+      t.text :inputs
+      t.text :output
+      t.string :error_message
+      t.text :error_details
+      t.datetime :started_at
+      t.datetime :completed_at
+      t.integer :duration_seconds
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_executions, :status
+    add_index :rcrewai_executions, :created_at
+
+    create_table :rcrewai_execution_logs do |t|
+      t.references :execution, null: false, foreign_key: { to_table: :rcrewai_executions }
+      t.string :level, null: false
+      t.text :message, null: false
+      t.text :details
+      t.datetime :timestamp, null: false
+
+      t.timestamps
+    end
+
+    add_index :rcrewai_execution_logs, :level
+    add_index :rcrewai_execution_logs, :timestamp
+  end
+end

data/lib/generators/rcrew_a_i/rails/install/templates/rcrewai.rb

@@ -0,0 +1,53 @@
+RcrewAI::Rails.configure do |config|
+  # ActiveJob queue name for background processing
+  # Default: "default"
+  config.job_queue_name = ENV.fetch("RCREWAI_QUEUE", "default")
+
+  # Enable web UI for monitoring crews
+  # Default: true
+  config.enable_web_ui = ENV.fetch("RCREWAI_WEB_UI", "true") == "true"
+
+  # Use ActiveJob for async execution
+  # Default: true
+  config.async_execution = ENV.fetch("RCREWAI_ASYNC", "true") == "true"
+
+  # Persistence backend (currently only :active_record supported)
+  # Default: :active_record
+  config.persistence_backend = :active_record
+
+  # Default LLM provider
+  # Options: "openai", "anthropic", "cohere", "groq", etc.
+  config.default_llm_provider = ENV.fetch("RCREWAI_LLM_PROVIDER", "openai")
+
+  # Default LLM model
+  config.default_llm_model = ENV.fetch("RCREWAI_LLM_MODEL", "gpt-4")
+
+  # Maximum retries for failed tasks
+  # Default: 3
+  config.max_retries = 3
+
+  # Timeout for crew execution (in seconds)
+  # Default: 300 (5 minutes)
+  config.timeout = 300
+
+  # Enable logging
+  # Default: true
+  config.enable_logging = true
+
+  # Log level
+  # Options: :debug, :info, :warn, :error
+  # Default: :info
+  config.log_level = :info
+end
+
+# Configure RcrewAI base gem if needed
+RcrewAI.configure do |config|
+  # Set your API keys here or in environment variables
+  # config.openai_api_key = ENV["OPENAI_API_KEY"]
+  # config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"]
+  # config.groq_api_key = ENV["GROQ_API_KEY"]
+  
+  # Configure other RcrewAI settings
+  # config.default_model = "gpt-4"
+  # config.temperature = 0.7
+end

data/lib/generators/rcrewai/rails/install/install_generator.rb

@@ -1,32 +1,37 @@
 require "rails/generators"
+require "rails/generators/migration"
 
 module RcrewAI
   module Rails
     module Generators
       class InstallGenerator < ::Rails::Generators::Base
+        include ::Rails::Generators::Migration
+
         source_root File.expand_path("templates", __dir__)
 
+        def self.next_migration_number(dirname)
+          Time.now.utc.strftime("%Y%m%d%H%M%S")
+        end
+
+        def create_migration_file
+          migration_template "create_rcrewai_tables.rb", "db/migrate/create_rcrewai_tables.rb", migration_class_name: "CreateRcrewaiTables"
+        end
+
         def create_initializer
-          create_file "config/initializers/rcrewai.rb", <<~RUBY
-            RcrewAI.configure do |config|
-              # Configure your LLM settings
-              # config.default_llm = :openai
-              # config.openai_api_key = ENV['OPENAI_API_KEY']
-              
-              # Rails specific configuration
-              config.job_queue_name = ENV.fetch("RCREWAI_QUEUE", "default")
-              config.enable_web_ui = ENV.fetch("RCREWAI_WEB_UI", "true") == "true"
-              config.async_execution = ENV.fetch("RCREWAI_ASYNC", "true") == "true"
-            end
-          RUBY
+          template "rcrewai.rb", "config/initializers/rcrewai.rb"
+        end
+
+        def add_routes
+          route "mount RcrewAI::Rails::Engine => '/rcrewai'"
         end
 
         def display_post_install_message
           say "\n✅ RcrewAI Rails has been installed!", :green
           say "\nNext steps:", :yellow
-          say "  1. Configure your settings in config/initializers/rcrewai.rb"
-          say "  2. Set your LLM API keys in environment variables"
-          say "  3. Start building AI crews with RcrewAI!"
+          say "  1. Run migrations: rails db:migrate"
+          say "  2. Configure your settings in config/initializers/rcrewai.rb"
+          say "  3. Set your LLM API keys in environment variables"
+          say "  4. Visit /rcrewai for the web UI (if enabled)"
           say "\n"
         end
       end

data/lib/rcrewai/rails/agent_builder.rb

@@ -62,7 +62,6 @@ module RcrewAI
       def initialize(attributes = {})
         @attributes = attributes
         @agent = build_agent
-        setup_tools
         configure_agent
       end
 
@@ -78,20 +77,19 @@ module RcrewAI
 
       def build_agent
         RCrewAI::Agent.new(
+          name: @attributes[:name] || default_agent_name,
           role: @attributes[:role] || self.class.agent_role,
           goal: @attributes[:goal] || self.class.agent_goal,
           backstory: @attributes[:backstory] || self.class.agent_backstory,
-          memory: @attributes[:memory] || self.class.memory_enabled,
+          tools: instantiate_tools,
           verbose: verbose?,
           allow_delegation: @attributes[:allow_delegation] || self.class.allow_delegation,
-          max_iter: @attributes[:max_iterations] || self.class.max_iterations,
-          llm: @attributes[:llm_config] || self.class.llm_config
+          max_iterations: @attributes[:max_iterations] || self.class.max_iterations
         )
       end
 
-      def setup_tools
-        tools = instantiate_tools
-        @agent.tools = tools if tools.any?
+      def default_agent_name
+        self.class.name.to_s.split("::").last&.underscore.presence || "agent"
       end
 
       def instantiate_tools

data/lib/rcrewai/rails/engine.rb

@@ -19,11 +19,6 @@ module RcrewAI
         #{config.root}/lib
       ]
 
-      # Tell Zeitwerk to ignore generator files - they aren't meant to be autoloaded
-      initializer "rcrewai_rails.zeitwerk" do |app|
-        ::Rails.autoloaders.main.ignore("#{root}/lib/generators")
-      end
-
       config.generators do |g|
         g.test_framework :rspec
         g.fixture_replacement :factory_bot
@@ -31,8 +26,10 @@ module RcrewAI
       end
 
       initializer "rcrewai_rails.assets" do |app|
-        app.config.assets.paths << root.join("app/assets/stylesheets")
-        app.config.assets.paths << root.join("app/assets/javascripts")
+        if app.config.respond_to?(:assets)
+          app.config.assets.paths << root.join("app/assets/stylesheets")
+          app.config.assets.paths << root.join("app/assets/javascripts")
+        end
       end
 
 

data/lib/rcrewai/rails/tools/action_mailer_tool.rb

@@ -2,35 +2,46 @@ module RcrewAI
   module Rails
     module Tools
       class ActionMailerTool < RCrewAI::Tools::Base
+        tool_name "action_mailer_send"
+        description "Send emails using a Rails Action Mailer. Choose the mailer class, the mailer method, and the delivery strategy."
+
+        param :mailer_method, type: :string, required: true,
+              description: "Name of the mailer method to invoke (e.g. 'welcome_email')."
+        param :mailer, type: :string, required: false,
+              description: "Mailer class name with or without the 'Mailer' suffix (e.g. 'User' or 'UserMailer'). Defaults to the mailer configured on the tool."
+        param :params, type: :object, required: false,
+              description: "Keyword arguments to pass to the mailer method."
+        param :deliver_method, type: :enum, required: false,
+              values: %w[deliver_now deliver_later deliver_later_at],
+              description: "How to send: deliver_now, deliver_later, or deliver_later_at."
+        param :at, type: :string, required: false,
+              description: "ISO8601 timestamp for deliver_later_at. Required when deliver_method is deliver_later_at."
+
         def initialize(mailer_class: nil, allowed_methods: [])
+          super()
           @mailer_class = mailer_class
-          @allowed_methods = allowed_methods
-          super(
-            name: "Action Mailer Tool",
-            description: "Send emails using Rails Action Mailer"
-          )
+          @allowed_methods = allowed_methods.map(&:to_sym)
         end
 
-        def execute(mailer_method, params = {}, deliver_method = :deliver_later)
-          validate_mailer_method!(mailer_method)
-          
-          mailer = get_mailer_class(params.delete(:mailer) || @mailer_class)
-          
-          # Build the mail object
-          mail = mailer.send(mailer_method, **params)
-          
-          # Deliver based on specified method
+        def execute(mailer_method:, mailer: nil, params: {}, deliver_method: "deliver_later", at: nil)
+          method_sym = mailer_method.to_sym
+          validate_mailer_method!(method_sym)
+
+          mailer_klass = resolve_mailer_class(mailer)
+          mailer_params = (params || {}).transform_keys(&:to_sym)
+          mail = mailer_klass.public_send(method_sym, **mailer_params)
+
           case deliver_method.to_sym
           when :deliver_now
             mail.deliver_now
-            { status: "sent", method: mailer_method, delivered_at: Time.current }
+            { status: "sent", method: method_sym, delivered_at: Time.current }
           when :deliver_later
             job = mail.deliver_later
-            { status: "queued", method: mailer_method, job_id: job.job_id }
+            { status: "queued", method: method_sym, job_id: job.job_id }
           when :deliver_later_at
-            delivery_time = params.delete(:at) || 1.hour.from_now
+            delivery_time = at.present? ? Time.iso8601(at) : 1.hour.from_now
             job = mail.deliver_later(wait_until: delivery_time)
-            { status: "scheduled", method: mailer_method, job_id: job.job_id, scheduled_for: delivery_time }
+            { status: "scheduled", method: method_sym, job_id: job.job_id, scheduled_for: delivery_time }
           else
             { error: "Unknown delivery method: #{deliver_method}" }
           end
@@ -41,15 +52,17 @@ module RcrewAI
         private
 
         def validate_mailer_method!(method)
-          if @allowed_methods.any? && !@allowed_methods.include?(method.to_sym)
-            raise ArgumentError, "Mailer method '#{method}' is not allowed"
-          end
+          return if @allowed_methods.empty? || @allowed_methods.include?(method)
+
+          raise ArgumentError, "Mailer method '#{method}' is not allowed"
         end
 
-        def get_mailer_class(mailer_name)
-          return @mailer_class if @mailer_class && mailer_name.nil?
-          
-          mailer_name = "#{mailer_name.to_s.camelize}Mailer" unless mailer_name.to_s.end_with?("Mailer")
+        def resolve_mailer_class(mailer_name)
+          return @mailer_class if mailer_name.nil? && @mailer_class
+          raise ArgumentError, "No mailer specified" if mailer_name.nil?
+
+          mailer_name = mailer_name.to_s
+          mailer_name = "#{mailer_name.camelize}Mailer" unless mailer_name.end_with?("Mailer")
           mailer_name.constantize
         rescue NameError
           raise ArgumentError, "Mailer class '#{mailer_name}' not found"
@@ -57,4 +70,4 @@ module RcrewAI
       end
     end
   end
-end
+end

data/lib/rcrewai/rails/tools/active_record_tool.rb

@@ -2,40 +2,50 @@ module RcrewAI
   module Rails
     module Tools
       class ActiveRecordTool < RCrewAI::Tools::Base
-        def initialize(model_class: nil, allowed_methods: [:find, :where, :count])
+        tool_name "active_record_query"
+        description "Query the Rails database using ActiveRecord. Supports find, find_by, where, count, pluck, exists?, first, last, and all."
+
+        param :query_type, type: :enum, required: true,
+              values: %w[find find_by where count pluck exists? first last all],
+              description: "ActiveRecord query method to invoke."
+        param :model, type: :string, required: false,
+              description: "Model class name (e.g. 'User'). Defaults to the model configured on the tool."
+        param :conditions, type: :object, required: false,
+              description: "Query conditions as a hash. For :find, include :id. For :pluck, include :field."
+
+        def initialize(model_class: nil, allowed_methods: %i[find where count])
+          super()
           @model_class = model_class
-          @allowed_methods = allowed_methods
-          super(
-            name: "ActiveRecord Query Tool",
-            description: "Query Rails database using ActiveRecord"
-          )
+          @allowed_methods = allowed_methods.map(&:to_sym)
         end
 
-        def execute(query_type, conditions = {})
+        def execute(query_type:, model: nil, conditions: {})
+          query_type = query_type.to_sym
           validate_query_type!(query_type)
-          
-          model = get_model_class(conditions.delete(:model) || @model_class)
-          
-          case query_type.to_sym
+
+          model_klass = resolve_model_class(model)
+          conds = (conditions || {}).transform_keys(&:to_sym)
+
+          case query_type
           when :find
-            model.find(conditions[:id])
+            model_klass.find(conds[:id])
           when :find_by
-            model.find_by(conditions)
+            model_klass.find_by(conds)
           when :where
-            model.where(conditions)
+            model_klass.where(conds)
           when :count
-            conditions.empty? ? model.count : model.where(conditions).count
+            conds.empty? ? model_klass.count : model_klass.where(conds).count
           when :pluck
-            field = conditions.delete(:field)
-            model.where(conditions).pluck(field)
+            field = conds.delete(:field)
+            model_klass.where(conds).pluck(field)
           when :exists?
-            model.exists?(conditions)
+            model_klass.exists?(conds)
           when :first
-            model.where(conditions).first
+            model_klass.where(conds).first
           when :last
-            model.where(conditions).last
+            model_klass.where(conds).last
           when :all
-            model.where(conditions).to_a
+            model_klass.where(conds).to_a
           else
             raise ArgumentError, "Unsupported query type: #{query_type}"
           end
@@ -48,20 +58,20 @@ module RcrewAI
         private
 
         def validate_query_type!(query_type)
-          unless @allowed_methods.include?(query_type.to_sym)
-            raise ArgumentError, "Query type '#{query_type}' is not allowed"
-          end
+          return if @allowed_methods.include?(query_type)
+
+          raise ArgumentError, "Query type '#{query_type}' is not allowed"
         end
 
-        def get_model_class(model_name)
-          return @model_class if @model_class && model_name.nil?
-          
-          model_name = model_name.to_s.camelize
-          model_name.constantize
+        def resolve_model_class(model_name)
+          return @model_class if model_name.nil? && @model_class
+          raise ArgumentError, "No model specified" if model_name.nil?
+
+          model_name.to_s.camelize.constantize
         rescue NameError
           raise ArgumentError, "Model class '#{model_name}' not found"
         end
       end
     end
   end
-end
+end

data/lib/rcrewai/rails/tools/active_storage_tool.rb

@@ -2,30 +2,32 @@ module RcrewAI
   module Rails
     module Tools
       class ActiveStorageTool < RCrewAI::Tools::Base
-        def initialize(allowed_operations: [:attach, :download, :analyze])
-          @allowed_operations = allowed_operations
-          super(
-            name: "Active Storage Tool",
-            description: "Manage file attachments using Rails Active Storage"
-          )
+        tool_name "active_storage"
+        description "Manage Rails Active Storage attachments: attach, download, analyze, delete, or build a URL."
+
+        param :operation, type: :enum, required: true,
+              values: %w[attach download analyze delete url],
+              description: "Active Storage operation to perform."
+        param :params, type: :object, required: false,
+              description: "Operation parameters (model, id, attachment_name, blob_id, signed_id, key, file, filename, content_type, expires_in)."
+
+        def initialize(allowed_operations: %i[attach download analyze])
+          super()
+          @allowed_operations = allowed_operations.map(&:to_sym)
         end
 
-        def execute(operation, params = {})
-          validate_operation!(operation)
-          
-          case operation.to_sym
-          when :attach
-            attach_file(params)
-          when :download
-            download_file(params)
-          when :analyze
-            analyze_file(params)
-          when :delete
-            delete_file(params)
-          when :url
-            get_url(params)
-          else
-            { error: "Unknown operation: #{operation}" }
+        def execute(operation:, params: {})
+          op = operation.to_sym
+          validate_operation!(op)
+          opts = (params || {}).transform_keys(&:to_sym)
+
+          case op
+          when :attach   then attach_file(opts)
+          when :download then download_file(opts)
+          when :analyze  then analyze_file(opts)
+          when :delete   then delete_file(opts)
+          when :url      then get_url(opts)
+          else { error: "Unknown operation: #{operation}" }
           end
         rescue => e
           { error: "Active Storage operation failed", message: e.message }
@@ -34,31 +36,31 @@ module RcrewAI
         private
 
         def validate_operation!(operation)
-          unless @allowed_operations.include?(operation.to_sym)
-            raise ArgumentError, "Operation '#{operation}' is not allowed"
-          end
+          return if @allowed_operations.include?(operation)
+
+          raise ArgumentError, "Operation '#{operation}' is not allowed"
         end
 
         def attach_file(params)
           record = find_record(params[:model], params[:id])
           attachment_name = params[:attachment_name] || :file
-          
+
           file = params[:file] || params[:io]
           filename = params[:filename] || "attachment"
           content_type = params[:content_type] || "application/octet-stream"
-          
+
           record.send(attachment_name).attach(
             io: file,
             filename: filename,
             content_type: content_type
           )
-          
+
           { attached: true, filename: filename, record_id: record.id }
         end
 
         def download_file(params)
           blob = find_blob(params)
-          
+
           {
             filename: blob.filename.to_s,
             content_type: blob.content_type,
@@ -70,7 +72,7 @@ module RcrewAI
         def analyze_file(params)
           blob = find_blob(params)
           blob.analyze unless blob.analyzed?
-          
+
           {
             filename: blob.filename.to_s,
             content_type: blob.content_type,
@@ -84,14 +86,14 @@ module RcrewAI
           blob = find_blob(params)
           filename = blob.filename.to_s
           blob.purge
-          
+
           { deleted: true, filename: filename }
         end
 
         def get_url(params)
           blob = find_blob(params)
           expires_in = params[:expires_in] || 5.minutes
-          
+
           {
             url: ::Rails.application.routes.url_helpers.rails_blob_url(blob, expires_in: expires_in),
             expires_at: expires_in.from_now
@@ -119,4 +121,4 @@ module RcrewAI
       end
     end
   end
-end
+end

data/lib/rcrewai/rails/tools/rails_cache_tool.rb

@@ -2,29 +2,31 @@ module RcrewAI
   module Rails
     module Tools
       class RailsCacheTool < RCrewAI::Tools::Base
-        def initialize
-          super(
-            name: "Rails Cache Tool",
-            description: "Read and write to Rails cache"
-          )
-        end
+        tool_name "rails_cache"
+        description "Read from and write to the Rails cache. Supports read, write, delete, exist?, fetch, and clear."
+
+        param :action, type: :enum, required: true,
+              values: %w[read write delete exist? fetch clear],
+              description: "Cache action to perform."
+        param :key, type: :string, required: false,
+              description: "Cache key. Required for every action except clear."
+        param :value, type: :string, required: false,
+              description: "Value to store (used by write and fetch fallback)."
+        param :options, type: :object, required: false,
+              description: "Cache options hash (e.g. expires_in)."
 
-        def execute(action, key, value = nil, options = {})
-          case action.to_sym
-          when :read
-            read_cache(key)
-          when :write
-            write_cache(key, value, options)
-          when :delete
-            delete_cache(key)
-          when :exist?
-            cache_exists?(key)
-          when :fetch
-            fetch_cache(key, options) { value }
-          when :clear
-            clear_cache
-          else
-            { error: "Unknown action: #{action}" }
+        def execute(action:, key: nil, value: nil, options: {})
+          act = action.to_sym
+          opts = (options || {}).transform_keys(&:to_sym)
+
+          case act
+          when :read    then read_cache(key)
+          when :write   then write_cache(key, value, opts)
+          when :delete  then delete_cache(key)
+          when :exist?  then cache_exists?(key)
+          when :fetch   then fetch_cache(key, value, opts)
+          when :clear   then clear_cache
+          else { error: "Unknown action: #{action}" }
           end
         rescue => e
           { error: "Cache operation failed", message: e.message }
@@ -37,7 +39,7 @@ module RcrewAI
           { key: key, value: value, exists: !value.nil? }
         end
 
-        def write_cache(key, value, options = {})
+        def write_cache(key, value, options)
           success = ::Rails.cache.write(key, value, options)
           { key: key, written: success }
         end
@@ -48,14 +50,11 @@ module RcrewAI
         end
 
         def cache_exists?(key)
-          exists = ::Rails.cache.exist?(key)
-          { key: key, exists: exists }
+          { key: key, exists: ::Rails.cache.exist?(key) }
         end
 
-        def fetch_cache(key, options = {})
-          value = ::Rails.cache.fetch(key, options) do
-            yield if block_given?
-          end
+        def fetch_cache(key, fallback, options)
+          value = ::Rails.cache.fetch(key, options) { fallback }
           { key: key, value: value }
         end
 
@@ -66,4 +65,4 @@ module RcrewAI
       end
     end
   end
-end
+end

data/lib/rcrewai/rails/tools/rails_logger_tool.rb

@@ -2,40 +2,41 @@ module RcrewAI
   module Rails
     module Tools
       class RailsLoggerTool < RCrewAI::Tools::Base
+        tool_name "rails_logger"
+        description "Log a message to the Rails logger at the given level and emit an ActiveSupport notification."
+
+        param :level, type: :enum, required: true,
+              values: %w[debug info warn error fatal],
+              description: "Log level."
+        param :message, type: :string, required: true,
+              description: "Message to log."
+        param :metadata, type: :object, required: false,
+              description: "Additional metadata appended as JSON to the log line."
+
         def initialize(tag: "RcrewAI")
+          super()
           @tag = tag
-          super(
-            name: "Rails Logger Tool",
-            description: "Log messages to Rails logger"
-          )
         end
 
-        def execute(level, message, metadata = {})
+        def execute(level:, message:, metadata: {})
           logger = ::Rails.logger
-          
-          # Format the message with metadata
-          formatted_message = format_message(message, metadata)
-          
+          meta = metadata || {}
+          formatted_message = format_message(message, meta)
+
           case level.to_sym
-          when :debug
-            logger.debug(formatted_message)
-          when :info
-            logger.info(formatted_message)
-          when :warn
-            logger.warn(formatted_message)
-          when :error
-            logger.error(formatted_message)
-          when :fatal
-            logger.fatal(formatted_message)
+          when :debug then logger.debug(formatted_message)
+          when :info  then logger.info(formatted_message)
+          when :warn  then logger.warn(formatted_message)
+          when :error then logger.error(formatted_message)
+          when :fatal then logger.fatal(formatted_message)
           else
             return { error: "Unknown log level: #{level}" }
           end
 
-          # Also instrument for monitoring
           ActiveSupport::Notifications.instrument("log.rcrewai", {
             level: level,
             message: message,
-            metadata: metadata,
+            metadata: meta,
             tag: @tag
           })
 
@@ -48,10 +49,10 @@ module RcrewAI
 
         def format_message(message, metadata)
           return "[#{@tag}] #{message}" if metadata.empty?
-          
+
           "[#{@tag}] #{message} | #{metadata.to_json}"
         end
       end
     end
   end
-end
+end

data/lib/rcrewai/rails/version.rb

@@ -1,8 +1,5 @@
 module RcrewAI
   module Rails
-    VERSION = "0.2.8"
-    
-    # Also define Version for Zeitwerk compatibility
-    Version = VERSION
+    VERSION = "0.3.0"
   end
 end

data/rcrewai-rails.gemspec

@@ -45,7 +45,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Core dependency
-  spec.add_dependency "rcrewai", "~> 0.2"
+  spec.add_dependency "rcrewai", "~> 0.3"
   
   # Rails dependencies
   spec.add_dependency "rails", ">= 7.0.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rcrewai-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - gkosmo
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.2'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -238,6 +238,12 @@ files:
 - app/views/rcrewai/rails/tools/show.html.erb
 - config/routes.rb
 - db/migrate/001_add_agent_to_tasks.rb
+- lib/generators/rcrew_a_i/rails/crew/crew_generator.rb
+- lib/generators/rcrew_a_i/rails/crew/templates/agent.rb.erb
+- lib/generators/rcrew_a_i/rails/crew/templates/crew.rb.erb
+- lib/generators/rcrew_a_i/rails/install/install_generator.rb
+- lib/generators/rcrew_a_i/rails/install/templates/create_rcrewai_tables.rb
+- lib/generators/rcrew_a_i/rails/install/templates/rcrewai.rb
 - lib/generators/rcrewai/rails/crew/crew_generator.rb
 - lib/generators/rcrewai/rails/crew/templates/agent.rb.erb
 - lib/generators/rcrewai/rails/crew/templates/crew.rb.erb