meta_workflows 0.7.0

data/lib/services/meta_workflows/meta_workflow_service.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+module Services
+  module MetaWorkflows
+    class MetaWorkflowService
+      ACTIONS_WITHOUT_CONVERSATION = %w[record_redirect collection_create record_update].freeze
+
+      attr_reader :record, :workflow_name, :user, :inputs, :workflow_params
+
+      # TODO: inputs should be a an empty hash by default
+      # Once everything is working we can change the default value from nil to {}
+      def initialize(record:, workflow_name: nil, user: nil, inputs: nil, workflow_params: nil)
+        @record = record
+        @workflow_name = workflow_name
+        @user = user
+        @inputs = inputs
+        @workflow_params = workflow_params
+      end
+
+      def call
+        validate_workflow_presence
+
+        workflow, workflow_execution = find_or_create_workflow_execution
+        execution_step, execution_output, workflow_step = prepare_workflow_execution(workflow, workflow_execution)
+
+        if ACTIONS_WITHOUT_CONVERSATION.include?(execution_step['action'])
+          process_action(execution_step, nil, workflow_execution, workflow)
+        else
+          chat = create_and_configure_chat(workflow_step)
+          conversation = create_and_configure_conversation(chat, workflow_execution, execution_output, execution_step)
+          process_action(execution_step, conversation, workflow_execution, workflow)
+        end
+      end
+
+      private
+
+      def process_action(execution_step, conversation, workflow_execution, workflow)
+        case execution_step['action']
+        when 'agent'
+          process_agent_action(conversation, workflow_execution, workflow)
+        when 'human'
+          process_human_action(execution_step, workflow_execution)
+        when 'record_redirect'
+          process_record_redirect_action(workflow_execution, workflow)
+        when 'collection_create'
+          process_collection_create_action(execution_step, workflow_execution, workflow)
+        when 'record_update'
+          process_record_update_action(execution_step, workflow_execution, workflow)
+        else
+          raise ArgumentError, "The action #{execution_step['action']} does not exist"
+        end
+      end
+
+      def process_agent_action(conversation, workflow_execution, workflow)
+        workflow_step = find_workflow_step(workflow_execution)
+
+        begin
+          clear_previous_errors(workflow_step)
+          execute_llm_call(conversation, workflow_execution)
+          handle_workflow_continuation(workflow_execution, workflow, conversation)
+        rescue StandardError => e
+          handle_agent_error(e, workflow_step, workflow, workflow_execution)
+          raise
+        end
+      end
+
+      def find_workflow_step(workflow_execution)
+        workflow_execution.workflow_steps.find_by(step: workflow_execution.current_step)
+      end
+
+      def clear_previous_errors(workflow_step)
+        workflow_step&.clear_error if workflow_step&.error?
+      end
+
+      def execute_llm_call(conversation, workflow_execution)
+        conversation.call_llm
+        workflow_execution.increment_step
+      end
+
+      def handle_workflow_continuation(workflow_execution, workflow, conversation)
+        new_inputs = extract_tool_call_inputs(conversation)
+
+        if workflow_execution.current_step < workflow.total_steps
+          schedule_next_workflow_step_with_inputs(new_inputs)
+        else
+          workflow_execution.update(completed: true)
+        end
+      end
+
+      def schedule_next_workflow_step_with_inputs(new_inputs)
+        ::MetaWorkflows::MetaWorkflowJob.perform_later(
+          record_id: record.id,
+          record_type: record.class.name,
+          workflow_name: nil,
+          user_id: user&.id,
+          inputs: new_inputs
+        )
+      end
+
+      def handle_agent_error(error, workflow_step, workflow, workflow_execution)
+        Rails.logger.error("LLM Error in MetaWorkflowService: #{error.message}")
+        Rails.logger.error(error.backtrace.join("\n"))
+
+        record_error_details(error, workflow_step, workflow, workflow_execution) if workflow_step
+      end
+
+      def record_error_details(error, workflow_step, workflow, workflow_execution)
+        workflow_step.record_error(error, additional_details: {
+                                     service_class: self.class.name,
+                                     workflow_id: workflow.id,
+                                     workflow_name: workflow.name,
+                                     current_step: workflow_execution.current_step,
+                                     record_type: record.class.name,
+                                     record_id: record.id
+                                   })
+      end
+
+      def process_human_action(execution_step, workflow_execution)
+        ::MetaWorkflows::HumanInputJob.perform_later(
+          user_id: user&.id,
+          record: workflow_execution.record,
+          params: {
+            inputs: inputs,
+            prompt_id: execution_step['prompt_id']
+          }
+        )
+        # the step advancement is handled in the human input job
+      end
+
+      def process_record_redirect_action(workflow_execution, workflow)
+        ::MetaWorkflows::RecordRedirectJob.perform_later(workflow_execution: workflow_execution)
+        workflow_execution.increment_step
+
+        return unless workflow_execution.current_step >= workflow.total_steps
+
+        workflow_execution.update(completed: true)
+      end
+
+      def process_collection_create_action(execution_step, workflow_execution, workflow)
+        service = build_collection_service(execution_step, workflow_execution)
+
+        begin
+          service.call
+          workflow_execution.increment_step
+          continue_workflow(workflow_execution, workflow)
+        rescue StandardError => e
+          Rails.logger.error("Error creating collection: #{e.message}")
+          # The workflow should halt on error per requirements - do not increment step
+        end
+      end
+
+      def process_record_update_action(execution_step, workflow_execution, workflow)
+        service = build_record_update_service(execution_step, workflow_execution)
+
+        begin
+          service.call
+          workflow_execution.increment_step
+          continue_workflow(workflow_execution, workflow)
+        rescue StandardError => e
+          Rails.logger.error("Error updating record: #{e.message}")
+          # Let Sidekiq handle retry - reraise the error
+          raise
+        end
+      end
+
+      def build_collection_service(execution_step, workflow_execution)
+        service_class_name = execution_step['collection_creator']
+        service_class = service_class_name.safe_constantize
+
+        raise ArgumentError, "Invalid collection creator class: #{service_class_name}" unless service_class
+
+        parent_record = find_parent_record(workflow_execution)
+
+        service_class.new(
+          parent_record: parent_record,
+          collection: inputs[:collection]
+        )
+      end
+
+      def build_record_update_service(execution_step, workflow_execution)
+        service_class_name = execution_step['record_updater']
+        service_class = service_class_name.safe_constantize
+
+        raise ArgumentError, "Invalid record updater class: #{service_class_name}" unless service_class
+
+        target_record = find_parent_record(workflow_execution)
+        attributes_to_update = execution_step['attributes_to_update']
+
+        service_class.new(target_record, attributes_to_update, workflow_execution.workflow_params)
+      end
+
+      def find_parent_record(workflow_execution)
+        record_class = workflow_execution.record.class.name.constantize
+        record_class.find(workflow_execution.workflow_params['record_id'])
+      end
+
+      def continue_workflow(workflow_execution, workflow)
+        if workflow_execution.current_step < workflow.total_steps
+          schedule_next_workflow_step
+        else
+          workflow_execution.update(completed: true)
+        end
+      end
+
+      def schedule_next_workflow_step
+        ::MetaWorkflows::MetaWorkflowJob.perform_later(
+          record_id: record.id,
+          record_type: record.class.name,
+          workflow_name: nil,
+          user_id: user&.id,
+          inputs: {}
+        )
+      end
+
+      def create_and_configure_conversation(chat, workflow_execution, execution_output, execution_step)
+        conversation = RubyConversations::Conversation.new(chat: chat)
+        conversation.tool = ::MetaWorkflows::Tools::MetaWorkflowTool.build(workflow_execution, execution_output)
+        conversation.with_prompt(
+          execution_step['prompt_id'],
+          inputs: inputs,
+          description: "Executing step #{workflow_execution.current_step} of " \
+                       "workflow #{workflow_execution.workflow.name}"
+        )
+        conversation
+      end
+
+      def create_and_configure_chat(workflow_step)
+        workflow_step.chat = ::MetaWorkflows::Chat.new(model_id: RubyConversations.configuration.default_llm_model,
+                                                       provider: RubyConversations.configuration.default_llm_provider)
+        chat = workflow_step.chat
+        chat.user = @user
+        chat.save!
+        workflow_step.save!
+        chat
+      end
+
+      def validate_workflow_presence
+        return unless workflow_name.nil? && record.workflow_execution.blank?
+
+        raise ArgumentError, 'No workflow specified and record has no workflow attached'
+      end
+
+      def find_or_create_workflow_execution
+        if workflow_name.present?
+          workflow = ::MetaWorkflows::Workflow.find_by(name: workflow_name)
+          workflow_execution = ::MetaWorkflows::WorkflowExecution.create(
+            record: record,
+            workflow: workflow,
+            current_step: 0,
+            completed: false,
+            workflow_params: workflow_params
+          )
+        else
+          workflow_execution = record.workflow_execution
+          workflow = workflow_execution.workflow
+        end
+
+        [workflow, workflow_execution]
+      end
+
+      def prepare_workflow_execution(workflow, workflow_execution)
+        execution_step = workflow.step_data(workflow_execution.current_step)
+        execution_output = workflow.step_output(workflow_execution.current_step)
+        workflow_step = workflow_execution.workflow_steps.find_or_create_by(step: workflow_execution.current_step)
+
+        [execution_step, execution_output, workflow_step]
+      end
+
+      def extract_tool_call_inputs(conversation)
+        # the tool call is always the next to last message in the conversation
+        tool_call_id = JSON.parse(conversation.messages.first.response)[-2]['tool_call_id']
+        tool_call = ::MetaWorkflows::ToolCall.find(tool_call_id)
+        tool_call.arguments.deep_symbolize_keys
+      end
+    end
+  end
+end

