rubycode 0.1.3 → 0.1.4

data/lib/rubycode/adapters/ollama.rb

@@ -5,49 +5,49 @@ require "json"
 
 module RubyCode
   module Adapters
-    # Ollama adapter for local LLM integration
+    # Ollama adapter for cloud LLM integration
     class Ollama < Base
+      def initialize(config)
+        super
+        validate_api_key!
+      end
+
       def generate(messages:, system: nil, tools: nil)
-        uri = URI("#{@config.url}/api/chat")
+        enforce_rate_limit_delay
+
+        uri = build_uri
         payload = build_payload(messages, system, tools)
         request = build_request(uri, payload)
 
-        debug_request(uri, payload) if @config.debug
-
         body = send_request_with_retry(uri, request)
 
-        debug_response(body) if @config.debug
+        @last_request_time = Time.now
+
+        # Extract and track tokens
+        @current_request_tokens = extract_tokens(body)
+        @total_tokens_counter += @current_request_tokens
 
         body
+      rescue AdapterError => e
+        # If model doesn't support tools, provide helpful error message
+        raise AdapterError, build_tools_error_message if tools && e.message.include?("does not support tools")
+
+        raise e
       end
 
       private
 
-      def send_request_with_retry(uri, request)
-        attempt = 0
-
-        begin
-          attempt += 1
-          send_request(uri, request)
-        rescue AdapterTimeoutError, AdapterConnectionError => e
-          unless attempt <= @config.max_retries
-            raise AdapterRetryExhaustedError, "Failed after #{@config.max_retries} retries: #{e.message}"
-          end
-
-          delay = @config.retry_base_delay * (2**(attempt - 1))
-          display_retry_status(attempt, @config.max_retries, delay, e)
-          sleep(delay)
-          retry
-        end
+      def adapter_name
+        "Ollama"
       end
 
-      def display_retry_status(attempt, max_retries, delay, error)
-        puts Views::AgentLoop::RetryStatus.build(
-          attempt: attempt,
-          max_retries: max_retries,
-          delay: delay,
-          error: error.message
-        )
+      def api_endpoint
+        # Not used - Ollama uses build_uri override
+        "#{@config.url}/api/chat"
+      end
+
+      def build_uri
+        URI("#{@config.url}/api/chat")
       end
 
       def build_payload(messages, system, tools)
@@ -60,78 +60,110 @@ module RubyCode
       def build_request(uri, payload)
         request = Net::HTTP::Post.new(uri)
         request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{api_key}"
         request.body = payload.to_json
         request
       end
 
+      def convert_response(_raw_response)
+        # Ollama returns the body directly in the right format
+        # No conversion needed
+        raise NotImplementedError, "Ollama doesn't use convert_response"
+      end
+
       def send_request(uri, request)
         response = perform_http_request(uri, request)
-        handle_response(response)
+        body = handle_response(response)
+
+        # Parse tool calls from content for models that use XML format (like Qwen)
+        parse_tool_calls_from_content(body) if body["message"]
+
+        body
       rescue Net::ReadTimeout, Net::OpenTimeout, Errno::ECONNREFUSED, Errno::ETIMEDOUT, SocketError => e
         handle_network_error(e, uri)
       rescue JSON::ParserError => e
-        raise AdapterError, "Invalid JSON response from server: #{e.message}"
+        raise AdapterError, I18n.t("rubycode.errors.adapter.invalid_json", error: e.message)
       rescue StandardError => e
-        raise AdapterError, "Unexpected error: #{e.message}"
-      end
-
-      def perform_http_request(uri, request)
-        Net::HTTP.start(
-          uri.hostname,
-          uri.port,
-          read_timeout: @config.http_read_timeout,
-          open_timeout: @config.http_open_timeout
-        ) { |http| http.request(request) }
-      end
-
-      def handle_network_error(error, uri)
-        case error
-        when Net::ReadTimeout
-          raise AdapterTimeoutError, "Request timed out after #{@config.http_read_timeout}s: #{error.message}"
-        when Net::OpenTimeout
-          raise AdapterTimeoutError, "Connection timed out after #{@config.http_open_timeout}s: #{error.message}"
-        when Errno::ECONNREFUSED
-          raise AdapterConnectionError, "Connection refused to #{uri}: #{error.message}"
-        when Errno::ETIMEDOUT
-          raise AdapterConnectionError, "Connection timed out to #{uri}: #{error.message}"
-        when SocketError
-          raise AdapterConnectionError, "Cannot resolve host #{uri.hostname}: #{error.message}"
-        end
+        raise AdapterError, I18n.t("rubycode.errors.adapter.unexpected_error", error: e.message)
+      end
+
+      def build_tools_error_message
+        I18n.t("rubycode.errors.tools_not_supported", model: @config.model)
       end
 
