claude_swarm 0.1.20 → 0.2.0

data/lib/claude_swarm/openai/responses.rb

@@ -0,0 +1,338 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module OpenAI
+    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)
+        @openai_client = openai_client
+        @mcp_client = mcp_client
+        @available_tools = available_tools
+        @executor = logger # This is actually the executor, not a logger
+        @instance_name = instance_name
+        @model = model
+        @temperature = temperature
+        @reasoning_effort = reasoning_effort
+        @system_prompt = nil
+      end
+
+      def execute(prompt, options = {})
+        # Store system prompt for first call
+        @system_prompt = options[:system_prompt] if options[:system_prompt]
+
+        # Start with initial prompt
+        initial_input = prompt
+
+        # Process with recursive tool handling - start with empty conversation
+        process_responses_api(initial_input, [], nil)
+      end
+
+      def reset_session
+        @system_prompt = nil
+      end
+
+      private
+
+      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")
+          return "Error: Maximum tool call depth exceeded"
+        end
+
+        # Build parameters
+        parameters = {
+          model: @model,
+        }
+
+        # Only add temperature for non-o-series models
+        # O-series models don't support temperature parameter
+        unless @model.match?(ClaudeSwarm::Configuration::O_SERIES_MODEL_PATTERN)
+          parameters[:temperature] = @temperature
+        end
+
+        # Only add reasoning effort for o-series models
+        # reasoning is only supported by o-series models: o1, o1 Preview, o1-mini, o1-pro, o3, o3-mini, o3-pro, o3-deep-research, o4-mini, o4-mini-deep-research, etc.
+        if @reasoning_effort && @model.match?(ClaudeSwarm::Configuration::O_SERIES_MODEL_PATTERN)
+          parameters[:reasoning] = { effort: @reasoning_effort }
+        end
+
+        # On first call, use string input (can include system prompt)
+        # On subsequent calls with function results, use array input
+        if conversation_array.empty?
+          # Initial call - string input
+          parameters[:input] = if depth.zero? && @system_prompt
+            "#{@system_prompt}\n\n#{input}"
+          else
+            input
+          end
+        else
+          # Follow-up call with conversation array (function calls + outputs)
+          parameters[:input] = conversation_array
+
+          # Log conversation array to debug duplicates
+          @executor.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}")
+        end
+
+        # Add previous response ID for conversation continuity
+        parameters[:previous_response_id] = previous_response_id if previous_response_id
+
+        # Add tools if available
+        if @available_tools&.any?
+          # Convert tools to responses API format
+          parameters[:tools] = @available_tools.map do |tool|
+            {
+              "type" => "function",
+              "name" => tool.name,
+              "description" => tool.description,
+              "parameters" => tool.schema || {},
+            }
+          end
+          @executor.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)}")
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "openai_request",
+          api: "responses",
+          depth: depth,
+          parameters: parameters,
+        })
+
+        # Make the API call without streaming
+        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)}")
+
+          # 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}")
+            rescue StandardError => parse_error
+              @executor.error("Could not parse error response: #{parse_error.message}")
+            end
+          end
+
+          # Log error to session JSON
+          append_to_session_json({
+            type: "openai_error",
+            api: "responses",
+            error: {
+              class: e.class.to_s,
+              message: e.message,
+              response_body: e.respond_to?(:response) ? e.response[:body] : nil,
+              backtrace: e.backtrace.first(5),
+            },
+          })
+
+          return "Error calling OpenAI responses API: #{e.message}"
+        end
+
+        # Log the full response
+        @executor.info("Responses API Full Response (depth=#{depth}): #{JSON.pretty_generate(response)}")
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "openai_response",
+          api: "responses",
+          depth: depth,
+          response: response,
+        })
+
+        # Extract response details
+        response_id = response["id"]
+
+        # Handle response based on output structure
+        output = response["output"]
+
+        if output.nil?
+          @executor.error("No output in response")
+          return "Error: No output in OpenAI response"
+        end
+
+        # Check if output is an array (as per documentation)
+        if output.is_a?(Array) && !output.empty?
+          # Check if there are function calls
+          function_calls = output.select { |item| item["type"] == "function_call" }
+
+          if function_calls.any?
+            # Check if we already have a conversation going
+            if conversation_array.empty?
+              # First depth - build new conversation
+              new_conversation = build_conversation_with_outputs(function_calls)
+            else
+              # Subsequent depth - append to existing conversation
+              # Don't re-add function calls, just add the new ones and their outputs
+              new_conversation = conversation_array.dup
+              append_new_outputs(function_calls, new_conversation)
+            end
+
+            # Recursively process with updated conversation
+            process_responses_api(nil, new_conversation, response_id, depth + 1)
+          else
+            # Look for text response
+            extract_text_response(output)
+          end
+        else
+          @executor.error("Unexpected output format: #{output.inspect}")
+          "Error: Unexpected response format"
+        end
+      end
+
+      def extract_text_response(output)
+        text_output = output.find { |item| item["content"] }
+        return "" unless text_output && text_output["content"].is_a?(Array)
+
+        text_content = text_output["content"].find { |item| item["text"] }
+        text_content ? text_content["text"] : ""
+      end
+
+      def build_conversation_with_outputs(function_calls)
+        # Log tool calls
+        @executor.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
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "tool_calls",
+          api: "responses",
+          tool_calls: function_calls,
+        })
+
+        # Build conversation array with function outputs only
+        # The API already knows about the function calls from the previous response
+        conversation = []
+
+        # Then execute tools and add outputs
+        function_calls.each do |function_call|
+          tool_name = function_call["name"]
+          tool_args_str = function_call["arguments"]
+          # Use the call_id field for matching with function outputs
+          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"]}")
+
+          begin
+            # Parse arguments
+            tool_args = JSON.parse(tool_args_str)
+
+            # Log tool execution
+            @executor.info("Responses API - Executing tool: #{tool_name} with args: #{JSON.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}")
+
+            # Append to session JSON
+            append_to_session_json({
+              type: "tool_execution",
+              api: "responses",
+              tool_name: tool_name,
+              arguments: tool_args,
+              result: result.to_s,
+            })
+
+            # Add function output to conversation
+            conversation << {
+              type: "function_call_output",
+              call_id: call_id,
+              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"))
+
+            # Append error to session JSON
+            append_to_session_json({
+              type: "tool_error",
+              api: "responses",
+              tool_name: tool_name,
+              arguments: tool_args_str,
+              error: {
+                class: e.class.to_s,
+                message: e.message,
+                backtrace: e.backtrace.first(5),
+              },
+            })
+
+            # Add error output to conversation
+            conversation << {
+              type: "function_call_output",
+              call_id: call_id,
+              output: { error: e.message }.to_json,
+            }
+          end
+        end
+
+        @executor.info("Responses API - Built conversation with #{conversation.size} function outputs")
+        @executor.debug("Final conversation structure: #{JSON.pretty_generate(conversation)}")
+        conversation
+      end
+
+      def append_new_outputs(function_calls, conversation)
+        # Only add the new function outputs
+        # Don't add function calls - the API already knows about them
+
+        function_calls.each do |fc|
+          # Execute and add output only
+          tool_name = fc["name"]
+          tool_args_str = fc["arguments"]
+          call_id = fc["call_id"]
+
+          begin
+            # Parse arguments
+            tool_args = JSON.parse(tool_args_str)
+
+            # Log tool execution
+            @executor.info("Responses API - Executing tool: #{tool_name} with args: #{JSON.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}")
+
+            # Add function output to conversation
+            conversation << {
+              type: "function_call_output",
+              call_id: call_id,
+              output: result.to_json, # Must be JSON string
+            }
+          rescue StandardError => e
+            @executor.error("Responses API - Tool execution failed for #{tool_name}: #{e.message}")
+
+            # Add error output to conversation
+            conversation << {
+              type: "function_call_output",
+              call_id: call_id,
+              output: { error: e.message }.to_json,
+            }
+          end
+        end
+      end
+
+      def append_to_session_json(event)
+        # Delegate to the executor's log method
+        @executor.log(event) if @executor.respond_to?(:log)
+      end
+    end
+  end
+end

data/lib/claude_swarm/orchestrator.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
-require "English"
-require "shellwords"
-require "json"
-require "fileutils"
-
 module ClaudeSwarm
   class Orchestrator
     include SystemUtils
     RUN_DIR = File.expand_path("~/.claude-swarm/run")
 
     def initialize(configuration, mcp_generator, vibe: false, prompt: nil, stream_logs: false, debug: false,
-                   restore_session_path: nil, worktree: nil)
+      restore_session_path: nil, worktree: nil, session_id: nil)
       @config = configuration
       @generator = mcp_generator
       @vibe = vibe
