claude_swarm 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d72ab4034667cbfd6719b79c3a3aeff7ae93fdf7adc850b910edfcda8c4fe92
-  data.tar.gz: 48f3b2151b39a4aad0bc09ac089a6eb98911b82e4e7f1eb029e7541462a2efc6
+  metadata.gz: bc0d22524516d5e0f2a76715c2a80b36d1a974a3ff7ba451c103c86cb4a36fd1
+  data.tar.gz: 4cebdba8032fc3dfe223033ba9b2890b5849dd5516a539ffdf57231bcec66c38
 SHA512:
-  metadata.gz: 9f23d4f5086dac9ee9e112476d7e0aa1f4e39af367ef542829665989a17610e382f21b9c396f2118aab04cca56758286580a20a57be6ced893beddea49137890
-  data.tar.gz: c487d6321ae3f07e5310eb94e08ab1a45bc98628df6f82ad7cf5e74bb323358189310efeeb29b31c456ed61b0a61934c92aca0535d93947e8598a4192f97a6f6
+  metadata.gz: e5ec9ed928d5e73d12eb1257571e3c2b45fc9db64dbd64e8f3186ea2df5f187927d4cc0a6e8eb9901cb8dbaf4679f442f340c85f6f6f728ca01f1d8b82db8bf8
+  data.tar.gz: 8fce151a6a47d68736fc62b6453515f46e12d293d2eee2f3e951f99510351941faf9f0b9c5f0497de37847fac282cc997ccebdbb11f477fc71b21b8514dd753d

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## [0.3.7]
+
+### Added
+- **Main instance logging**: Captures main Claude instance output in `session.log` with prettified JSON format
+
+### Changed
+- **Updated claude-code-sdk-ruby dependency**: Bumped from 0.1.4 to 0.1.6
+  - Includes latest SDK improvements and bug fixes
+
+## [0.3.6]
+
+### Added
+- **SSE MCP server headers support**: SSE-type MCP servers can now include custom headers for authentication
+  - Supports headers like `Authorization: "Bearer ${TOKEN}"` in MCP configurations
+  - Environment variables in header values are automatically interpolated
+- **Comprehensive retry middleware for OpenAI API calls**: Added robust retry logic for OpenAI provider to handle API errors gracefully
+  - Automatically retries on rate limit errors (429) with exponential backoff
+  - Retries on server errors (500, 502, 503, 504) and timeout errors
+  - Configurable retry attempts, delay, and backoff settings
+  - Detailed logging of retry attempts and errors
+
 ## [0.3.5]
 
 ### Changed

data/README.md

@@ -389,6 +389,9 @@ mcps:
   - name: remote_api
     type: sse
     url: "https://api.example.com/mcp"