-      def handle_response(response)
-        body = JSON.parse(response.body)
+      # Parse <tool_call> XML tags or plain JSON from message content
+      # Some models (like Qwen) return tool calls as XML or JSON in content instead of structured format
+      def parse_tool_calls_from_content(body)
+        message = body["message"]
+        content = message["content"] || ""
 
-        # Check for HTTP errors
-        case response.code.to_i
-        when 200..299
-          body
-        when 500..599
-          # Server errors are retriable
-          raise AdapterConnectionError, "Server error (#{response.code}): #{response.message}"
-        else
-          # Client errors are not retriable
-          raise AdapterError, "HTTP error (#{response.code}): #{response.message}"
+        return if content.empty?
+
+        tool_calls, clean_content = extract_tool_calls_and_content(content)
+
+        # Update message with parsed tool calls and cleaned content
+        return unless tool_calls.any?
+
+        message["tool_calls"] = tool_calls
+        message["content"] = clean_content
+      end
+
+      def extract_tool_calls_and_content(content)
+        # Try XML-wrapped tool calls first
+        xml_result = parse_xml_tool_calls(content)
+        return xml_result if xml_result[0].any?
+
+        # Try plain JSON tool call
+        json_result = parse_json_tool_call(content)
+        return json_result if json_result[0].any?
+
+        [[], content]
+      end
+
+      def parse_xml_tool_calls(content)
+        return [[], content] unless content.include?("<tool_call>")
+
+        tool_calls = []
+        content.scan(%r{<tool_call>(.*?)</tool_call>}m) do |match|
+          tool_call_json = match[0].strip
+          tool_data = parse_tool_json(tool_call_json)
+          tool_calls << convert_to_openai_format(tool_data) if tool_data
         end
+
+        clean_content = tool_calls.any? ? content.gsub(%r{<tool_call>.*?</tool_call>}m, "").strip : content
+        [tool_calls, clean_content]
       end
 
-      def debug_request(uri, payload)
-        puts "\n#{"=" * 80}"
-        puts "📤 REQUEST TO LLM"
-        puts "=" * 80
-        puts "URL: #{uri}"
-        puts "Model: #{@config.model}"
-        puts "\nPayload:"
-        puts JSON.pretty_generate(payload)
-        puts "=" * 80
+      def parse_json_tool_call(content)
+        return [[], content] unless content.strip.start_with?("{")
+
+        tool_data = parse_tool_json(content)
+        return [[], content] unless tool_data
+
+        [[convert_to_openai_format(tool_data)], ""]
       end
 
-      def debug_response(body)
-        puts "\n#{"=" * 80}"
-        puts "📥 RESPONSE FROM LLM"
-        puts "=" * 80
-        puts JSON.pretty_generate(body)
-        puts "#{"=" * 80}\n"
+      def parse_tool_json(json_string)
+        JSON.parse(json_string)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def convert_to_openai_format(tool_data)
+        {
+          "function" => {
+            "name" => tool_data["name"],
+            "arguments" => tool_data["arguments"]
+          }
+        }
+      end
+
+      def extract_tokens(response_body)
+        # Ollama returns tokens in different format
+        TokenCounter.new(
+          input: response_body["prompt_eval_count"],
+          output: response_body["eval_count"]
+        )
       end
     end
   end

