claude_swarm 0.3.2 → 1.0.0

data/lib/claude_swarm/openai/executor.rb

@@ -1,26 +1,53 @@
 # frozen_string_literal: true
 
+require "openai"
+require "faraday/net_http_persistent"
+require "faraday/retry"
+
 module ClaudeSwarm
   module OpenAI
-    class Executor
-      attr_reader :session_id, :last_response, :working_directory, :logger, :session_path
+    class Executor < BaseExecutor
+      # Static configuration for Faraday retry middleware
+      FARADAY_RETRY_CONFIG = {
+        max: 3, # Maximum number of retries
+        interval: 0.5, # Initial delay between retries (in seconds)
+        interval_randomness: 0.5, # Randomness factor for retry intervals
+        backoff_factor: 2, # Exponential backoff factor
+        exceptions: [
+          Faraday::TimeoutError,
+          Faraday::ConnectionFailed,
+          Faraday::ServerError, # Retry on 5xx errors
+        ].freeze,
+        retry_statuses: [429, 500, 502, 503, 504].freeze, # HTTP status codes to retry
+      }.freeze
+
+      # Static configuration for OpenAI client
+      OPENAI_CLIENT_CONFIG = {
+        log_errors: true,
+        request_timeout: 1800, # 30 minutes
+      }.freeze
 
       def initialize(working_directory: Dir.pwd, model: nil, mcp_config: nil, vibe: false,
         instance_name: nil, instance_id: nil, calling_instance: nil, calling_instance_id: nil,
-        claude_session_id: nil, additional_directories: [],
+        claude_session_id: nil, additional_directories: [], debug: false,
         temperature: nil, api_version: "chat_completion", openai_token_env: "OPENAI_API_KEY",
         base_url: nil, reasoning_effort: nil)
-        @working_directory = working_directory
-        @additional_directories = additional_directories
-        @model = model
-        @mcp_config = mcp_config
-        @vibe = vibe
-        @session_id = claude_session_id
-        @last_response = nil
-        @instance_name = instance_name
-        @instance_id = instance_id
-        @calling_instance = calling_instance
-        @calling_instance_id = calling_instance_id
+        # Call parent initializer for common attributes
+        super(
+          working_directory: working_directory,
+          model: model,
+          mcp_config: mcp_config,
+          vibe: vibe,
+          instance_name: instance_name,
+          instance_id: instance_id,
+          calling_instance: calling_instance,
+          calling_instance_id: calling_instance_id,
+          claude_session_id: claude_session_id,
+          additional_directories: additional_directories,
+          debug: debug
+        )
+
+        # OpenAI-specific attributes
         @temperature = temperature
         @api_version = api_version
         @base_url = base_url
@@ -30,37 +57,14 @@ module ClaudeSwarm
         @conversation_messages = []
         @previous_response_id = nil
 
-        # Setup logging first
-        setup_logging
-
         # Setup OpenAI client
         setup_openai_client(openai_token_env)
 
         # Setup MCP client for tools
         setup_mcp_client
 
-        # Create API handlers
-        @chat_completion_handler = OpenAI::ChatCompletion.new(
-          openai_client: @openai_client,
-          mcp_client: @mcp_client,
-          available_tools: @available_tools,
-          logger: self,
-          instance_name: @instance_name,
-          model: @model,
-          temperature: @temperature,
-          reasoning_effort: @reasoning_effort,
-        )
-
-        @responses_handler = OpenAI::Responses.new(
-          openai_client: @openai_client,
-          mcp_client: @mcp_client,
-          available_tools: @available_tools,
-          logger: self,
-          instance_name: @instance_name,
-          model: @model,
-          temperature: @temperature,
-          reasoning_effort: @reasoning_effort,
-        )
+        # Create API handler based on api_version
+        @api_handler = create_api_handler
       end
 
       def execute(prompt, options = {})
@@ -70,61 +74,23 @@ module ClaudeSwarm
         # Start timing
         start_time = Time.now
 
