meta_workflows 0.7.0

data/app/jobs/meta_workflows/human_input_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class HumanInputJob < MetaJob
+    include MetaWorkflows::MetaWorkflowsHelper
+    queue_as :default
+
+    def perform(user_id:, record:, params:)
+      setup(user_id, record)
+      conversation = initialize_conversation(params)
+      process_and_broadcast(conversation)
+    end
+
+    private
+
+    def broadcast_response(response)
+      Turbo::StreamsChannel.broadcast_replace_to(turbo_stream_name(record),
+                                                 target: target_frame_id(record),
+                                                 locals: { record: record, response: response },
+                                                 partial: meta_response)
+    end
+
+    def broadcast_form(chat)
+      Turbo::StreamsChannel.broadcast_replace_to(
+        turbo_stream_name(record),
+        target: target_frame_id(record, form: true),
+        partial: meta_response_form,
+        locals: { record: record,
+                  workflow_execution_id: record.workflow_execution.id,
+                  response_enabled: true,
+                  chat_id: chat.id }
+      )
+    end
+  end
+end

data/app/jobs/meta_workflows/meta_job.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class MetaJob < MetaWorkflows::ApplicationJob
+    attr_accessor :chat, :inputs, :full_response, :user_id, :record
+
+    private
+
+    def setup(user_id, record)
+      @user_id = user_id
+      @record = record.class.find(record.id)
+    end
+
+    def initialize_conversation(params)
+      if params[:chat_id].blank?
+        initialize_new_conversation(params)
+      else
+        continue_existing_conversation(params)
+      end
+    end
+
+    def initialize_new_conversation(params)
+      inputs = params.symbolize_keys[:inputs]
+
+      workflow_execution = record.workflow_execution
+      current_step = workflow_execution.workflow_steps.find_by(step: workflow_execution.current_step)
+      @chat = current_step&.chat
+
+      @full_response = +''
+
+      conversation = RubyConversations::Conversation.new(chat:)
+      conversation.with_prompt(params[:prompt_id], inputs: inputs, description: "Running #{params[:prompt_id]} process")
+    end
+
+    def continue_existing_conversation(params)
+      @chat = MetaWorkflows::Chat.find(params[:chat_id])
+      conversation = RubyConversations::Conversation.new(chat:, id: chat.conversation_id)
+
+      new_message = params[:inputs]
+      conversation.with_user_message(new_message, description: "Following up on #{params[:prompt_id]} process")
+      @full_response = chat.messages[1..].map(&:content).join + format_user_message(new_message)
+
+      conversation
+    end
+
+    def process_and_broadcast(conversation)
+      workflow_step = current_workflow_step
+
+      begin
+        clear_previous_errors(workflow_step)
+        execute_llm_conversation(conversation)
+        finalize_conversation(conversation)
+      rescue StandardError => e
+        handle_llm_error(e, workflow_step, conversation)
+        raise
+      end
+    end
+
+    def clear_previous_errors(workflow_step)
+      workflow_step&.clear_error if workflow_step&.error?
+    end
+
+    def execute_llm_conversation(conversation)
+      conversation.call_llm do |chunk|
+        full_response << (chunk.content || '')
+        broadcast_response(full_response)
+      end
+    end
+
+    def finalize_conversation(conversation)
+      chat.update!(conversation_id: conversation.id) if chat.conversation_id.blank?
+      broadcast_response(full_response)
+      broadcast_form(chat)
+    end
+
+    def handle_llm_error(error, workflow_step, conversation)
+      log_error(error)
+      store_error_in_workflow_step(error, workflow_step, conversation)
+      broadcast_error_response(error)
+    end
+
+    def log_error(error)
+      Rails.logger.error("LLM Error in MetaJob: #{error.message}")
+      Rails.logger.error(error.backtrace.join("\n"))
+    end
+
+    def store_error_in_workflow_step(error, workflow_step, conversation)
+      workflow_step&.record_error(error, additional_details: {
+                                    job_class: self.class.name,
+                                    chat_id: chat&.id,
+                                    conversation_id: conversation&.id,
+                                    full_response_length: full_response&.length || 0
+                                  })
+    end
+
+    def current_workflow_step
+      return nil unless record&.workflow_execution
+
+      workflow_execution = record.workflow_execution
+      workflow_execution.workflow_steps.find_by(step: workflow_execution.current_step)
+    end
+
+    def broadcast_error_response(error)
+      error_message = "Error occurred during LLM processing: #{error.message}"
+      broadcast_response(error_message)
+    end
+
+    def broadcast_response(response)
+      raise NotImplementedError
+    end
+
+    def broadcast_form(chat)
+      raise NotImplementedError
+    end
+
+    def format_user_message(message)
+      '<div class="flex p-4 border border-slate-300 rounded-xl bg-white text-xl ' \
+        "font-semibold leading-snug\">#{message}</div>\n\n"
+    end
+  end
+end