data/lib/rubycode/adapters/openai.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module RubyCode
+  module Adapters
+    # OpenAI adapter for cloud LLM integration
+    # OpenAI provides industry-leading models including GPT-4o
+    class Openai < Base
+      API_ENDPOINT = "https://api.openai.com/v1/chat/completions"
+
+      def initialize(config)
+        super
+        validate_api_key!
+      end
+
+      private
+
+      def adapter_name
+        "OpenAI"
+      end
+
+      def api_endpoint
+        API_ENDPOINT
+      end
+
+      def build_payload(messages, system, tools)
+        # OpenAI format: system message goes in messages array
+        formatted_messages = messages.dup
+
+        formatted_messages.unshift({ role: "system", content: system }) if system
+
+        payload = {
+          model: @config.model,
+          messages: formatted_messages,
+          temperature: 0.7
+        }
+
+        # OpenAI supports function calling format
+        payload[:tools] = tools if tools
+
+        payload
+      end
+
+      def build_request(uri, payload)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{api_key}"
+        request.body = payload.to_json
+        request
+      end
+
+      def convert_response(openai_response)
+        # OpenAI format: { choices: [{ message: { role, content, tool_calls } }] }
+        # Our format: { "message" => { "content" => ..., "tool_calls" => [...] } }
+
+        choice = openai_response["choices"]&.first
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_choices") unless choice
+
+        message = choice["message"]
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_message") unless message
+
+        {
+          "message" => {
+            "content" => message["content"] || "",
+            "tool_calls" => format_tool_calls(message["tool_calls"])
+          }
+        }
+      end
+
+      def format_tool_calls(openai_tool_calls)
+        return [] unless openai_tool_calls
+
+        openai_tool_calls.map do |tool_call|
+          {
+            "function" => {
+              "name" => tool_call.dig("function", "name"),
+              "arguments" => tool_call.dig("function", "arguments")
+            }
+          }
+        end
+      end
+
+      def extract_tokens(response_body)
+        usage = response_body["usage"] || {}
+
+        TokenCounter.new(
+          input: usage["prompt_tokens"],
+          output: usage["completion_tokens"],
+          cached: usage.dig("prompt_tokens_details", "cached_tokens"),
+          thinking: usage.dig("completion_tokens_details", "reasoning_tokens")
+        )
+      end
+    end
+  end
+end

data/lib/rubycode/adapters/openrouter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+
+module RubyCode
+  module Adapters
+    # OpenRouter adapter for cloud LLM integration (OpenAI-compatible API)
+    # Provides access to multiple LLM providers through a unified API
+    class Openrouter < Base
+      API_ENDPOINT = "https://openrouter.ai/api/v1/chat/completions"
+
+      def initialize(config)
+        super
+        validate_api_key!
+      end
+
+      private
+
+      def adapter_name
+        "OpenRouter"
+      end
+
+      def api_endpoint
+        API_ENDPOINT
+      end
+
+      def build_payload(messages, system, tools)
+        # OpenAI-compatible format: system message goes in messages array
+        formatted_messages = messages.dup
+
+        formatted_messages.unshift({ role: "system", content: system }) if system
+
+        payload = {
+          model: @config.model,
+          messages: formatted_messages,
+          temperature: 0.7
+        }
+
+        # OpenRouter supports OpenAI function calling format
+        payload[:tools] = tools if tools
+
+        payload
+      end
+
+      def build_request(uri, payload)
+        request = Net::HTTP::Post.new(uri)
+        request["Content-Type"] = "application/json"
+        request["Authorization"] = "Bearer #{api_key}"
+
+        # Optional but recommended headers for OpenRouter
+        request["HTTP-Referer"] = "https://github.com/jonasmedeiros/rubycode"
+        request["X-Title"] = "RubyCode"
+
+        request.body = payload.to_json
+        request
+      end
+
+      def convert_response(openrouter_response)
+        # OpenRouter uses OpenAI-compatible format
+        # Format: { choices: [{ message: { role, content, tool_calls } }] }
+        # Our format: { "message" => { "content" => ..., "tool_calls" => [...] } }
+
+        choice = openrouter_response["choices"]&.first
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_choices") unless choice
+
+        message = choice["message"]
+        raise AdapterError, I18n.t("rubycode.errors.adapter.no_message") unless message
+
+        {
+          "message" => {
+            "content" => message["content"] || "",
+            "tool_calls" => format_tool_calls(message["tool_calls"])
+          }
+        }
+      end
+
+      def format_tool_calls(tool_calls)
+        return [] unless tool_calls
+
+        tool_calls.map do |tool_call|
+          {
+            "function" => {
+              "name" => tool_call.dig("function", "name"),
+              "arguments" => tool_call.dig("function", "arguments")
+            }
+          }
+        end
+      end
+
+      def extract_tokens(response_body)
+        usage = response_body["usage"] || {}
+
+        TokenCounter.new(
+          input: usage["prompt_tokens"],
+          output: usage["completion_tokens"],
+          cached: usage.dig("prompt_tokens_details", "cached_tokens")
+        )
+      end
+    end
+  end
+end