-        # Execute based on API version
-        result = if @api_version == "responses"
-          @responses_handler.execute(prompt, options)
-        else
-          @chat_completion_handler.execute(prompt, options)
-        end
+        # Execute using the appropriate handler
+        result = @api_handler.execute(prompt, options)
 
         # Calculate duration
         duration_ms = ((Time.now - start_time) * 1000).round
 
-        # Format response similar to ClaudeCodeExecutor
-        response = {
-          "type" => "result",
-          "result" => result,
-          "duration_ms" => duration_ms,
-          "total_cost" => calculate_cost(result),
-          "session_id" => @session_id,
-        }
-
-        log_response(response)
-
-        @last_response = response
-        response
+        # Build and return response
+        build_response(result, duration_ms)
       rescue StandardError => e
-        @logger.error("Unexpected error for #{@instance_name}: #{e.class} - #{e.message}")
-        @logger.error("Backtrace: #{e.backtrace.join("\n")}")
+        logger.error { "Unexpected error for #{@instance_name}: #{e.class} - #{e.message}" }
+        logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
         raise
       end
 
       def reset_session
-        @session_id = nil
-        @last_response = nil
-        @chat_completion_handler&.reset_session
-        @responses_handler&.reset_session
-      end
-
-      def has_session?
-        !@session_id.nil?
-      end
-
-      # Delegate logger methods for the API handlers
-      def info(message)
-        @logger.info(message)
-      end
-
-      def error(message)
-        @logger.error(message)
-      end
-
-      def warn(message)
-        @logger.warn(message)
-      end
-
-      def debug(message)
-        @logger.debug(message)
+        super
+        @api_handler&.reset_session
       end
 
       # Session JSON logger for the API handlers
@@ -139,14 +105,15 @@ module ClaudeSwarm
       private
 
       def setup_openai_client(token_env)
-        config = {
-          access_token: ENV.fetch(token_env),
-          log_errors: true,
-          request_timeout: 1800, # 30 minutes
-        }
-        config[:uri_base] = @base_url if @base_url
+        openai_client_config = build_openai_client_config(token_env)
+
+        @openai_client = ::OpenAI::Client.new(openai_client_config) do |faraday|
+          # Use persistent HTTP connections for better performance
+          faraday.adapter(:net_http_persistent)
 
-        @openai_client = ::OpenAI::Client.new(config)
+          # Add retry middleware with custom configuration
+          faraday.request(:retry, **build_faraday_retry_config)
+        end
       rescue KeyError
         raise ExecutionError, "OpenAI API key not found in environment variable: #{token_env}"
       end
@@ -155,54 +122,26 @@ module ClaudeSwarm
         return unless @mcp_config && File.exist?(@mcp_config)
 
         # Read MCP config to find MCP servers
-        mcp_data = JSON.parse(File.read(@mcp_config))
-
-        # Create MCP client with all MCP servers from the config
-        if mcp_data["mcpServers"] && !mcp_data["mcpServers"].empty?
-          mcp_configs = []
-
-          mcp_data["mcpServers"].each do |name, server_config|
-            case server_config["type"]
-            when "stdio"
-              # Combine command and args into a single array
-              command_array = [server_config["command"]]
-              command_array.concat(server_config["args"] || [])
-
-              stdio_config = MCPClient.stdio_config(
-                command: command_array,
-                name: name,
-              )
-              stdio_config[:read_timeout] = 1800
-              mcp_configs << stdio_config
-            when "sse"
-              @logger.warn("SSE MCP servers not yet supported for OpenAI instances: #{name}")
-              # TODO: Add SSE support when available in ruby-mcp-client
-            end
-          end
-
-          if mcp_configs.any?
-            # Create MCP client with unbundled environment to avoid bundler conflicts
-            # This ensures MCP servers run in a clean environment without inheriting
-            # Claude Swarm's BUNDLE_* environment variables
-            Bundler.with_unbundled_env do
-              @mcp_client = MCPClient.create_client(
-                mcp_server_configs: mcp_configs,
-                logger: @logger,
-              )
-
-              # List available tools from all MCP servers
-              begin
-                @available_tools = @mcp_client.list_tools
-                @logger.info("Loaded #{@available_tools.size} tools from #{mcp_configs.size} MCP server(s)")
-              rescue StandardError => e
-                @logger.error("Failed to load MCP tools: #{e.message}")
-                @available_tools = []
-              end
-            end
-          end
+        mcp_data = JsonHandler.parse_file!(@mcp_config)
+
+        # Build MCP configurations from servers
+        mcp_configs = build_mcp_configs(mcp_data["mcpServers"])
+        return if mcp_configs.empty?
+
+        # Create MCP client with unbundled environment to avoid bundler conflicts
+        # This ensures MCP servers run in a clean environment without inheriting
+        # Claude Swarm's BUNDLE_* environment variables
+        Bundler.with_unbundled_env do
+          @mcp_client = MCPClient.create_client(
+            mcp_server_configs: mcp_configs,
+            logger: @logger,
+          )
+
+          # List available tools from all MCP servers
+          load_mcp_tools(mcp_configs)
         end
       rescue StandardError => e