@@ -20,18 +15,24 @@ module ClaudeSwarm
       @debug = debug
       @restore_session_path = restore_session_path
       @session_path = nil
+      @provided_session_id = session_id
       # Store worktree option for later use
       @worktree_option = worktree
       @needs_worktree_manager = worktree.is_a?(String) || worktree == "" ||
-                                configuration.instances.values.any? { |inst| !inst[:worktree].nil? }
+        configuration.instances.values.any? { |inst| !inst[:worktree].nil? }
       # Store modified instances after worktree setup
       @modified_instances = nil
+      # Track start time for runtime calculation
+      @start_time = nil
 
       # Set environment variable for prompt mode to suppress output
       ENV["CLAUDE_SWARM_PROMPT"] = "1" if @prompt
     end
 
     def start
+      # Track start time
+      @start_time = Time.now
+
       if @restore_session_path
         unless @prompt
           puts "🔄 Restoring Claude Swarm: #{@config.swarm_name}"
@@ -76,7 +77,11 @@ module ClaudeSwarm
         end
 
         # Generate and set session path for all instances
-        session_path = SessionPath.generate(working_dir: Dir.pwd)
+        session_path = if @provided_session_id
+          SessionPath.generate(working_dir: Dir.pwd, session_id: @provided_session_id)
+        else
+          SessionPath.generate(working_dir: Dir.pwd)
+        end
         SessionPath.ensure_directory(session_path)
         @session_path = session_path
 