data/lib/rubycode/agent_loop.rb

@@ -9,6 +9,7 @@ module RubyCode
   class AgentLoop
     MAX_ITERATIONS = 25
     MAX_TOOL_CALLS = 50
+    MAX_CONSECUTIVE_RATE_LIMIT_ERRORS = 3
 
     def initialize(adapter:, memory:, config:, system_prompt:, options: {})
       @adapter = adapter
@@ -20,11 +21,13 @@ module RubyCode
       @response_handler = Client::ResponseHandler.new(memory: @memory, config: @config)
       @display_formatter = Client::DisplayFormatter.new(config: @config)
       @approval_handler = Client::ApprovalHandler.new(tty_prompt: @tty_prompt, config: @config)
+      @consecutive_rate_limit_errors = 0
     end
 
     def run
       iteration = 0
       total_tool_calls = 0
+      @last_response_was_error = false
 
       loop do
         iteration += 1
@@ -33,12 +36,7 @@ module RubyCode
 
         content, tool_calls = llm_response
 
-        if tool_calls.empty?
-          result = @response_handler.handle_empty_tool_calls(content, iteration, total_tool_calls)
-          return result if result
-
-          next # Continue loop for workaround case
-        end
+        next if handle_empty_tool_calls_case(content, tool_calls, iteration, total_tool_calls)
 
         total_tool_calls += tool_calls.length
         return @response_handler.handle_max_tool_calls(content, total_tool_calls) if total_tool_calls > MAX_TOOL_CALLS
@@ -46,31 +44,115 @@ module RubyCode
         done_result = execute_tool_calls(tool_calls, iteration)
         return @response_handler.finalize_response(done_result, iteration, total_tool_calls) if done_result
       end
+    rescue RubyCode::AdapterRetryExhaustedError => e
+      build_retry_exhausted_message(e)
+    end
+
+    def handle_empty_tool_calls_case(content, tool_calls, iteration, total_tool_calls)
+      return false unless tool_calls.empty?
+
+      # Skip empty tool call handling if last response was an adapter error
+      if @last_response_was_error
+        @last_response_was_error = false # Reset flag
+        return true # Continue loop
+      end
+
+      result = @response_handler.handle_empty_tool_calls(content, iteration, total_tool_calls)
+      return result if result
+
+      false
+    end
+
+    def build_retry_exhausted_message(error)
+      "\n❌ Unable to reach LLM server after multiple retries.\n\n" \
+        "Error: #{error.message}\n\n" \
+        "Please check:\n  " \
+        "• Is your LLM server running?\n  " \
+        "• Are you being rate limited? (wait a few minutes)\n  " \
+        "• Is the server URL correct in your config?\n"
     end
 
     private
 
     def llm_response
-      puts Views::AgentLoop::ThinkingStatus.build unless @config.debug
+      puts Views::AgentLoop::ThinkingStatus.build
+
+      response_body = fetch_llm_response
+      display_response_info(response_body)
 