+    headers:  # Optional: custom headers for authentication
+      Authorization: "Bearer ${API_TOKEN}"
+      X-Custom-Header: "value"
 ```
 
 ### Tools

data/lib/claude_swarm/base_executor.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class BaseExecutor
+    attr_reader :session_id, :last_response, :working_directory, :logger, :session_path, :session_json_path, :instance_info
+
+    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: [], debug: false)
+      @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
+      @debug = debug
+
+      # Setup static info strings for logging
+      @instance_info = build_info(@instance_name, @instance_id)
+      @caller_info = build_info(@calling_instance, @calling_instance_id)
+      @caller_to_instance = "#{@caller_info} -> #{instance_info}:"
+      @instance_to_caller = "#{instance_info} -> #{@caller_info}:"
+
+      # Setup logging
+      setup_logging
+
+      # Setup static event templates
+      setup_event_templates
+    end
+
+    def execute(_prompt, _options = {})
+      raise NotImplementedError, "Subclasses must implement the execute method"
+    end
+
+    def reset_session
+      @session_id = nil
+      @last_response = nil
+    end
+
+    def has_session?
+      !@session_id.nil?
+    end
+
+    protected
+
+    def build_info(name, id)
+      return name unless id
+
+      "#{name} (#{id})"
+    end
+
+    def setup_logging
+      # Use session path from environment (required)
+      @session_path = SessionPath.from_env
+      SessionPath.ensure_directory(@session_path)
+
+      # Initialize session JSON path
+      @session_json_path = File.join(@session_path, "session.log.json")
+
+      # Create logger with session.log filename
+      log_filename = "session.log"
+      log_path = File.join(@session_path, log_filename)
+      log_level = @debug ? :debug : :info
+      @logger = Logger.new(log_path, level: log_level, progname: @instance_name)
+
+      logger.info { "Started #{self.class.name} for instance: #{instance_info}" }
+    end
+
+    def setup_event_templates
+      @log_request_event_template = {
+        type: "request",
+        from_instance: @calling_instance,
+        from_instance_id: @calling_instance_id,
+        to_instance: @instance_name,
+        to_instance_id: @instance_id,
+      }.freeze
+
+      @session_json_entry_template = {
+        instance: @instance_name,
+        instance_id: @instance_id,
+        calling_instance: @calling_instance,
+        calling_instance_id: @calling_instance_id,
+      }.freeze
+    end
+
+    def log_request(prompt)
+      logger.info { "#{@caller_to_instance} \n---\n#{prompt}\n---" }
+
+      # Merge dynamic data with static template
+      event = @log_request_event_template.merge(
+        prompt: prompt,
+        timestamp: Time.now.iso8601,
+      )
+
+      append_to_session_json(event)
+    end
+
+    def log_response(response)
+      logger.info do
+        "($#{response["total_cost"]} - #{response["duration_ms"]}ms) #{@instance_to_caller} \n---\n#{response["result"]}\n---"
+      end
+    end
+
+    def append_to_session_json(event)
+      # Use file locking to ensure thread-safe writes
+      File.open(@session_json_path, File::WRONLY | File::APPEND | File::CREAT) do |file|
+        file.flock(File::LOCK_EX)
+
+        # Merge dynamic data with static template
+        entry = @session_json_entry_template.merge(
+          timestamp: Time.now.iso8601,
+          event: event,
+        )
+
+        # Write as single line JSON (JSONL format)
+        file.puts(entry.to_json)
+
+        file.flock(File::LOCK_UN)
+      end
+    rescue StandardError => e
+      logger.error { "Failed to append to session JSON: #{e.message}" }
+      raise
+    end
+
+    class ExecutionError < StandardError; end
+    class ParseError < StandardError; end
+  end
+end

data/lib/claude_swarm/claude_code_executor.rb

@@ -1,28 +1,7 @@
 # frozen_string_literal: true
 
 module ClaudeSwarm
-  class ClaudeCodeExecutor
-    attr_reader :session_id, :last_response, :working_directory, :logger, :session_path
-
-    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: [])
-      @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
-
-      # Setup logging
-      setup_logging
-    end
-
+  class ClaudeCodeExecutor < BaseExecutor
     def execute(prompt, options = {})
       # Log the request
       log_request(prompt)
@@ -75,8 +54,8 @@ module ClaudeSwarm
           end
         end
       rescue StandardError => e
-        @logger.error("Execution error for #{@instance_name}: #{e.class} - #{e.message}")
-        @logger.error("Backtrace: #{e.backtrace.join("\n")}")
+        logger.error { "Execution error for #{@instance_name}: #{e.class} - #{e.message}" }
+        logger.error { "Backtrace: #{e.backtrace.join("\n")}" }
         raise ExecutionError, "Claude Code execution failed: #{e.message}"
       end
 
@@ -90,20 +69,11 @@ module ClaudeSwarm
 
       result_response
     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
-    end
-
-    def has_session?
-      !@session_id.nil?
-    end
-
     private
 
     def write_instance_state
@@ -122,63 +92,9 @@ module ClaudeSwarm
       }
 
       File.write(state_file, JSON.pretty_generate(state_data))
-      @logger.info("Wrote instance state for #{@instance_name} (#{@instance_id}) with session ID: #{@session_id}")
+      logger.info { "Wrote instance state for #{@instance_name} (#{@instance_id}) with session ID: #{@session_id}" }
     rescue StandardError => e
-      @logger.error("Failed to write instance state for #{@instance_name} (#{@instance_id}): #{e.message}")
-    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
-
-      # 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"
-      end
-
-      return unless @instance_name
-
-      instance_info = @instance_name
-      instance_info += " (#{@instance_id})" if @instance_id
-      @logger.info("Started Claude Code 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)
-    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---",
-      )
+      logger.error { "Failed to write instance state for #{@instance_name} (#{@instance_id}): #{e.message}" }
     end
 
     def log_streaming_event(event)
@@ -198,13 +114,13 @@ module ClaudeSwarm
     end
 
     def log_system_message(event)
-      @logger.debug("SYSTEM: #{JSON.pretty_generate(event)}")
+      logger.debug { "SYSTEM: #{JSON.pretty_generate(event)}" }
     end
 
     def log_assistant_message(msg)
       # Assistant messages don't have stop_reason in SDK - they only have content
       content = msg["content"]
-      @logger.debug("ASSISTANT: #{JSON.pretty_generate(content)}") if content
+      logger.debug { "ASSISTANT: #{JSON.pretty_generate(content)}" } if content
 
       # Log tool calls
       tool_calls = content&.select { |c| c["type"] == "tool_use" } || []
@@ -212,52 +128,20 @@ module ClaudeSwarm
         arguments = tool_call["input"].to_json
         arguments = "#{arguments[0..300]} ...}" if arguments.length > 300
 
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info(
-          "Tool call from #{instance_info} -> Tool: #{tool_call["name"]}, ID: #{tool_call["id"]}, Arguments: #{arguments}",
-        )
+        logger.info do
+          "Tool call from #{instance_info} -> Tool: #{tool_call["name"]}, ID: #{tool_call["id"]}, Arguments: #{arguments}"
+        end
       end
 
       # Log thinking text
       text = content&.select { |c| c["type"] == "text" } || []
       text.each do |t|
-        instance_info = @instance_name
-        instance_info += " (#{@instance_id})" if @instance_id
-        @logger.info("#{instance_info} is thinking:\n---\n#{t["text"]}\n---")
+        logger.info { "#{instance_info} is thinking:\n---\n#{t["text"]}\n---" }
       end
     end
 
     def log_user_message(content)
-      @logger.debug("USER: #{JSON.pretty_generate(content)}")
-    end
-
-    def append_to_session_json(event)
-      json_filename = "session.log.json"
-      json_path = File.join(@session_path, json_filename)
-
-      # 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)
-
-        # 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,
-        }
-
-        # Write as single line JSON (JSONL format)
-        file.puts(entry.to_json)
-
-        file.flock(File::LOCK_UN)
-      end
-    rescue StandardError => e
-      @logger.error("Failed to append to session JSON: #{e.message}")
-      raise
+      logger.debug { "USER: #{JSON.pretty_generate(content)}" }
     end
 
     def build_sdk_options(prompt, options)
@@ -265,7 +149,8 @@ module ClaudeSwarm
       sdk_options = ClaudeSDK::ClaudeCodeOptions.new
 
       # Basic options
-      sdk_options.model = @model if @model
+      # Only set model if ANTHROPIC_MODEL env var is not set
+      sdk_options.model = @model if @model && !ENV["ANTHROPIC_MODEL"]
       sdk_options.cwd = @working_directory
       sdk_options.resume = @session_id if @session_id && !options[:new_session]
 
@@ -328,14 +213,14 @@ module ClaudeSwarm
             headers: server_config["headers"] || {},
           )
         else
-          @logger.warn("Unsupported MCP server type: #{server_type} for server: #{name}")
+          logger.warn { "Unsupported MCP server type: #{server_type} for server: #{name}" }
           nil
         end
       end
 
       mcp_servers.compact
     rescue StandardError => e
-      @logger.error("Failed to parse MCP config: #{e.message}")
+      logger.error { "Failed to parse MCP config: #{e.message}" }
       {}
     end
 
@@ -346,7 +231,7 @@ module ClaudeSwarm
       @additional_directories.each do |dir|
         # This is a placeholder - the SDK doesn't directly support file system servers
         # You would need to implement a proper MCP server that provides file access
-        @logger.warn("Additional directories not fully supported: #{dir}")
+        logger.warn { "Additional directories not fully supported: #{dir}" }
       end
     end
 
@@ -451,8 +336,5 @@ module ClaudeSwarm
         end
       end
     end
-
-    class ExecutionError < StandardError; end
-    class ParseError < StandardError; end
   end
 end

data/lib/claude_swarm/claude_mcp_server.rb

@@ -7,7 +7,7 @@ module ClaudeSwarm
       attr_accessor :executor, :instance_config, :logger, :session_path, :calling_instance, :calling_instance_id
     end
 
-    def initialize(instance_config, calling_instance:, calling_instance_id: nil)
+    def initialize(instance_config, calling_instance:, calling_instance_id: nil, debug: false)
       @instance_config = instance_config
       @calling_instance = calling_instance
       @calling_instance_id = calling_instance_id
@@ -24,6 +24,7 @@ module ClaudeSwarm
         calling_instance_id: calling_instance_id,
         claude_session_id: instance_config[:claude_session_id],
         additional_directories: instance_config[:directories][1..] || [],
+        debug: debug,
       }
 
       @executor = if instance_config[:provider] == "openai"

data/lib/claude_swarm/cli.rb

@@ -230,6 +230,7 @@ module ClaudeSwarm
           instance_config,
           calling_instance: options[:calling_instance],
           calling_instance_id: options[:calling_instance_id],
+          debug: options[:debug],
         )
         server.start
       rescue StandardError => e

data/lib/claude_swarm/mcp_generator.rb

@@ -90,7 +90,9 @@ module ClaudeSwarm
         {
           "type" => "sse",
           "url" => mcp["url"],
-        }
+        }.tap do |config|
+          config["headers"] = mcp["headers"] if mcp["headers"]
+        end
       end
     end
 

data/lib/claude_swarm/openai/chat_completion.rb

@@ -5,11 +5,11 @@ module ClaudeSwarm
     class ChatCompletion
       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
@@ -57,7 +57,7 @@ module ClaudeSwarm
       def process_chat_completion(messages, 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
 
@@ -83,7 +83,7 @@ module ClaudeSwarm
         parameters[:tools] = @mcp_client.to_openai_tools if @available_tools&.any? && @mcp_client
 
         # Log the request parameters
-        @executor.info("Chat API Request (depth=#{depth}): #{JSON.pretty_generate(parameters)}")
+        @executor.logger.info { "Chat API Request (depth=#{depth}): #{JSON.pretty_generate(parameters)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -97,16 +97,16 @@ module ClaudeSwarm
         begin
           response = @openai_client.chat(parameters: parameters)
         rescue StandardError => e
-          @executor.error("Chat API error: #{e.class} - #{e.message}")
-          @executor.error("Request parameters: #{JSON.pretty_generate(parameters)}")
+          @executor.logger.error { "Chat API error: #{e.class} - #{e.message}" }
+          @executor.logger.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}")
+              @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
 
@@ -127,7 +127,7 @@ module ClaudeSwarm
         end
 
         # Log the response
-        @executor.info("Chat API Response (depth=#{depth}): #{JSON.pretty_generate(response)}")
+        @executor.logger.info { "Chat API Response (depth=#{depth}): #{JSON.pretty_generate(response)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -141,7 +141,7 @@ module ClaudeSwarm
         message = response.dig("choices", 0, "message")
 
         if message.nil?
-          @executor.error("No message in response: #{response.inspect}")
+          @executor.logger.error { "No message in response: #{response.inspect}" }
           return "Error: No response from OpenAI"
         end
 
@@ -169,7 +169,7 @@ module ClaudeSwarm
 
       def execute_and_append_tool_results(tool_calls, messages)
         # Log tool calls
-        @executor.info("Executing tool calls: #{JSON.pretty_generate(tool_calls)}")
+        @executor.logger.info { "Executing tool calls: #{JSON.pretty_generate(tool_calls)}" }
 
         # Append to session JSON
         append_to_session_json({
@@ -189,13 +189,13 @@ module ClaudeSwarm
               tool_args = tool_args_str.is_a?(String) ? JSON.parse(tool_args_str) : tool_args_str
 
               # Log tool execution
-              @executor.info("Executing tool: #{tool_name} with args: #{JSON.pretty_generate(tool_args)}")
+              @executor.logger.info { "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("Tool result for #{tool_name}: #{result}")
+              @executor.logger.info { "Tool result for #{tool_name}: #{result}" }
 
               # Append to session JSON
               append_to_session_json({
@@ -214,8 +214,8 @@ module ClaudeSwarm
                 content: result.to_s,
               }
             rescue StandardError => e
-              @executor.error("Tool execution failed for #{tool_name}: #{e.message}")
-              @executor.error(e.backtrace.join("\n"))
+              @executor.logger.error { "Tool execution failed for #{tool_name}: #{e.message}" }
+              @executor.logger.error { e.backtrace.join("\n") }
 
               # Append error to session JSON
               append_to_session_json({