@@ -129,29 +134,6 @@ module ClaudeSwarm
         save_swarm_config_path(session_path)
       end
 
-      # Execute before commands if specified
-      before_commands = @config.before_commands
-      if before_commands.any? && !@restore_session_path
-        unless @prompt
-          puts "⚙️  Executing before commands..."
-          puts
-        end
-
-        success = execute_before_commands(before_commands)
-        unless success
-          puts "❌ Before commands failed. Aborting swarm launch." unless @prompt
-          cleanup_processes
-          cleanup_run_symlink
-          cleanup_worktrees
-          exit 1
-        end
-
-        unless @prompt
-          puts "✓ Before commands completed successfully"
-          puts
-        end
-      end
-
       # Launch the main instance (fetch after worktree setup to get modified paths)
       main_instance = @config.main_instance_config
       unless @prompt
@@ -180,8 +162,35 @@ module ClaudeSwarm
       log_thread = nil
       log_thread = start_log_streaming if @prompt && @stream_logs
 
+      # Write the current process PID (orchestrator) to a file for easy access
+      main_pid_file = File.join(@session_path, "main_pid")
+      File.write(main_pid_file, Process.pid.to_s)
+
       # Execute the main instance - this will cascade to other instances via MCP
       Dir.chdir(main_instance[:directory]) do
+        # Execute before commands if specified
+        before_commands = @config.before_commands
+        if before_commands.any? && !@restore_session_path
+          unless @prompt
+            puts "⚙️  Executing before commands..."
+            puts
+          end
+
+          success = execute_before_commands?(before_commands)
+          unless success
+            puts "❌ Before commands failed. Aborting swarm launch." unless @prompt
+            cleanup_processes
+            cleanup_run_symlink
+            cleanup_worktrees
+            exit(1)
+          end
+
+          unless @prompt
+            puts "✓ Before commands completed successfully"
+            puts
+          end
+        end
+
         system!(*command)
       end
 