-      messages = @memory.to_llm_format
-      response_body = @adapter.generate(
+      content, tool_calls = extract_message_parts(response_body)
+
+      reset_error_tracking
+      @memory.add_message(role: "assistant", content: content, tool_calls: tool_calls)
+
+      [content, tool_calls]
+    rescue RubyCode::AdapterRetryExhaustedError => e
+      # Stop the agent loop when retries are exhausted
+      handle_retry_exhausted(e)
+      raise e # Re-raise to stop the loop
+    rescue RubyCode::AdapterError => e
+      handle_adapter_error_with_rate_limiting(e)
+      @last_response_was_error = true # Mark as error to skip injection reminder
+      [nil, []] # Return empty to continue loop
+    end
+
+    def fetch_llm_response
+      messages = @memory.to_llm_format(
+        window_size: @config.memory_window,
+        prune_tool_results: @config.prune_tool_results
+      )
+      @adapter.generate(
         messages: messages,
         system: @system_prompt,
         tools: Tools.definitions
       )
+    end
 
-      puts Views::AgentLoop::ResponseReceived.build unless @config.debug
+    def display_response_info(_response_body)
+      puts Views::AgentLoop::ResponseReceived.build
 
+      tokens = @adapter.current_request_tokens
+      cumulative = @adapter.total_tokens_counter
+      puts Views::AgentLoop::TokenSummary.build(
+        tokens: tokens,
+        adapter: @config.adapter,
+        model: @config.model,
+        cumulative: cumulative
+      )
+    end
+
+    def extract_message_parts(response_body)
       assistant_message = response_body["message"]
       content = assistant_message["content"] || ""
       tool_calls = assistant_message["tool_calls"] || []
-
-      @memory.add_message(role: "assistant", content: content)
       [content, tool_calls]
-    rescue AdapterError => e
-      handle_adapter_error(e)
-      [nil, []] # Return empty to continue loop
+    end
+
+    def reset_error_tracking
+      @consecutive_rate_limit_errors = 0
+      @last_response_was_error = false
+    end
+
+    def handle_adapter_error_with_rate_limiting(error)
+      if rate_limit_error?(error)
+        @consecutive_rate_limit_errors += 1
+        if @consecutive_rate_limit_errors >= MAX_CONSECUTIVE_RATE_LIMIT_ERRORS
+          handle_rate_limit_exhausted(error)
+          raise AdapterRetryExhaustedError,
+                "Rate limit exceeded after #{MAX_CONSECUTIVE_RATE_LIMIT_ERRORS} consecutive attempts"
+        end
+      else
+        # Reset counter for non-rate-limit errors
+        @consecutive_rate_limit_errors = 0
+      end
+
+      handle_adapter_error(error)
+    end
+
+    def handle_retry_exhausted(error)
+      error_msg = I18n.t("rubycode.errors.adapter_retry_exhausted", error: error.message)
+      puts Views::AgentLoop::AdapterError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
     end
 
     def handle_adapter_error(error)
@@ -79,8 +161,18 @@ module RubyCode
       @memory.add_message(role: "user", content: error_msg)
     end
 
+    def rate_limit_error?(error)
+      error.message.include?("Rate limited") || error.message.include?("429")
+    end
+
+    def handle_rate_limit_exhausted(_error)
+      error_msg = I18n.t("rubycode.errors.rate_limit_exhausted", max_attempts: MAX_CONSECUTIVE_RATE_LIMIT_ERRORS)
+      puts Views::AgentLoop::AdapterError.build(message: error_msg)
+      @memory.add_message(role: "user", content: error_msg)
+    end
+
     def execute_tool_calls(tool_calls, iteration)
-      puts Views::AgentLoop::IterationHeader.build(iteration: iteration, tool_calls: tool_calls) unless @config.debug
+      puts Views::AgentLoop::IterationHeader.build(iteration: iteration, tool_calls: tool_calls)
 
       done_result = nil
       tool_calls.each do |tool_call|
@@ -92,7 +184,7 @@ module RubyCode
         end
       end
 
-      puts Views::AgentLoop::IterationFooter.build unless @config.debug
+      puts Views::AgentLoop::IterationFooter.build
       done_result
     end
 
@@ -108,7 +200,7 @@ module RubyCode
       result = run_tool(tool_name, params)
       return nil unless result
 
-      @display_formatter.display_result(result)
+      @display_formatter.display_result(result, tool_name: tool_name)
       add_tool_result_to_memory(tool_name, result)
       result
     rescue ToolError, StandardError => e

data/lib/rubycode/client/approval_handler.rb

@@ -53,6 +53,20 @@ module RubyCode
         approved
       end
 
+      def request_web_search_approval(query, max_results)
+        display = Views::WebSearchApproval.build(
+          query: query,
+          max_results: max_results
+        )
+        puts display
+
+        approved = request_approval("Perform this web search?")
+
+        puts Views::SkipNotification.build(message: "User declined web search for '#{query}'") unless approved
+
+        approved
+      end
+
       private
 
       def request_approval(question)