swarm_memory 2.1.5 → 2.1.6

data/lib/claude_swarm/mcp_generator.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-
-module ClaudeSwarm
-  class McpGenerator
-    CLAUDE_MCP_SERVER_CONFIG = {
-      "type" => "stdio",
-      "command" => "claude",
-      "args" => ["mcp", "serve"],
-    }.freeze
-
-    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"] = CLAUDE_MCP_SERVER_CONFIG.dup 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_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]
-          args.push("--zdr", instance[:zdr].to_s) if instance.key?(:zdr)
-        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 running claude-swarm
-      # We intentionally exclude Bundler variables to ensure we use the system-installed gem
-      required_env = {}
-
-      # Claude Swarm-specific variables (always needed)
-      ENV.each do |k, v|
-        required_env[k] = v if k.start_with?("CLAUDE_SWARM_")
-      end
-
-      # Ruby-specific variables that MCP servers need
-      # Exclude RUBYOPT and RUBYLIB to avoid Bundler interference
-      [
-        "RUBY_ROOT",
-        "RUBY_ENGINE",
-        "RUBY_VERSION",
-        "GEM_ROOT",
-        "GEM_HOME",
-        "GEM_PATH",
-        "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

@@ -1,256 +0,0 @@
-# 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, zdr: false)
-        @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
-        @zdr = zdr # Not used in chat_completion API, but kept for compatibility
-        @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,
-        }
-
-        parameters[:temperature] = @temperature if @temperature
-        parameters[:reasoning_effort] = @reasoning_effort if @reasoning_effort
-
-        # 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