circuit_breaker-wf 0.1.0

data/lib/circuit_breaker/executors/agent_executor.rb

@@ -0,0 +1,187 @@
+require_relative 'base_executor'
+require_relative 'llm/memory'
+require_relative 'llm/tools'
+
+module CircuitBreaker
+  module Executors
+    class AgentExecutor < BaseExecutor
+      MAX_ITERATIONS = 10
+
+      executor_config do
+        parameter :agent_type, type: :string, description: 'Type of agent'
+        parameter :task, type: :string, description: 'Task for the agent to perform'
+        parameter :model, type: :string, default: 'gpt-4', description: 'LLM model to use'
+        parameter :model_provider, type: :string, description: 'Model provider (ollama/openai)'
+        parameter :ollama_base_url, type: :string, default: 'http://localhost:11434', description: 'Ollama server URL'
+        parameter :system_prompt, type: :string, description: 'System prompt for the agent'
+        parameter :tools, type: :array, default: [], description: 'List of tools available to the agent'
+        parameter :parameters, type: :hash, default: {}, description: 'Additional parameters'
+      end
+
+      def initialize(context = {})
+        super
+        @agent_type = context[:agent_type]
+        @task = context[:task]
+        @model = context[:model] || 'gpt-4'
+        @model_provider = context[:model_provider] || detect_model_provider(@model)
+        @ollama_base_url = context[:ollama_base_url] || 'http://localhost:11434'
+        @system_prompt = context[:system_prompt]
+        @memory = LLM::ChainMemory.new
+        @toolkit = setup_toolkit(context[:tools] || [])
+        @parameters = context[:parameters] || {}
+      end
+
+      def execute
+        return unless @task
+
+        iteration = 0
+        final_output = nil
+
+        while iteration < MAX_ITERATIONS
+          # Get current state and plan next action
+          current_state = prepare_state(iteration)
+          action_plan = plan_next_action(current_state)
+
+          break if action_plan[:status] == 'complete'
+
+          # Execute planned action
+          action_result = execute_action(action_plan)
+          
+          # Store intermediate results
+          @memory.add_step_result(
+            step_name: action_plan[:action],
+            input: action_plan[:input],
+            output: action_result,
+            metadata: { iteration: iteration }
+          )
+
+          final_output = action_result
+          iteration += 1
+        end
+
+        @result = {
+          task: @task,
+          iterations: iteration,
+          final_output: final_output,
+          memory: @memory.to_h,
+          status: iteration < MAX_ITERATIONS ? 'completed' : 'max_iterations_reached'
+        }
+      end
+
+      private
+
+      def detect_model_provider(model)
+        return 'ollama' if model.start_with?('llama', 'codellama', 'mistral', 'dolphin')
+        'openai'
+      end
+
+      def setup_toolkit(tools)
+        toolkit = LLM::ToolKit.new
+        tools.each do |tool|
+          toolkit.add_tool(tool)
+        end
+        toolkit
+      end
+
+      def prepare_state(iteration)
+        {
+          task: @task,
+          iteration: iteration,
+          tools: @toolkit.tool_descriptions,
+          memory: @memory.get_step_history,
+          parameters: @parameters
+        }
+      end
+
+      def plan_next_action(state)
+        prompt = generate_planning_prompt(state)
+        
+        case @model_provider
+        when 'ollama'
+          response = make_ollama_request(prompt)
+          parse_llm_response(response)
+        when 'openai'
+          # Existing OpenAI logic here
+          if state[:iteration] == 0
+            {
+              status: 'in_progress',
+              action: 'search',
+              input: { query: state[:task] }
+            }
+          else
+            { status: 'complete' }
+          end
+        end
+      end
+
+      def generate_planning_prompt(state)
+        # Generate a structured prompt for the LLM
+        system_context = @system_prompt || "You are an AI agent tasked with solving problems step by step."
+        available_tools = state[:tools].map { |t| "- #{t[:name]}: #{t[:description]}" }.join("\n")
+        memory_context = state[:memory].map { |m| "Step #{m[:step]}: #{m[:result]}" }.join("\n")
+
+        <<~PROMPT
+          #{system_context}
+
+          TASK: #{state[:task]}
+          ITERATION: #{state[:iteration]}
+          
+          AVAILABLE TOOLS:
+          #{available_tools}
+
+          PREVIOUS STEPS:
+          #{memory_context}
+
+          Based on the above context, determine the next action:
+          1. If the task is complete, respond with: {"status": "complete"}
+          2. If more work is needed, respond with: {"status": "in_progress", "action": "[tool_name]", "input": {[tool parameters]}}
+        PROMPT
+      end
+
+      def make_ollama_request(prompt)
+        require 'net/http'
+        require 'json'
+
+        uri = URI("#{@ollama_base_url}/api/generate")
+        http = Net::HTTP.new(uri.host, uri.port)
+        
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request.body = {
+          model: @model,
+          prompt: prompt,
+          stream: false
+        }.to_json
+
+        response = http.request(request)
+        JSON.parse(response.body)
+      rescue => e
+        { error: "Ollama request failed: #{e.message}" }
+      end
+
+      def parse_llm_response(response)
+        return { status: 'error', message: response[:error] } if response[:error]
+
+        begin
+          # Extract the JSON response from the LLM output
+          json_str = response['response'].match(/\{.*\}/m)&.[](0)
+          return { status: 'error', message: 'No valid JSON found in response' } unless json_str
+
+          JSON.parse(json_str, symbolize_names: true)
+        rescue JSON::ParserError => e
+          { status: 'error', message: "Failed to parse LLM response: #{e.message}" }
+        end
+      end
+
+      def execute_action(action_plan)
+        return unless action_plan[:action]
+
+        begin
+          @toolkit.execute_tool(action_plan[:action], **action_plan[:input])
+        rescue => e
+          { error: e.message }
+        end
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/assistant_executor.rb