data/app/jobs/meta_workflows/meta_workflow_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class MetaWorkflowJob < MetaWorkflows::ApplicationJob
+    queue_as :default
+
+    def perform(record_id:, record_type:, workflow_name:, user_id:, inputs: {}, workflow_params: nil)
+      record = record_type.constantize.find(record_id)
+      user = User.find(user_id)
+
+      Services::MetaWorkflows::MetaWorkflowService.new(
+        record: record,
+        workflow_name: workflow_name,
+        user: user,
+        inputs: inputs,
+        workflow_params: workflow_params
+      ).call
+    end
+  end
+end

data/app/jobs/meta_workflows/record_redirect_job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class RecordRedirectJob < MetaWorkflows::ApplicationJob
+    include MetaWorkflows::MetaWorkflowsHelper
+    queue_as :default
+
+    def perform(workflow_execution:)
+      @workflow_execution = workflow_execution
+      params = @workflow_execution.workflow_params || {}
+      broadcast_redirect(params)
+    end
+
+    private
+
+    def broadcast_redirect(params)
+      record_id = params['record_id']
+      record_class = params['record_class']
+      redirect_method = params['redirect_method']
+
+      record_class_constant = record_class.to_s.safe_constantize
+      record = record_class_constant&.find_by(id: record_id)
+
+      redirect_path = Rails.application.routes.url_helpers.send(redirect_method.to_s, record)
+
+      Turbo::StreamsChannel.broadcast_append_to(
+        turbo_stream_name(@workflow_execution.record),
+        target: target_frame_id(@workflow_execution.record, form: true),
+        partial: meta_redirect,
+        locals: {
+          redirect_path: redirect_path
+        }
+      )
+    end
+  end
+end

data/app/mailers/meta_workflows/application_mailer.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/meta_workflows/application_record.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/meta_workflows/chat.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class Chat < ApplicationRecord
+    acts_as_chat(message_class: 'MetaWorkflows::Message', tool_call_class: 'MetaWorkflows::ToolCall')
+
+    belongs_to :user, optional: true
+    has_many :workflow_steps, dependent: :nullify, class_name: 'MetaWorkflows::WorkflowStep'
+
+    validates :model_id, presence: true
+    validates :provider, presence: true
+
+    after_initialize :set_chat
+
+    def set_chat
+      RubyConversations::Conversation.configure_llm_credentials
+      @chat = RubyLLM::Chat.new(model: model_id, provider:)
+    end
+  end
+end

data/app/models/meta_workflows/message.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class Message < ApplicationRecord
+    acts_as_message(chat_class: 'MetaWorkflows::Chat', tool_call_class: 'MetaWorkflows::ToolCall')
+
+    def to_h
+      attributes
+    end
+  end
+end

data/app/models/meta_workflows/tool_call.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ToolCall < ApplicationRecord
+    acts_as_tool_call(message_class: 'MetaWorkflows::Message')
+  end
+end

data/app/models/meta_workflows/workflow.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class Workflow < ApplicationRecord
+    validates :name, presence: true, uniqueness: true
+    validates :recipe, presence: true
+
+    has_many :workflow_executions, dependent: :destroy, class_name: 'MetaWorkflows::WorkflowExecution'
+    has_many :courses, through: :workflow_executions
+    has_many :workflow_steps, through: :workflow_executions, class_name: 'MetaWorkflows::WorkflowStep'
+
+    def step_progress(step)
+      recipe.dig('steps', step, 'step_progress')
+    end
+
+    def prompt_id(step)
+      recipe.dig('steps', step, 'prompt_id')
+    end
+
+    def step_data(step)
+      recipe.dig('steps', step)
+    end
+
+    def step_output(step)
+      recipe.dig('steps', step, 'output')
+    end
+
+    def total_steps
+      recipe['steps'].size
+    end
+  end
+end

data/app/models/meta_workflows/workflow_execution.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class WorkflowExecution < ApplicationRecord
+    belongs_to :workflow, class_name: 'MetaWorkflows::Workflow'
+    belongs_to :record, polymorphic: true
+    has_many :workflow_steps, dependent: :destroy, class_name: 'MetaWorkflows::WorkflowStep'
+
+    # Default values for fields
+    attribute :current_step, :integer, default: 0
+    attribute :repetition, :integer, default: 0
+    attribute :completed, :boolean, default: false
+    attribute :workflow_params, :json, default: -> { {} }
+
+    validates :current_step, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :repetition, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :completed, inclusion: { in: [true, false] }
+
+    def increment_step
+      update(current_step: current_step + 1)
+    end
+  end
+end

