rcrewai-rails 0.2.7 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 353628caface76713be1e44bd2cf1d8e3bf665cb603f5ed19afb3bb48e460c99
-  data.tar.gz: 1d75db788deba2bec2462528107fd21c1b0fbad22c93d5d8b3c14e6d464059d0
+  metadata.gz: 2d2402d751d591a36e40134763d02f9c45d3b9fe3f3e38bfbcda988f08764269
+  data.tar.gz: d1e38e88b3effbba297ea931df56a7499912d8c2f7c7d4dd02b1b9c4e71fba1b
 SHA512:
-  metadata.gz: eef641fc2157fffe10bcfb634fa4235dfbfc1a0d4d9fba5ad7e7208554b6e16f71cc6cb19707b423ba05f398f18207bca58159af47e883c5ac23835260328efd
-  data.tar.gz: c0a0f57c8bf242f1d050f5422edf26f8044cb00b9738e936e7437a00c934f3e9f47fa786fc69474279113861d71588854123906ede51e34e1f8a6b1f15b38191
+  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/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

@@ -26,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.7"
-    
-    # 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.7
+  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