swarm_memory 2.0.0

data/lib/claude_swarm/mcp_generator.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  class McpGenerator
+    def initialize(configuration, vibe: false, restore_session_path: nil)
+      @config = configuration
+      @vibe = vibe
+      @restore_session_path = restore_session_path
+      @session_path = nil # Will be set when needed
+      @instance_ids = {} # Store instance IDs for all instances
+      @restore_states = {} # Store loaded state data during restoration
+    end
+
+    def generate_all
+      ensure_swarm_directory
+
+      if @restore_session_path
+        # Load existing instance IDs and states from state files
+        load_instance_states
+      else
+        # Generate new instance IDs
+        @config.instances.each_key do |name|
+          @instance_ids[name] = "#{name}_#{SecureRandom.hex(4)}"
+        end
+      end
+
+      @config.instances.each do |name, instance|
+        generate_mcp_config(name, instance)
+      end
+    end
+
+    def mcp_config_path(instance_name)
+      File.join(session_path, "#{instance_name}.mcp.json")
+    end
+
+    private
+
+    def session_path
+      @session_path ||= SessionPath.from_env
+    end
+
+    def ensure_swarm_directory
+      # Session directory is already created by orchestrator
+      # Just ensure it exists
+      SessionPath.ensure_directory(session_path)
+    end
+
+    def generate_mcp_config(name, instance)
+      mcp_servers = {}
+
+      # Add configured MCP servers
+      instance[:mcps].each do |mcp|
+        mcp_servers[mcp["name"]] = build_mcp_server_config(mcp)
+      end
+
+      # Add connection MCPs for other instances
+      instance[:connections].each do |connection_name|
+        connected_instance = @config.instances[connection_name]
+        mcp_servers[connection_name] = build_instance_mcp_config(
+          connection_name,
+          connected_instance,
+          calling_instance: name,
+          calling_instance_id: @instance_ids[name],
+        )
+      end
+
+      # Add Claude tools MCP server for OpenAI instances
+      mcp_servers["claude_tools"] = build_claude_tools_mcp_config if instance[:provider] == "openai"
+
+      config = {
+        "instance_id" => @instance_ids[name],
+        "instance_name" => name,
+        "mcpServers" => mcp_servers,
+      }
+
+      JsonHandler.write_file!(mcp_config_path(name), config)
+    end
+
+    def build_mcp_server_config(mcp)
+      case mcp["type"]
+      when "stdio"
+        {
+          "type" => "stdio",
+          "command" => mcp["command"],
+          "args" => mcp["args"] || [],
+        }.tap do |config|
+          config["env"] = mcp["env"] if mcp["env"]
+        end
+      when "sse", "http"
+        {
+          "type" => mcp["type"],
+          "url" => mcp["url"],
+        }.tap do |config|
+          config["headers"] = mcp["headers"] if mcp["headers"]
+        end
+      end
+    end
+
+    def build_claude_tools_mcp_config
+      # Build environment for claude mcp serve by excluding Ruby/Bundler-specific variables
+      # This preserves all system variables while removing Ruby contamination
+      clean_env = ENV.to_h.reject do |key, _|
+        key.start_with?("BUNDLE_") ||
+          key.start_with?("RUBY") ||
+          key.start_with?("GEM_") ||
+          key == "RUBYOPT" ||
+          key == "RUBYLIB"
+      end
+
+      {
+        "type" => "stdio",
+        "command" => "claude",
+        "args" => ["mcp", "serve"],
+        "env" => clean_env,
+      }
+    end
+
+    def build_instance_mcp_config(name, instance, calling_instance:, calling_instance_id:)
+      # Get the path to the claude-swarm executable
+      exe_path = "claude-swarm"
+
+      # Build command-line arguments for Thor
+      args = [
+        "mcp-serve",
+        "--name",
+        name,
+        "--directory",
+        instance[:directory],
+        "--model",
+        instance[:model],
+      ]
+
+      # Add directories array if we have multiple directories
+      args.push("--directories", *instance[:directories]) if instance[:directories] && instance[:directories].size > 1
+
+      # Add optional arguments
+      # Handle prompt_file by reading the file contents
+      if instance[:prompt_file]
+        prompt_file_path = File.join(@config.root_directory, instance[:prompt_file])
+        if File.exist?(prompt_file_path)
+          prompt_content = File.read(prompt_file_path)
+          args.push("--prompt", prompt_content)
+        end
+      elsif instance[:prompt]
+        args.push("--prompt", instance[:prompt])
+      end
+
+      args.push("--description", instance[:description]) if instance[:description]
+
+      args.push("--allowed-tools", instance[:allowed_tools].join(",")) if instance[:allowed_tools] && !instance[:allowed_tools].empty?
+
+      args.push("--disallowed-tools", instance[:disallowed_tools].join(",")) if instance[:disallowed_tools] && !instance[:disallowed_tools].empty?
+
+      args.push("--connections", instance[:connections].join(",")) if instance[:connections] && !instance[:connections].empty?
+
+      args.push("--mcp-config-path", mcp_config_path(name))
+
+      args.push("--calling-instance", calling_instance) if calling_instance
+
+      args.push("--calling-instance-id", calling_instance_id) if calling_instance_id
+
+      args.push("--instance-id", @instance_ids[name]) if @instance_ids[name]
+
+      args.push("--vibe") if @vibe || instance[:vibe]
+
+      # Add provider-specific parameters
+      if instance[:provider]
+        args.push("--provider", instance[:provider])
+
+        # Add OpenAI-specific parameters
+        if instance[:provider] == "openai"
+          args.push("--reasoning-effort", instance[:reasoning_effort]) if instance[:reasoning_effort]
+          args.push("--temperature", instance[:temperature].to_s) if instance[:temperature]
+          args.push("--api-version", instance[:api_version]) if instance[:api_version]
+          args.push("--openai-token-env", instance[:openai_token_env]) if instance[:openai_token_env]
+          args.push("--base-url", instance[:base_url]) if instance[:base_url]
+        end
+      end
+
+      # Add claude session ID if restoring
+      if @restore_states[name.to_s]
+        claude_session_id = @restore_states[name.to_s]["claude_session_id"]
+        args.push("--claude-session-id", claude_session_id) if claude_session_id
+      end
+
+      # Capture environment variables needed for Ruby and Bundler to work properly
+      # This includes both BUNDLE_* variables and Ruby-specific variables
+      required_env = {}
+
+      # Bundle-specific variables
+      ENV.each do |k, v|
+        required_env[k] = v if k.start_with?("BUNDLE_")
+      end
+
+      # Claude Swarm-specific variables
+      ENV.each do |k, v|
+        required_env[k] = v if k.start_with?("CLAUDE_SWARM_")
+      end
+
+      # Ruby-specific variables that MCP servers need
+      [
+        "RUBY_ROOT",
+        "RUBY_ENGINE",
+        "RUBY_VERSION",
+        "GEM_ROOT",
+        "GEM_HOME",
+        "GEM_PATH",
+        "RUBYOPT",
+        "RUBYLIB",
+        "PATH",
+      ].each do |key|
+        required_env[key] = ENV[key] if ENV[key]
+      end
+
+      config = {
+        "type" => "stdio",
+        "command" => exe_path,
+        "args" => args,
+      }
+
+      # Add required environment variables if any exist
+      config["env"] = required_env unless required_env.empty?
+
+      config
+    end
+
+    def load_instance_states
+      state_dir = File.join(@restore_session_path, "state")
+      return unless Dir.exist?(state_dir)
+
+      Dir.glob(File.join(state_dir, "*.json")).each do |state_file|
+        data = JsonHandler.parse_file!(state_file)
+        instance_name = data["instance_name"]
+        instance_id = data["instance_id"]
+
+        # Check both string and symbol keys since config instances might have either
+        if instance_name && (@config.instances.key?(instance_name) || @config.instances.key?(instance_name.to_sym))
+          # Store with the same key type as in @config.instances
+          key = @config.instances.key?(instance_name) ? instance_name : instance_name.to_sym
+          @instance_ids[key] = instance_id
+          @restore_states[instance_name] = data
+        end
+      rescue StandardError
+        # Skip invalid state files
+      end
+    end
+  end
+end