data/lib/services/meta_workflows/updaters/meta_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Services
+  module MetaWorkflows
+    module Updaters
+      class MetaService < Services::MetaWorkflows::ApplicationService
+        attr_reader :record, :attributes_to_update, :workflow_params
+
+        def initialize(record, attributes_to_update, workflow_params)
+          super()
+          @record = record
+          @attributes_to_update = attributes_to_update
+          @workflow_params = workflow_params
+        end
+
+        def call
+          update_attributes = build_update_attributes
+          record.update!(update_attributes)
+          record
+        end
+
+        private
+
+        def build_update_attributes
+          attributes_hash = {}
+
+          attributes_to_update.each do |attribute_name|
+            param_value = workflow_params[attribute_name] || workflow_params[attribute_name.to_sym]
+            next if param_value.blank?
+
+            attributes_hash[attribute_name.to_sym] = param_value
+          end
+
+          attributes_hash
+        end
+      end
+    end
+  end
+end

data/lib/tasks/meta_workflows_tasks.rake

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+require_relative '../meta_workflows/asset_installer'
+
+namespace :meta_workflows do
+  desc 'Import workflows from YAML files in the workflows directory'
+  task import: :environment do
+    MetaWorkflows::WorkflowImporter.new.import_workflows
+  end
+
+  namespace :install do
+    desc 'Install meta_workflows assets (JavaScript controllers and stylesheets) into host application'
+    task assets: :environment do
+      MetaWorkflows::AssetInstallerService.new.install
+    end
+  end
+end
+
+# Service class to handle workflow import logic
+module MetaWorkflows
+  class WorkflowImporter
+    def initialize
+      @workflows_path = Rails.root.join('workflows')
+    end
+
+    def import_workflows
+      puts "Importing workflows from #{@workflows_path}..."
+
+      Dir.glob(File.join(@workflows_path, '*.yml')).each do |file_path|
+        import_single_workflow(file_path)
+      end
+
+      puts 'Workflow import completed!'
+    end
+
+    private
+
+    def import_single_workflow(file_path)
+      file_name = File.basename(file_path, '.yml')
+      workflow_name = file_name.underscore
+
+      begin
+        yaml_content = YAML.load_file(file_path)
+        save_workflow(workflow_name, yaml_content)
+      rescue StandardError => e
+        puts "Error processing #{file_path}: #{e.message}"
+      end
+    end
+
+    def save_workflow(workflow_name, yaml_content)
+      workflow = MetaWorkflows::Workflow.find_or_initialize_by(name: workflow_name)
+      workflow.recipe = yaml_content
+
+      if workflow.save
+        puts "Successfully imported workflow: #{workflow.name}"
+      else
+        puts "Failed to import workflow #{workflow_name}: #{workflow.errors.full_messages.join(', ')}"
+      end
+    end
+  end
+
+  # Service class to handle asset installation
+  class AssetInstallerService
+    def install
+      puts 'Installing meta_workflows assets...'
+
+      installer = MetaWorkflows::AssetInstaller.new
+
+      # Pre-installation validation
+      unless installer.valid_environment?
+        puts 'Installation aborted due to validation errors.'
+        return
+      end
+
+      begin
+        process_asset_installation(installer)
+      rescue MetaWorkflows::AssetInstaller::InstallationError => e
+        handle_installation_error(e)
+      rescue StandardError => e
+        handle_unexpected_error(e)
+      end
+    end
+
+    private
+
+    def process_asset_installation(installer)
+      assets = discover_and_validate_assets(installer)
+      return if assets.empty?
+
+      result = installer.install_assets(assets)
+      display_installation_results(installer, assets, result)
+    end
+
+    def discover_and_validate_assets(installer)
+      assets = installer.discover_assets
+
+      if assets.empty?
+        puts 'No assets found to install.'
+        return []
+      end
+
+      puts "Found #{assets.count} asset(s) to install:"
+      assets.each { |asset| puts "  - #{asset[:relative_path]}" }
+      puts
+
+      assets
+    end
+
+    def display_installation_results(installer, assets, result)
+      puts
+      if result[:success]
+        display_successful_installation(installer, assets, result)
+      else
+        display_partial_installation(installer, assets, result)
+      end
+    end
+
+    def display_successful_installation(installer, assets, result)
+      puts 'Installation completed successfully!'
+      puts "#{result[:copied]} file(s) copied, #{result[:skipped]} file(s) skipped."
+
+      return unless result[:copied].positive?
+
+      puts
+      installer.display_integration_instructions(assets, result)
+    end
+
+    def display_partial_installation(installer, assets, result)
+      puts 'Installation completed with errors.'
+      puts "#{result[:copied]} file(s) copied, #{result[:skipped]} file(s) skipped, " \
+           "#{result[:failed]} file(s) failed."
+      puts 'Some files may have been partially installed. Please review the output above.'
+
+      return unless result[:copied].positive?
+
+      puts
+      puts 'For successfully copied files, see integration instructions below:'
+      installer.display_integration_instructions(assets, result)
+    end
+
+    def handle_installation_error(error)
+      puts "Installation failed: #{error.message}"
+      puts 'Installation aborted.'
+    end
+
+    def handle_unexpected_error(error)
+      puts "Unexpected error during asset installation: #{error.message}"
+      puts 'Installation aborted.'
+    end
+  end
+end