@@ -0,0 +1,245 @@
+require_relative 'base_executor'
+require_relative 'llm/memory'
+require_relative 'llm/tools'
+require_relative 'dsl'
+
+module CircuitBreaker
+  module Executors
+    class AssistantExecutor < BaseExecutor
+      include DSL
+
+      def initialize(context = {})
+        super
+        @memory = LLM::ConversationMemory.new(system_prompt: @context[:system_prompt])
+        @toolkit = LLM::ToolKit.new
+      end
+
+      executor_config do
+        parameter :model, type: :string, default: 'gpt-4', description: 'LLM model to use'
+        parameter :model_provider, type: :string, description: 'Model provider (ollama/openai)'
+        parameter :ollama_base_url, type: :string, default: 'http://localhost:11434', description: 'Ollama server URL'
+        parameter :system_prompt, type: :string, description: 'System prompt for the assistant'
+        parameter :tools, type: :array, default: [], description: 'List of tools available to the assistant'
+        parameter :parameters, type: :hash, default: {}, description: 'Additional parameters'
+        parameter :input, type: :string, description: 'Input message for the assistant'
+
+        validate do |context|
+          if context[:model_provider].nil?
+            context[:model_provider] = if context[:model].to_s.start_with?('llama', 'codellama', 'mistral', 'dolphin', 'qwen')
+              'ollama'
+            else
+              'openai'
+            end
+          end
+        end
+
+        before_execute do |context|
+          @memory.system_prompt = context[:system_prompt] if context[:system_prompt]
+          add_tools(context[:tools]) if context[:tools]
+        end
+      end
+
+      class << self
+        def define(&block)
+          new.tap do |executor| 
+            executor.instance_eval(&block) if block_given?
+            executor.validate_parameters
+          end
+        end
+      end
+
+      def use_model(model_name)
+        @context[:model] = model_name
+        @context[:model_provider] = if model_name.to_s.start_with?('llama', 'codellama', 'mistral', 'dolphin', 'qwen')
+          'ollama'
+        else
+          'openai'
+        end
+        self
+      end
+
+      def with_system_prompt(prompt)
+        @context[:system_prompt] = prompt
+        @memory = LLM::ConversationMemory.new(system_prompt: prompt)
+        self
+      end
+
+      def with_parameters(params)
+        @context[:parameters] = (@context[:parameters] || {}).merge(params)
+        self
+      end
+
+      def add_tool(tool)
+        @toolkit.add_tool(tool)
+        self
+      end
+
+      def add_tools(tools)
+        tools.each { |tool| add_tool(tool) }
+        self
+      end
+
+      def update_context(new_context)
+        @context.merge!(new_context)
+        validate_parameters
+        self
+      end
+
+      def execute
+        input = @context[:input]
+        return unless input
+
+        @memory.add_user_message(input)
+        conversation_context = prepare_context
+        response = make_llm_call(conversation_context)
+        processed_response = process_response(response)
+        @memory.add_assistant_message(processed_response[:content])
+
+        @result = {
+          input: input,
+          output: processed_response,
+          conversation_history: @memory.to_h,
+          status: 'completed'
+        }
+      end
+
+      private
+
+      def prepare_context
+        {
+          messages: @memory.messages,
+          tools: @toolkit.tool_descriptions,
+          parameters: @context[:parameters]
+        }
+      end
+
+      def make_llm_call(context)
+        case @context[:model_provider]
+        when 'ollama'
+          make_ollama_request(context)
+        when 'openai'
+          make_openai_request(context)
+        end
+      end
+
+      def make_ollama_request(context, retries = 3)
+        require 'net/http'
+        require 'json'
+
+        messages = format_messages_for_ollama(context[:messages])
+        prompt = generate_ollama_prompt(messages, context[:tools])
+
+        uri = URI("#{@context[:ollama_base_url]}/api/generate")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.read_timeout = 120  # Increase timeout to 120 seconds
+        
+        request = Net::HTTP::Post.new(uri)
+        request['Content-Type'] = 'application/json'
+        request.body = {
+          model: @context[:model],
+          prompt: prompt,
+          stream: false,
+          options: @context[:parameters]
+        }.to_json
+
+        begin
+          response = http.request(request)
+          
+          if response.code == '200'
+            result = JSON.parse(response.body)
+            full_response = ""
+            
+            if result.is_a?(Array)
+              result.each { |chunk| full_response += chunk['response'].to_s }
+            else
+              full_response = result['response']
+            end
+
+            {
+              content: full_response,
+              tool_calls: extract_tool_calls(full_response)
+            }
+          else
+            raise "HTTP Error: #{response.message}"
+          end
+        rescue => e
+          if retries > 0
+            puts "Retrying Ollama request (#{retries} attempts left)..."
+            sleep(2)  # Wait 2 seconds before retrying
+            make_ollama_request(context, retries - 1)
+          else
+            {
+              content: "Error: #{e.message}. Please try again later.",
+              tool_calls: []
+            }
+          end
+        end
+      end
+
+      def make_openai_request(context)
+        # Implement OpenAI API call here
+        {
+          content: "OpenAI integration not implemented",
+          tool_calls: []
+        }
+      end
+
+      def format_messages_for_ollama(messages)
+        messages.map do |msg|
+          {
+            role: msg[:role],
+            content: msg[:content]
+          }
+        end
+      end
+
+      def generate_ollama_prompt(messages, tools)
+        system_msg = messages.find { |m| m[:role] == 'system' }
+        user_msgs = messages.select { |m| m[:role] != 'system' }
+
+        prompt = []
+        prompt << "System: #{system_msg[:content]}" if system_msg
+        prompt << "\nAvailable Tools:\n#{format_tools_for_ollama(tools)}" unless tools.empty?
+        
+        user_msgs.each do |msg|
+          prompt << "\n#{msg[:role].capitalize}: #{msg[:content]}"
+        end
+
+        prompt << "\nAssistant: "
+        prompt.join("\n")
+      end
+
+      def format_tools_for_ollama(tools)
+        return "" if tools.nil? || tools.empty?
+        tools.map do |tool|
+          "#{tool[:name]}: #{tool[:description]}\nParameters: #{tool[:parameters].to_json}"
+        end.join("\n\n")
+      end
+
+      def extract_tool_calls(content)
+        tool_calls = content.scan(/@(\w+)\((.*?)\)/)
+        tool_calls.map do |name, args_str|
+          begin
+            {
+              name: name,
+              arguments: JSON.parse(args_str)
+            }
+          rescue JSON::ParserError
+            nil
+          end
+        end.compact
+      end
+
+      def process_response(response)
+        return response unless response[:tool_calls]&.any?
+
+        tool_results = response[:tool_calls].map do |tool_call|
+          result = @toolkit.execute_tool(tool_call[:name], **tool_call[:arguments])
+          { tool: tool_call[:name], result: result }
+        end
+
+        response.merge(tool_results: tool_results)
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/base_executor.rb