-        @logger.error("Failed to setup MCP client: #{e.message}")
+        logger.error { "Failed to setup MCP client: #{e.message}" }
         @mcp_client = nil
         @available_tools = []
       end
@@ -213,96 +152,103 @@ module ClaudeSwarm
         "$0.00"
       end
 
-      def setup_logging
-        # Use session path from environment (required)
-        @session_path = SessionPath.from_env
-        SessionPath.ensure_directory(@session_path)
-
-        # Create logger with session.log filename
-        log_filename = "session.log"
-        log_path = File.join(@session_path, log_filename)
-        @logger = Logger.new(log_path)
-        @logger.level = Logger::INFO
+      def create_api_handler
+        handler_params = {
+          openai_client: @openai_client,
+          mcp_client: @mcp_client,
+          available_tools: @available_tools,
+          executor: self,
+          instance_name: @instance_name,
+          model: @model,
+          temperature: @temperature,
+          reasoning_effort: @reasoning_effort,
+        }
 
-        # Custom formatter for better readability
-        @logger.formatter = proc do |severity, datetime, _progname, msg|
-          "[#{datetime.strftime("%Y-%m-%d %H:%M:%S.%L")}] [#{severity}] #{msg}\n"
+        if @api_version == "responses"
+          OpenAI::Responses.new(**handler_params)
+        else
+          OpenAI::ChatCompletion.new(**handler_params)
         end
-
-        return unless @instance_name
-
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info("Started OpenAI executor for instance: #{instance_info}")
       end
 
-      def log_request(prompt)
-        caller_info = @calling_instance
-        caller_info += " (#{@calling_instance_id})" if @calling_instance_id
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info("#{caller_info} -> #{instance_info}: \n---\n#{prompt}\n---")
-
-        # Build event hash for JSON logging
-        event = {
-          type: "request",
-          from_instance: @calling_instance,
-          from_instance_id: @calling_instance_id,
-          to_instance: @instance_name,
-          to_instance_id: @instance_id,
-          prompt: prompt,
-          timestamp: Time.now.iso8601,
-        }
-
-        append_to_session_json(event)
+      def log_streaming_content(content)
+        # Log streaming content similar to ClaudeCodeExecutor
+        logger.debug { "#{instance_info} streaming: #{content}" }
       end
 