data/lib/claude_swarm/openai/chat_completion.rb

@@ -0,0 +1,264 @@
+# frozen_string_literal: true
+
+module ClaudeSwarm
+  module OpenAI
+    class ChatCompletion
+      MAX_TURNS_WITH_TOOLS = 100_000 # virtually infinite
+
+      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 = executor
+        @instance_name = instance_name
+        @model = model
+        @temperature = temperature
+        @reasoning_effort = reasoning_effort
+        @conversation_messages = []
+      end
+
+      def execute(prompt, options = {})
+        # Build messages array
+        messages = build_messages(prompt, options)
+
+        # Process chat with recursive tool handling
+        result = process_chat_completion(messages)
+
+        # Update conversation state
+        @conversation_messages = messages
+
+        result
+      end
+
+      def reset_session
+        @conversation_messages = []
+      end
+
+      private
+
+      def build_messages(prompt, options)
+        messages = []
+
+        # Add system prompt if provided
+        system_prompt = options[:system_prompt]
+        if system_prompt && @conversation_messages.empty?
+          messages << { role: "system", content: system_prompt }
+        elsif !@conversation_messages.empty?
+          # Use existing conversation
+          messages = @conversation_messages.dup
+        end
+
+        # Add user message
+        messages << { role: "user", content: prompt }
+
+        messages
+      end
+
+      def process_chat_completion(messages, depth = 0)
+        # Prevent infinite recursion
+        if depth > MAX_TURNS_WITH_TOOLS
+          @executor.logger.error { "Maximum recursion depth reached in tool execution" }
+          return "Error: Maximum tool call depth exceeded"
+        end
+
+        # Build parameters
+        parameters = {
+          model: @model,
+          messages: messages,
+        }
+
+        # Only add temperature for non-o-series models
+        # O-series models don't support temperature parameter
+        if @temperature && !@model.match?(ClaudeSwarm::Configuration::O_SERIES_MODEL_PATTERN)
+          parameters[:temperature] = @temperature
+        end
+
+        # Only add reasoning_effort for o-series models
+        # reasoning_effort 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
+
+        # Add tools if available
+        parameters[:tools] = @mcp_client.to_openai_tools if @available_tools&.any? && @mcp_client
+
+        # Log the request parameters
+        @executor.logger.info { "Chat API Request (depth=#{depth}): #{JsonHandler.pretty_generate!(parameters)}" }
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "openai_request",
+          api: "chat",
+          depth: depth,
+          parameters: parameters,
+        })
+
+        # Make the API call without streaming
+        begin
+          response = @openai_client.chat(parameters: parameters)
+        rescue StandardError => e
+          @executor.logger.error { "Chat 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.logger.error { "Error response body: #{error_body}" }
+            rescue StandardError => parse_error
+              @executor.logger.error { "Could not parse error response: #{parse_error.message}" }
+            end
+          end
+
+          # Log error to session JSON
+          append_to_session_json({
+            type: "openai_error",
+            api: "chat",
+            depth: depth,
+            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 chat API: #{e.message}"
+        end
+
+        # Log the response
+        @executor.logger.info { "Chat API Response (depth=#{depth}): #{JsonHandler.pretty_generate!(response)}" }
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "openai_response",
+          api: "chat",
+          depth: depth,
+          response: response,
+        })
+
+        # Extract the message from the response
+        message = response.dig("choices", 0, "message")
+
+        if message.nil?
+          @executor.logger.error { "No message in response: #{response.inspect}" }
+          return "Error: No response from OpenAI"
+        end
+
+        # Check if there are tool calls
+        if message["tool_calls"]
+          # Add the assistant message with tool calls
+          messages << {
+            role: "assistant",
+            content: nil,
+            tool_calls: message["tool_calls"],
+          }
+
+          # Execute tools and collect results
+          execute_and_append_tool_results(message["tool_calls"], messages)
+
+          # Recursively process the next response
+          process_chat_completion(messages, depth + 1)
+        else
+          # Regular text response - this is the final response
+          response_text = message["content"] || ""
+          messages << { role: "assistant", content: response_text }
+          response_text
+        end
+      end
+
+      def execute_and_append_tool_results(tool_calls, messages)
+        # Log tool calls
+        @executor.logger.info { "Executing tool calls: #{JsonHandler.pretty_generate!(tool_calls)}" }
+
+        # Append to session JSON
+        append_to_session_json({
+          type: "tool_calls",
+          api: "chat",
+          tool_calls: tool_calls,
+        })
+
+        # Execute tool calls in parallel threads
+        threads = tool_calls.map do |tool_call|
+          Thread.new do
+            tool_name = tool_call.dig("function", "name")
+            tool_args_str = tool_call.dig("function", "arguments")
+
+            begin
+              # Parse arguments
+              tool_args = tool_args_str.is_a?(String) ? JsonHandler.parse!(tool_args_str) : tool_args_str
+
+              # Log tool execution
+              @executor.logger.info { "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.logger.info { "Tool result for #{tool_name}: #{result}" }
+
+              # Append to session JSON
+              append_to_session_json({
+                type: "tool_execution",
+                tool_name: tool_name,
+                arguments: tool_args,
+                result: result.to_s,
+              })
+
+              # Return success result
+              {
+                success: true,
+                tool_call_id: tool_call["id"],
+                role: "tool",
+                name: tool_name,
+                content: result.to_s,
+              }
+            rescue StandardError => e
+              @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({
+                type: "tool_error",
+                tool_name: tool_name,
+                arguments: tool_args,
+                error: {
+                  class: e.class.to_s,
+                  message: e.message,
+                  backtrace: e.backtrace.first(5),
+                },
+              })
+
+              # Return error result
+              {
+                success: false,
+                tool_call_id: tool_call["id"],
+                role: "tool",
+                name: tool_name,
+                content: "Error: #{e.message}",
+              }
+            end
+          end
+        end
+
+        # Collect results from all threads
+        tool_results = threads.map(&:value)
+
+        # Add all tool results to messages
+        tool_results.each do |result|
+          messages << {
+            tool_call_id: result[:tool_call_id],
+            role: result[:role],
+            name: result[:name],
+            content: result[:content],
+          }
+        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