@@ -0,0 +1,56 @@
+require_relative 'dsl'
+
+module CircuitBreaker
+  module Executors
+    class BaseExecutor
+      include DSL
+
+      attr_reader :context, :result
+
+      def initialize(context = {})
+        @context = context
+        @result = nil
+        validate_parameters
+      end
+
+      def execute
+        run_before_hooks
+        execute_internal
+        run_after_hooks
+        @result
+      end
+
+      protected
+
+      def execute_internal
+        raise NotImplementedError, "#{self.class} must implement #execute_internal"
+      end
+
+      private
+
+      def run_before_hooks
+        self.class.get_config[:before_execute].each do |hook|
+          instance_exec(@context, &hook)
+        end
+      end
+
+      def run_after_hooks
+        self.class.get_config[:after_execute].each do |hook|
+          instance_exec(@result, &hook)
+        end
+      end
+
+      def to_h
+        {
+          executor: self.class.name,
+          context: @context,
+          result: @result
+        }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/docker_executor.rb

@@ -0,0 +1,56 @@
+require_relative 'base_executor'
+
+module CircuitBreaker
+  module Executors
+    class DockerExecutor < BaseExecutor
+      executor_config do
+        parameter :image,
+          type: :string,
+          required: true,
+          description: 'Docker image to run'
+
+        parameter :command,
+          type: :string,
+          description: 'Command to run in the container'
+
+        parameter :environment,
+          type: :hash,
+          default: {},
+          description: 'Environment variables to set in the container'
+
+        parameter :volumes,
+          type: :array,
+          default: [],
+          description: 'Volumes to mount in the container'
+
+        validate do |context|
+          if context[:command] && !context[:command].is_a?(String)
+            raise ArgumentError, 'Command must be a string'
+          end
+        end
+
+        before_execute do |context|
+          puts "Preparing to run Docker container with image: #{context[:image]}"
+        end
+
+        after_execute do |result|
+          puts "Docker container execution completed with status: #{result[:status]}"
+        end
+      end
+
+      protected
+
+      def execute_internal
+        # Implementation for Docker execution would go here
+        # This would typically involve running a Docker container
+        @result = {
+          image: @context[:image],
+          command: @context[:command],
+          environment: @context[:environment],
+          volumes: @context[:volumes],
+          status: 'completed'
+        }
+      end
+    end
+  end
+end