metadata

@@ -0,0 +1,219 @@
+--- !ruby/object:Gem::Specification
+name: meta_workflows
+version: !ruby/object:Gem::Version
+  version: 0.7.0
+platform: ruby
+authors:
+- Leonid Medovyy
+- Sami Tanquary
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.2.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_conversations
+  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: ruby_llm
+  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: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: stimulus-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: MetaWorkflows provides a flexible framework for creating and executing
+  AI-powered workflows with human interaction points, built as a Rails engine for
+  easy integration into existing applications.
+email:
+- leonid.medovyy@strongmind.com
+- samantha.tanquary@strongmind.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- app/assets/javascripts/meta_workflows/controllers/loading_phrases_controller.js
+- app/assets/javascripts/meta_workflows/controllers/redirect_controller.js
+- app/assets/javascripts/meta_workflows/controllers/response_scroll_controller.js
+- app/assets/javascripts/meta_workflows_manifest.js
+- app/assets/stylesheets/meta_workflows/application.css
+- app/controllers/meta_workflows/application_controller.rb
+- app/controllers/meta_workflows/debug_controller.rb
+- app/controllers/meta_workflows/humans_controller.rb
+- app/controllers/meta_workflows/meta_controller.rb
+- app/helpers/meta_workflows/application_helper.rb
+- app/helpers/meta_workflows/debug_helper.rb
+- app/helpers/meta_workflows/execution_helper.rb
+- app/helpers/meta_workflows/formatting_helper.rb
+- app/helpers/meta_workflows/meta_workflows_helper.rb
+- app/helpers/meta_workflows/status_badge_helper.rb
+- app/jobs/meta_workflows/application_job.rb
+- app/jobs/meta_workflows/human_input_job.rb
+- app/jobs/meta_workflows/meta_job.rb
+- app/jobs/meta_workflows/meta_workflow_job.rb
+- app/jobs/meta_workflows/record_redirect_job.rb
+- app/mailers/meta_workflows/application_mailer.rb
+- app/models/meta_workflows.rb
+- app/models/meta_workflows/application_record.rb
+- app/models/meta_workflows/chat.rb
+- app/models/meta_workflows/message.rb
+- app/models/meta_workflows/tool_call.rb
+- app/models/meta_workflows/workflow.rb
+- app/models/meta_workflows/workflow_execution.rb
+- app/models/meta_workflows/workflow_step.rb
+- app/services/meta_workflows/execution_filter_service.rb
+- app/sidekiq/meta_workflows/tools/meta_workflow_tool.rb
+- app/views/layouts/meta_workflows/application.html.erb
+- app/views/layouts/meta_workflows/debug.html.erb
+- app/views/meta_workflows/_loader.html.erb
+- app/views/meta_workflows/_redirect.html.erb
+- app/views/meta_workflows/_response.html.erb
+- app/views/meta_workflows/_response_form.html.erb
+- app/views/meta_workflows/debug/executions.html.erb
+- app/views/meta_workflows/debug/show_execution.html.erb
+- app/views/meta_workflows/debug/show_workflow.html.erb
+- app/views/meta_workflows/debug/workflows.html.erb
+- config/routes.rb
+- db/migrate/20250530220618_create_meta_workflows_workflows.rb
+- db/migrate/20250530220634_create_meta_workflows_workflow_executions.rb
+- db/migrate/20250530220704_create_meta_workflows_chats.rb
+- db/migrate/20250530220722_create_meta_workflows_messages.rb
+- db/migrate/20250530220737_create_meta_workflows_tool_calls.rb
+- db/migrate/20250530220750_create_meta_workflows_workflow_steps.rb
+- db/migrate/20250613213159_add_error_fields_to_workflow_steps.rb
+- lib/meta_workflows.rb
+- lib/meta_workflows/asset_installer.rb
+- lib/meta_workflows/configuration.rb
+- lib/meta_workflows/engine.rb
+- lib/meta_workflows/export_execution_service.rb
+- lib/meta_workflows/version.rb
+- lib/services/meta_workflows/application_service.rb
+- lib/services/meta_workflows/meta_workflow_service.rb
+- lib/services/meta_workflows/updaters/meta_service.rb
+- lib/tasks/meta_workflows_tasks.rake
+homepage: https://github.com/strongmind/meta_workflows
+licenses:
+- None
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/strongmind/meta_workflows
+  source_code_uri: https://github.com/strongmind/meta_workflows
+  changelog_uri: https://github.com/strongmind/meta_workflows/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/strongmind/meta_workflows/blob/main/README.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: A Rails engine for managing AI-powered meta workflows
+test_files: []