-      def log_response(response)
-        caller_info = @calling_instance
-        caller_info += " (#{@calling_instance_id})" if @calling_instance_id
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info(
-          "(#{response["total_cost"]} - #{response["duration_ms"]}ms) #{instance_info} -> #{caller_info}: \n---\n#{response["result"]}\n---",
+      def build_faraday_retry_config
+        FARADAY_RETRY_CONFIG.merge(
+          retry_block: method(:handle_retry_logging),
         )
       end
 
-      def log_streaming_content(content)
-        # Log streaming content similar to ClaudeCodeExecutor
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.debug("#{instance_info} streaming: #{content}")
+      def handle_retry_logging(env:, options:, retry_count:, exception:, will_retry:)
+        retry_delay = options.interval * (options.backoff_factor**(retry_count - 1))
+        error_info = exception&.message || "HTTP #{env.status}"
+
+        message = if will_retry
+          "Request failed (attempt #{retry_count}/#{options.max}): #{error_info}. Retrying in #{retry_delay} seconds..."
+        else
+          "Request failed after #{retry_count} attempts: #{error_info}. Giving up."
+        end
+
+        @logger.warn(message)
       end
 
-      def append_to_session_json(event)
-        json_filename = "session.log.json"
-        json_path = File.join(@session_path, json_filename)
+      def build_openai_client_config(token_env)
+        OPENAI_CLIENT_CONFIG.merge(access_token: ENV.fetch(token_env)).tap do |config|
+          config[:uri_base] = @base_url if @base_url
+        end
+      end
 
-        # Use file locking to ensure thread-safe writes
-        File.open(json_path, File::WRONLY | File::APPEND | File::CREAT) do |file|
-          file.flock(File::LOCK_EX)
+      def build_stdio_config(name, server_config)
+        # Combine command and args into a single array
+        command_array = [server_config["command"]]
+        command_array.concat(server_config["args"] || [])
 
-          # Create entry with metadata
-          entry = {
-            instance: @instance_name,
-            instance_id: @instance_id,
-            calling_instance: @calling_instance,
-            calling_instance_id: @calling_instance_id,
-            timestamp: Time.now.iso8601,
-            event: event,
-          }
+        MCPClient.stdio_config(
+          command: command_array,
+          name: name,
+        ).tap do |config|
+          config[:read_timeout] = 1800
+        end
+      end
 
-          # Write as single line JSON (JSONL format)
-          file.puts(entry.to_json)
+      def build_mcp_configs(mcp_servers)
+        return [] if mcp_servers.nil? || mcp_servers.empty?
 
-          file.flock(File::LOCK_UN)
+        mcp_servers.filter_map do |name, server_config|
+          case server_config["type"]
+          when "stdio"
+            build_stdio_config(name, server_config)
+          when "sse"
+            logger.warn { "SSE MCP servers not yet supported for OpenAI instances: #{name}" }
+            # TODO: Add SSE support when available in ruby-mcp-client
+            nil
+          end
         end
+      end
+
+      def load_mcp_tools(mcp_configs)
+        @available_tools = @mcp_client.list_tools
+        logger.info { "Loaded #{@available_tools.size} tools from #{mcp_configs.size} MCP server(s)" }
       rescue StandardError => e
-        @logger.error("Failed to append to session JSON: #{e.message}")
-        raise
+        logger.error { "Failed to load MCP tools: #{e.message}" }
+        @available_tools = []
       end
 
-      class ExecutionError < StandardError; end
+      def build_response(result, duration_ms)
+        {
+          "type" => "result",
+          "result" => result,
+          "duration_ms" => duration_ms,
+          "total_cost" => calculate_cost(result),
+          "session_id" => @session_id,
+        }.tap do |response|
+          log_response(response)
+          @last_response = response
+        end
+      end
     end
   end
 end

data/lib/claude_swarm/openai/responses.rb

@@ -5,11 +5,11 @@ module ClaudeSwarm
     class Responses
       MAX_TURNS_WITH_TOOLS = 100_000 # virtually infinite
 
-      def initialize(openai_client:, mcp_client:, available_tools:, logger:, instance_name:, model:, temperature: nil, reasoning_effort: nil)
+      def initialize(openai_client:, mcp_client:, available_tools:, executor:, instance_name:, model:, temperature: nil, reasoning_effort: nil)
         @openai_client = openai_client
         @mcp_client = mcp_client
         @available_tools = available_tools
-        @executor = logger # This is actually the executor, not a logger
+        @executor = executor
         @instance_name = instance_name
         @model = model
         @temperature = temperature
@@ -37,7 +37,7 @@ module ClaudeSwarm
       def process_responses_api(input, conversation_array, previous_response_id, depth = 0)
         # Prevent infinite recursion
         if depth > MAX_TURNS_WITH_TOOLS
-          @executor.error("Maximum recursion depth reached in tool execution")
+          @executor.logger.error { "Maximum recursion depth reached in tool execution" }
           return "Error: Maximum tool call depth exceeded"
         end
 
@@ -72,11 +72,11 @@ module ClaudeSwarm
           parameters[:input] = conversation_array
 
           # Log conversation array to debug duplicates
-          @executor.info("Conversation array size: #{conversation_array.size}")
+          @executor.logger.info { "Conversation array size: #{conversation_array.size}" }
           conversation_ids = conversation_array.map do |item|
             item["call_id"] || item["id"] || "no-id-#{item["type"]}"
           end.compact
-          @executor.info("Conversation item IDs: #{conversation_ids.inspect}")
+          @executor.logger.info { "Conversation item IDs: #{conversation_ids.inspect}" }
         end
 
         # Add previous response ID for conversation continuity
@@ -93,11 +93,11 @@ module ClaudeSwarm
               "parameters" => tool.schema || {},
             }
           end