data/app/models/meta_workflows/workflow_step.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class WorkflowStep < ApplicationRecord
+    belongs_to :workflow_execution, class_name: 'MetaWorkflows::WorkflowExecution'
+    belongs_to :chat, class_name: 'MetaWorkflows::Chat', optional: true
+
+    validates :step, presence: true, numericality: { only_integer: true, greater_than_or_equal_to: 0 }
+    validates :workflow_execution_id, uniqueness: { scope: :step }
+
+    has_one :workflow, through: :workflow_execution, class_name: 'MetaWorkflows::Workflow'
+
+    # Scopes for error handling
+    scope :with_errors, -> { where.not(error_message: nil) }
+    scope :without_errors, -> { where(error_message: nil) }
+
+    # Error handling methods
+    def error?
+      error_message.present?
+    end
+
+    def record_error(error, additional_details: {})
+      update!(
+        error_message: error.message,
+        error_type: error.class.name,
+        error_details: {
+          backtrace: error.backtrace&.first(10),
+          additional_details: additional_details
+        }.compact,
+        error_occurred_at: Time.current
+      )
+    end
+
+    def clear_error
+      update!(
+        error_message: nil,
+        error_type: nil,
+        error_details: nil,
+        error_occurred_at: nil
+      )
+    end
+
+    def error_summary
+      return nil unless error?
+
+      "#{error_type}: #{error_message}"
+    end
+  end
+end

data/app/models/meta_workflows.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  def self.table_name_prefix
+    'meta_workflows_'
+  end
+end

data/app/services/meta_workflows/execution_filter_service.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  class ExecutionFilterService
+    def initialize(executions, params)
+      @executions = executions
+      @params = params
+    end
+
+    def apply_filters
+      executions = @executions
+      executions = filter_by_workflow(executions)
+      executions = filter_by_status(executions)
+      executions = filter_by_date_range(executions)
+      search_executions(executions)
+    end
+
+    private
+
+    attr_reader :params
+
+    def filter_by_workflow(executions)
+      return executions if params[:workflow_id].blank?
+
+      executions.where(workflow_id: params[:workflow_id])
+    end
+
+    def filter_by_status(executions)
+      return executions if params[:status].blank?
+
+      case params[:status]
+      when 'completed'
+        executions.where(completed: true)
+      when 'running'
+        executions.where(completed: false).where(updated_at: 1.hour.ago..)
+      when 'failed'
+        executions.where(completed: false).where(updated_at: ...1.hour.ago)
+      else
+        executions
+      end
+    end
+
+    def filter_by_date_range(executions)
+      executions = filter_by_date_from(executions)
+      filter_by_date_to(executions)
+    end
+
+    def filter_by_date_from(executions)
+      return executions if params[:date_from].blank?
+
+      begin
+        date_from = Date.parse(params[:date_from])
+        executions.where(created_at: date_from.beginning_of_day..)
+      rescue ArgumentError
+        executions
+      end
+    end
+
+    def filter_by_date_to(executions)
+      return executions if params[:date_to].blank?
+
+      begin
+        date_to = Date.parse(params[:date_to])
+        executions.where(created_at: ..date_to.end_of_day)
+      rescue ArgumentError
+        executions
+      end
+    end
+
+    def search_executions(executions)
+      return executions if params[:search].blank?
+
+      executions.joins(:workflow)
+                .where(
+                  'meta_workflows_workflows.name ILIKE ? OR meta_workflows_workflow_executions.id::text ILIKE ?',
+                  "%#{params[:search]}%", "%#{params[:search]}%"
+                )
+    end
+  end
+end