@@ -191,6 +200,27 @@ module ClaudeSwarm
         log_thread.join
       end
 
+      # Display runtime and cost summary
+      display_summary
+
+      # Execute after commands if specified
+      after_commands = @config.after_commands
+      if after_commands.any? && !@restore_session_path
+        Dir.chdir(main_instance[:directory]) do
+          unless @prompt
+            puts
+            puts "⚙️  Executing after commands..."
+            puts
+          end
+
+          success = execute_after_commands?(after_commands)
+          if !success && !@prompt
+            puts "⚠️  Some after commands failed"
+            puts
+          end
+        end
+      end
+
       # Clean up child processes and run symlink
       cleanup_processes
       cleanup_run_symlink
@@ -199,7 +229,7 @@ module ClaudeSwarm
 
     private
 
-    def execute_before_commands(commands)
+    def execute_before_commands?(commands)
       log_file = File.join(@session_path, "session.log") if @session_path
 
       commands.each_with_index do |command, index|
@@ -215,7 +245,7 @@ module ClaudeSwarm
           puts "Debug: Executing command #{index + 1}/#{commands.size}: #{command}" if @debug && !@prompt
 
           # Use system with output capture
-          output = `#{command} 2>&1`
+          output = %x(#{command} 2>&1)
           success = $CHILD_STATUS.success?
 
           # Log the output
@@ -254,6 +284,62 @@ module ClaudeSwarm
       true
     end
 
+    def execute_after_commands?(commands)
+      log_file = File.join(@session_path, "session.log") if @session_path
+      all_succeeded = true
+
+      commands.each_with_index do |command, index|
+        # Log the command execution to session log
+        if @session_path
+          File.open(log_file, "a") do |f|
+            f.puts "[#{Time.now.strftime("%Y-%m-%d %H:%M:%S")}] Executing after command #{index + 1}/#{commands.size}: #{command}"
+          end
+        end
+
+        # Execute the command and capture output
+        begin
+          puts "Debug: Executing after command #{index + 1}/#{commands.size}: #{command}" if @debug && !@prompt
+
+          # Use system with output capture
+          output = %x(#{command} 2>&1)
+          success = $CHILD_STATUS.success?
+
+          # Log the output
+          if @session_path
+            File.open(log_file, "a") do |f|
+              f.puts "Command output:"
+              f.puts output
+              f.puts "Exit status: #{$CHILD_STATUS.exitstatus}"
+              f.puts "-" * 80
+            end
+          end
+
+          # Show output if in debug mode or if command failed
+          if (@debug || !success) && !@prompt
+            puts "After command #{index + 1} output:"
+            puts output
+            puts "Exit status: #{$CHILD_STATUS.exitstatus}"
+          end
+
+          unless success
+            puts "❌ After command #{index + 1} failed: #{command}" unless @prompt
+            all_succeeded = false
+          end
+        rescue StandardError => e
+          puts "Error executing after command #{index + 1}: #{e.message}" unless @prompt
+          if @session_path
+            File.open(log_file, "a") do |f|
+              f.puts "Error: #{e.message}"
+              f.puts "-" * 80
+            end
+          end
+          all_succeeded = false
+        end
+      end
+
+      all_succeeded
+    end
+
     def save_swarm_config_path(session_path)
       # Copy the YAML config file to the session directory
       config_copy_path = File.join(session_path, "config.yml")
@@ -267,8 +353,9 @@ module ClaudeSwarm
       metadata = {
         "start_directory" => Dir.pwd,
         "timestamp" => Time.now.utc.iso8601,
+        "start_time" => @start_time.utc.iso8601,
         "swarm_name" => @config.swarm_name,
-        "claude_swarm_version" => VERSION
+        "claude_swarm_version" => VERSION,
       }
 
       # Add worktree info if applicable
@@ -279,9 +366,23 @@ module ClaudeSwarm
     end
 
     def setup_signal_handlers
-      %w[INT TERM QUIT].each do |signal|
+      ["INT", "TERM", "QUIT"].each do |signal|
         Signal.trap(signal) do
           puts "\n🛑 Received #{signal} signal, cleaning up..."
+          display_summary
+
+          # Execute after commands if configured
+          main_instance = @config.main_instance_config
+          after_commands = @config.after_commands
+          if after_commands.any? && !@restore_session_path && !@prompt
+            Dir.chdir(main_instance[:directory]) do
+              puts
+              puts "⚙️  Executing after commands..."
+              puts
+              execute_after_commands?(after_commands)
+            end
+          end
+
           cleanup_processes
           cleanup_run_symlink
           cleanup_worktrees
@@ -305,6 +406,71 @@ module ClaudeSwarm
       puts "⚠️  Error during worktree cleanup: #{e.message}"
     end
 
+    def display_summary
+      return unless @session_path && @start_time
+
+      end_time = Time.now
+      runtime_seconds = (end_time - @start_time).to_i
+
+      # Update session metadata with end time
+      update_session_end_time(end_time)
+
+      # Calculate total cost from session logs
+      total_cost = calculate_total_cost
+
+      puts
+      puts "=" * 50
+      puts "🏁 Claude Swarm Summary"
+      puts "=" * 50
+      puts "Runtime: #{format_duration(runtime_seconds)}"
+      puts "Total Cost: #{format_cost(total_cost)}"
+      puts "Session: #{File.basename(@session_path)}"
+      puts "=" * 50
+    end
+
+    def update_session_end_time(end_time)
+      metadata_file = File.join(@session_path, "session_metadata.json")
+      return unless File.exist?(metadata_file)
+
+      metadata = JSON.parse(File.read(metadata_file))
+      metadata["end_time"] = end_time.utc.iso8601
+      metadata["duration_seconds"] = (end_time - @start_time).to_i
+
+      File.write(metadata_file, JSON.pretty_generate(metadata))
+    rescue StandardError => e
+      puts "⚠️  Error updating session metadata: #{e.message}" unless @prompt
+    end
+
+    def calculate_total_cost
+      log_file = File.join(@session_path, "session.log.json")
+      result = SessionCostCalculator.calculate_total_cost(log_file)
+
+      # Check if main instance has cost data
+      main_instance_name = @config.main_instance
+      @main_has_cost = result[:instances_with_cost].include?(main_instance_name)
+
+      result[:total_cost]
+    end
+
+    def format_duration(seconds)
+      hours = seconds / 3600
+      minutes = (seconds % 3600) / 60
+      secs = seconds % 60
+
+      parts = []
+      parts << "#{hours}h" if hours.positive?
+      parts << "#{minutes}m" if minutes.positive?
+      parts << "#{secs}s"
+
+      parts.join(" ")
+    end
+
+    def format_cost(cost)
+      cost_str = format("$%.4f", cost)
+      cost_str += " (excluding main instance)" unless @main_has_cost
+      cost_str
+    end
+
     def create_run_symlink
       return unless @session_path
 
@@ -339,7 +505,7 @@ module ClaudeSwarm
         session_log_path = File.join(ENV.fetch("CLAUDE_SWARM_SESSION_PATH", nil), "session.log")
 
         # Wait for log file to be created
-        sleep 0.1 until File.exist?(session_log_path)
+        sleep(0.1) until File.exist?(session_log_path)
 
         # Open file and seek to end
         File.open(session_log_path, "r") do |file|
@@ -348,10 +514,10 @@ module ClaudeSwarm
           loop do
             changes = file.read
             if changes
-              print changes
+              print(changes)
               $stdout.flush
             else
-              sleep 0.1
+              sleep(0.1)
             end
           end
         end
@@ -374,7 +540,7 @@ module ClaudeSwarm
       parts = [
         "claude",
         "--model",
-        instance[:model]
+        instance[:model],
       ]
 
       # Add resume flag if restoring session