-          @executor.info("Available tools for responses API: #{parameters[:tools].map { |t| t["name"] }.join(", ")}")
+          @executor.logger.info { "Available tools for responses API: #{parameters[:tools].map { |t| t["name"] }.join(", ")}" }
         end
 
         # Log the request parameters
-        @executor.info("Responses API Request (depth=#{depth}): #{JSON.pretty_generate(parameters)}")
+        @executor.logger.info { "Responses API Request (depth=#{depth}): #{JsonHandler.pretty_generate!(parameters)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -111,16 +111,16 @@ module ClaudeSwarm
         begin
           response = @openai_client.responses.create(parameters: parameters)
         rescue StandardError => e
-          @executor.error("Responses API error: #{e.class} - #{e.message}")
-          @executor.error("Request parameters: #{JSON.pretty_generate(parameters)}")
+          @executor.logger.error { "Responses API error: #{e.class} - #{e.message}" }
+          @executor.logger.error { "Request parameters: #{JsonHandler.pretty_generate!(parameters)}" }
 
           # Try to extract and log the response body for better debugging
           if e.respond_to?(:response)
             begin
               error_body = e.response[:body]
-              @executor.error("Error response body: #{error_body}")
+              @executor.logger.error { "Error response body: #{error_body}" }
             rescue StandardError => parse_error
-              @executor.error("Could not parse error response: #{parse_error.message}")
+              @executor.logger.error { "Could not parse error response: #{parse_error.message}" }
             end
           end
 
@@ -140,7 +140,7 @@ module ClaudeSwarm
         end
 
         # Log the full response
-        @executor.info("Responses API Full Response (depth=#{depth}): #{JSON.pretty_generate(response)}")
+        @executor.logger.info { "Responses API Full Response (depth=#{depth}): #{JsonHandler.pretty_generate!(response)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -157,7 +157,7 @@ module ClaudeSwarm
         output = response["output"]
 
         if output.nil?
-          @executor.error("No output in response")
+          @executor.logger.error { "No output in response" }
           return "Error: No output in OpenAI response"
         end
 
@@ -185,7 +185,7 @@ module ClaudeSwarm
             extract_text_response(output)
           end
         else
-          @executor.error("Unexpected output format: #{output.inspect}")
+          @executor.logger.error { "Unexpected output format: #{output.inspect}" }
           "Error: Unexpected response format"
         end
       end
@@ -200,12 +200,12 @@ module ClaudeSwarm
 
       def build_conversation_with_outputs(function_calls)
         # Log tool calls
-        @executor.info("Responses API - Handling #{function_calls.size} function calls")
+        @executor.logger.info { "Responses API - Handling #{function_calls.size} function calls" }
 
         # Log IDs to check for duplicates
         call_ids = function_calls.map { |fc| fc["call_id"] || fc["id"] }
-        @executor.info("Function call IDs: #{call_ids.inspect}")
-        @executor.warn("WARNING: Duplicate function call IDs detected!") if call_ids.size != call_ids.uniq.size
+        @executor.logger.info { "Function call IDs: #{call_ids.inspect}" }
+        @executor.logger.warn { "WARNING: Duplicate function call IDs detected!" } if call_ids.size != call_ids.uniq.size
 
         # Append to session JSON
         append_to_session_json({
@@ -226,20 +226,20 @@ module ClaudeSwarm
           call_id = function_call["call_id"]
 
           # Log both IDs to debug
-          @executor.info("Function call has id=#{function_call["id"]}, call_id=#{function_call["call_id"]}")
+          @executor.logger.info { "Function call has id=#{function_call["id"]}, call_id=#{function_call["call_id"]}" }
 
           begin
             # Parse arguments
-            tool_args = JSON.parse(tool_args_str)
+            tool_args = JsonHandler.parse!(tool_args_str)
 
             # Log tool execution
-            @executor.info("Responses API - Executing tool: #{tool_name} with args: #{JSON.pretty_generate(tool_args)}")
+            @executor.logger.info { "Responses API - Executing tool: #{tool_name} with args: #{JsonHandler.pretty_generate!(tool_args)}" }
 
             # Execute tool via MCP
             result = @mcp_client.call_tool(tool_name, tool_args)
 
             # Log result
-            @executor.info("Responses API - Tool result for #{tool_name}: #{result}")
+            @executor.logger.info { "Responses API - Tool result for #{tool_name}: #{result}" }
 
             # Append to session JSON
             append_to_session_json({
@@ -257,8 +257,8 @@ module ClaudeSwarm
               output: result.to_json, # Must be JSON string
             }
           rescue StandardError => e
-            @executor.error("Responses API - Tool execution failed for #{tool_name}: #{e.message}")
-            @executor.error(e.backtrace.join("\n"))
+            @executor.logger.error { "Responses API - Tool execution failed for #{tool_name}: #{e.message}" }
+            @executor.logger.error { e.backtrace.join("\n") }
 
             # Append error to session JSON
             append_to_session_json({
@@ -282,8 +282,8 @@ module ClaudeSwarm
           end
         end
 
-        @executor.info("Responses API - Built conversation with #{conversation.size} function outputs")
-        @executor.debug("Final conversation structure: #{JSON.pretty_generate(conversation)}")
+        @executor.logger.info { "Responses API - Built conversation with #{conversation.size} function outputs" }
+        @executor.logger.debug { "Final conversation structure: #{JsonHandler.pretty_generate!(conversation)}" }
         conversation
       end
 
@@ -299,16 +299,16 @@ module ClaudeSwarm
 
           begin
             # Parse arguments
-            tool_args = JSON.parse(tool_args_str)
+            tool_args = JsonHandler.parse!(tool_args_str)
 
             # Log tool execution
-            @executor.info("Responses API - Executing tool: #{tool_name} with args: #{JSON.pretty_generate(tool_args)}")
+            @executor.logger.info { "Responses API - Executing tool: #{tool_name} with args: #{JsonHandler.pretty_generate!(tool_args)}" }
 
             # Execute tool via MCP
             result = @mcp_client.call_tool(tool_name, tool_args)
 
             # Log result
-            @executor.info("Responses API - Tool result for #{tool_name}: #{result}")
+            @executor.logger.info { "Responses API - Tool result for #{tool_name}: #{result}" }
 
             # Add function output to conversation
             conversation << {
@@ -317,7 +317,7 @@ module ClaudeSwarm
               output: result.to_json, # Must be JSON string
             }
           rescue StandardError => e
-            @executor.error("Responses API - Tool execution failed for #{tool_name}: #{e.message}")
+            @executor.logger.error { "Responses API - Tool execution failed for #{tool_name}: #{e.message}" }
 
             # Add error output to conversation
             conversation << {