data/lib/circuit_breaker/executors/dsl.rb

@@ -0,0 +1,97 @@
+module CircuitBreaker
+  module Executors
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def executor_config(&block)
+          @config_builder ||= ConfigBuilder.new
+          @config_builder.instance_eval(&block) if block_given?
+          @config_builder
+        end
+
+        def get_config
+          @config_builder&.to_h || {}
+        end
+      end
+
+      class ConfigBuilder
+        def initialize
+          @config = {
+            parameters: {},
+            validations: [],
+            before_execute: [],
+            after_execute: []
+          }
+        end
+
+        def parameter(name, type: nil, required: false, default: nil, description: nil)
+          @config[:parameters][name] = {
+            type: type,
+            required: required,
+            default: default,
+            description: description
+          }
+        end
+
+        def validate(&block)
+          @config[:validations] << block
+        end
+
+        def before_execute(&block)
+          @config[:before_execute] << block
+        end
+
+        def after_execute(&block)
+          @config[:after_execute] << block
+        end
+
+        def to_h
+          @config
+        end
+      end
+
+      def validate_parameters
+        config = self.class.get_config
+        parameters = config[:parameters]
+
+        parameters.each do |name, opts|
+          if opts[:required] && !@context.key?(name)
+            raise ArgumentError, "Missing required parameter: #{name}"
+          end
+
+          if @context.key?(name)
+            validate_parameter_type(name, @context[name], opts[:type]) if opts[:type]
+          elsif opts[:default]
+            @context[name] = opts[:default]
+          end
+        end
+
+        config[:validations].each do |validation|
+          instance_exec(@context, &validation)
+        end
+      end
+
+      private
+
+      def validate_parameter_type(name, value, expected_type)
+        case expected_type
+        when :string
+          raise TypeError, "#{name} must be a String" unless value.is_a?(String)
+        when :integer
+          raise TypeError, "#{name} must be an Integer" unless value.is_a?(Integer)
+        when :array
+          raise TypeError, "#{name} must be an Array" unless value.is_a?(Array)
+        when :hash
+          raise TypeError, "#{name} must be a Hash" unless value.is_a?(Hash)
+        when :boolean
+          unless [true, false].include?(value)
+            raise TypeError, "#{name} must be a Boolean"
+          end
+        end
+      end
+    end
+  end
+end