data/app/sidekiq/meta_workflows/tools/meta_workflow_tool.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module MetaWorkflows
+  module Tools
+    class MetaWorkflowTool < RubyLLM::Tool
+      ALLOWED_PARAM_TYPES = %w[array string integer number boolean object].freeze
+
+      attr_reader :workflow_execution, :step_output
+
+      def initialize(workflow_execution:, step_output:)
+        super()
+        @workflow_execution = workflow_execution
+        @step_output = step_output
+
+        self.class.description("Workflow step output for #{workflow_execution.workflow.name}")
+        self.class.setup_params(step_output) if step_output.present?
+      end
+
+      def self.setup_params(step_output)
+        step_output.each do |output_param|
+          process_param(output_param)
+        end
+      end
+
+      def self.process_param(param_def)
+        common_args = process_param_definition(param_def)
+        param param_def['name'].to_sym, **common_args
+      end
+
+      def self.process_array_items(items_array)
+        items_hash = {}
+
+        items_array.each do |param_def|
+          common_args = process_param_definition(param_def)
+          items_hash[param_def['name'].to_sym] = common_args
+        end
+
+        items_hash
+      end
+
+      def self.process_object_properties(properties_hash)
+        properties = {}
+
+        properties_hash.each do |key, property_def|
+          common_args = process_param_definition(property_def)
+          properties[key.to_sym] = common_args
+        end
+
+        properties
+      end
+
+      def self.process_param_definition(param_def)
+        type = param_def['type']
+
+        validate_type!(type)
+
+        common_args = {
+          type: type,
+          desc: param_def['description']
+        }
+
+        if type == 'array'
+          common_args[:items] = process_array_items(param_def['items'])
+        elsif type == 'object' && param_def['properties'].present?
+          common_args[:properties] = process_object_properties(param_def['properties'])
+        end
+
+        common_args
+      end
+
+      def self.validate_type!(type)
+        return if ALLOWED_PARAM_TYPES.include?(type)
+
+        raise ArgumentError, "Invalid type: #{type}. Allowed types are: #{ALLOWED_PARAM_TYPES.join(', ')}"
+      end
+
+      def self.build(workflow_execution, step_output)
+        new(workflow_execution: workflow_execution, step_output: step_output)
+      end
+
+      def execute(**_params)
+        { success: true, message: 'Output parameters saved successfully' }.to_json
+      end
+    end
+  end
+end

data/app/views/layouts/meta_workflows/application.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Meta workflows</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag    "meta_workflows/application", media: "all" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/layouts/meta_workflows/debug.html.erb

@@ -0,0 +1,47 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>MetaWorkflows Debug Tool</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= yield :head %>
+
+  <%= stylesheet_link_tag "meta_workflows/application", media: "all" %>
+  
+  <!-- Tailwind CSS -->
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="bg-gray-50 min-h-screen">
+  <!-- Header Navigation -->
+  <nav class="bg-white shadow-sm border-b border-gray-200">
+    <div class="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8">
+      <div class="flex justify-between items-center h-16">
+        <!-- Logo/Title -->
+        <div class="flex items-center">
+          <h1 class="text-xl font-semibold text-gray-900">
+            MetaWorkflows Debug Tool
+          </h1>
+        </div>
+
+        <!-- Navigation Links -->
+        <div class="flex space-x-8">
+          <%= link_to "Workflows", workflows_path, 
+              class: "#{current_page?(workflows_path) || params[:controller].include?('workflow') ? 'text-blue-600 border-b-2 border-blue-600' : 'text-gray-500 hover:text-gray-700'} px-3 py-2 text-sm font-medium" %>
+          <%= link_to "Executions", executions_path, 
+              class: "#{current_page?(executions_path) || params[:controller].include?('execution') ? 'text-blue-600 border-b-2 border-blue-600' : 'text-gray-500 hover:text-gray-700'} px-3 py-2 text-sm font-medium" %>
+        </div>
+      </div>
+    </div>
+  </nav>
+
+  <!-- Main Content -->
+  <main class="max-w-7xl mx-auto py-6 px-4 sm:px-6 lg:px-8">
+    <%= yield %>
+  </main>
+
+  <!-- Optional JavaScript -->
+  <%= yield :javascripts %>
+</body>
+</html> 

data/app/views/meta_workflows/_loader.html.erb

@@ -0,0 +1,22 @@
+<%= turbo_frame_tag target_frame_id(record) do %>
+  <div class="flex flex-col items-center justify-center gap-2"
+       data-controller="loading-phrases"
+       data-loading-phrases-phrases-value="<%= (local_assigns[:step_progress] || ["Processing your request...", "Talking to the LLM..."]).to_json %>">
+    <h2
+      class="text-center font-semibold
+             bg-gradient-to-r
+             bg-[length:300%_100%] bg-right-bottom
+             bg-clip-text [-webkit-text-fill-color:transparent]
+             animate-gradient-shift"
+      style="--tw-gradient-stops: #3182ce, #805ad5, #d53f8c, #3182ce;"
+      data-loading-phrases-target="message"
+    >
+      Processing your request...
+    </h2>
+    <div class="sm-sprite loader">
+      <span class="image-container">
+        <img class="" src="https://cdn.strongmind.com/backpack-ui/latest/assets/images/png/loaders/CB_loader.png" alt="loaders/CB_loader.png">
+      </span>
+    </div>
+  </div>
+<% end %> 

data/app/views/meta_workflows/_redirect.html.erb

@@ -0,0 +1 @@
+<div data-controller="redirect" data-redirect-url-value="<%= redirect_path %>" data-redirect-delay-value="0"></div> 

data/app/views/meta_workflows/_response.html.erb

@@ -0,0 +1,5 @@
+<%= turbo_frame_tag target_frame_id(record) do %>
+<div id="response-content-container" class="meta-workflows chat" data-controller="response-scroll">
+    <%= markdown(response) %>
+</div>
+<% end %>