rubyn-code 0.2.2 → 0.3.0

data/lib/rubyn_code/llm/adapters/anthropic_streaming.rb

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+require_relative '../message_builder'
+
+module RubynCode
+  module LLM
+    module Adapters
+      # SSE streaming parser for the Anthropic Messages API.
+      #
+      # Handles Anthropic-specific event types: message_start, content_block_start,
+      # content_block_delta, content_block_stop, message_delta, message_stop, error.
+      # Accumulates content blocks and produces a normalized LLM::Response via #finalize.
+      class AnthropicStreaming
+        include JsonParsing
+
+        class ParseError < RubynCode::Error; end
+        class OverloadError < RubynCode::Error; end
+
+        Event = Data.define(:type, :data)
+
+        HANDLERS = {
+          'message_start' => :handle_message_start,
+          'content_block_start' => :handle_content_block_start,
+          'content_block_delta' => :handle_content_block_delta,
+          'content_block_stop' => :handle_content_block_stop,
+          'message_delta' => :handle_message_delta,
+          'message_stop' => :handle_message_stop,
+          'error' => :handle_error
+        }.freeze
+
+        def initialize(&block)
+          @callback = block
+          @buffer = +''
+          @response_id = nil
+          @content_blocks = []
+          @current_block_index = nil
+          @current_text = +''
+          @current_tool_input_json = +''
+          @stop_reason = nil
+          @usage = nil
+        end
+
+        def feed(chunk)
+          @buffer << chunk
+          consume_events
+        end
+
+        def finalize
+          flush_pending_block
+          Response.new(
+            id: @response_id,
+            content: @content_blocks.compact,
+            stop_reason: @stop_reason,
+            usage: @usage
+          )
+        end
+
+        private
+
+        # -- SSE parsing --------------------------------------------------
+
+        def consume_events
+          while (idx = @buffer.index("\n\n"))
+            raw_event = @buffer.slice!(0..(idx + 1))
+            parse_sse(raw_event)
+          end
+        end
+
+        def parse_sse(raw)
+          event_type = nil
+          data_lines = []
+
+          raw.each_line do |line|
+            line = line.chomp
+            case line
+            when /\Aevent:\s*(.+)/ then event_type = ::Regexp.last_match(1).strip
+            when /\Adata:\s*(.*)/ then data_lines << ::Regexp.last_match(1)
+            end
+          end
+
+          return if data_lines.empty? && event_type.nil?
+
+          data_str = data_lines.join("\n")
+          dispatch(event_type, data_str.empty? ? {} : parse_json(data_str))
+        end
+
+        def dispatch(event_type, data)
+          handler = HANDLERS[event_type]
+          return unless handler
+
+          method(handler).arity.zero? ? send(handler) : send(handler, data)
+        end
+
+        # -- Event handlers -----------------------------------------------
+
+        def handle_message_start(data)
+          message = data['message'] || data
+          @response_id = message['id']
+          @usage = build_usage(message['usage']) if message['usage']
+          emit(:message_start, data)
+        end
+
+        def handle_content_block_start(data)
+          @current_block_index = data['index']
+          block = data['content_block'] || {}
+
+          case block['type']
+          when 'text'
+            @current_text = +(block['text'] || '')
+          when 'tool_use'
+            @current_tool_id = block['id']
+            @current_tool_name = block['name']
+            @current_tool_input_json = +''
+          end
+
+          emit(:content_block_start, data)
+        end
+
+        def handle_content_block_delta(data)
+          delta = data['delta'] || {}
+
+          case delta['type']
+          when 'text_delta'
+            text = delta['text'] || ''
+            @current_text << text
+            emit(:text_delta, { index: data['index'], text: text })
+          when 'input_json_delta'
+            json_chunk = delta['partial_json'] || ''
+            @current_tool_input_json << json_chunk
+            emit(:input_json_delta, { index: data['index'], partial_json: json_chunk })
+          end
+
+          emit(:content_block_delta, data)
+        end
+
+        def handle_content_block_stop(data)
+          store_current_block(data['index'].to_i)
+          emit(:content_block_stop, data)
+        end
+
+        def handle_message_delta(data)
+          delta = data['delta'] || {}
+          @stop_reason = delta['stop_reason'] if delta['stop_reason']
+          update_output_tokens(data['usage']) if data['usage']
+          emit(:message_delta, data)
+        end
+
+        def handle_message_stop
+          emit(:message_stop, {})
+        end
+
+        def handle_error(data)
+          error = data['error'] || data
+          error_type = error['type'] || 'unknown'
+          message = error['message'] || 'Unknown streaming error'
+
+          raise OverloadError, message if error_type == 'overloaded_error'
+
+          raise ParseError, "Streaming error (#{error_type}): #{message}"
+        end
+
+        # -- Block assembly (single code path) ----------------------------
+
+        def store_current_block(index)
+          if @current_tool_id
+            @content_blocks[index] = build_tool_block
+          elsif !@current_text.empty?
+            @content_blocks[index] = TextBlock.new(text: @current_text.dup)
+            @current_text = +''
+          end
+        end
+
+        def flush_pending_block
+          return unless @current_block_index
+
+          store_current_block(@current_block_index)
+          @current_block_index = nil
+        end
+
+        def build_tool_block
+          input = parse_json(@current_tool_input_json) || {}
+          block = ToolUseBlock.new(id: @current_tool_id, name: @current_tool_name, input: input)
+          @current_tool_id = nil
+          @current_tool_name = nil
+          @current_tool_input_json = +''
+          block
+        end
+
+        # -- Helpers ------------------------------------------------------
+
+        def build_usage(data)
+          Usage.new(
+            input_tokens: data['input_tokens'].to_i,
+            output_tokens: data['output_tokens'].to_i,
+            cache_creation_input_tokens: data['cache_creation_input_tokens'].to_i,
+            cache_read_input_tokens: data['cache_read_input_tokens'].to_i
+          )
+        end
+
+        def update_output_tokens(usage_data)
+          @usage = Usage.new(
+            input_tokens: @usage&.input_tokens || 0,
+            output_tokens: usage_data['output_tokens'].to_i,
+            cache_creation_input_tokens: @usage&.cache_creation_input_tokens || 0,
+            cache_read_input_tokens: @usage&.cache_read_input_tokens || 0
+          )
+        end
+
+        def emit(type, data)
+          @callback&.call(Event.new(type: type, data: data))
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Abstract base for all LLM provider adapters.
+      #
+      # Every adapter must implement #chat, #provider_name, and #models.
+      # The Client facade delegates to whichever adapter is active.
+      class Base
+        # @param messages [Array<Hash>] Conversation messages
+        # @param model [String] Model identifier
+        # @param max_tokens [Integer] Max output tokens
+        # @param tools [Array<Hash>, nil] Tool schemas
+        # @param system [String, nil] System prompt text
+        # @param on_text [Proc, nil] Streaming text callback
+        # @param task_budget [Hash, nil] Optional task budget context
+        # @return [LLM::Response]
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil) # rubocop:disable Metrics/ParameterLists -- LLM adapter interface requires these params
+          raise NotImplementedError, "#{self.class}#chat must be implemented"
+        end
+
+        # @return [String] Provider identifier (e.g. 'anthropic', 'openai')
+        def provider_name
+          raise NotImplementedError, "#{self.class}#provider_name must be implemented"
+        end
+
+        # @return [Array<String>] Available model identifiers
+        def models
+          raise NotImplementedError, "#{self.class}#models must be implemented"
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/json_parsing.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Shared JSON parsing for adapters and streaming parsers.
+      # Swallows parse errors and returns nil — callers decide how to handle.
+      module JsonParsing
+        private
+
+        def parse_json(str)
+          return nil if str.nil? || (str.respond_to?(:strip) && str.strip.empty?)
+
+          JSON.parse(str)
+        rescue JSON::ParserError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/openai.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+require_relative '../message_builder'
+
+module RubynCode
+  module LLM
+    module Adapters
+      class OpenAI < Base
+        include JsonParsing
+        include OpenAIMessageTranslator
+
+        API_URL = 'https://api.openai.com/v1/chat/completions'
+        MAX_RETRIES = 3
+        RETRY_DELAYS = [2, 5, 10].freeze
+
+        AVAILABLE_MODELS = %w[gpt-4o gpt-4o-mini gpt-4.1 gpt-4.1-mini gpt-4.1-nano o3 o4-mini].freeze
+
+        def initialize(api_key: nil, base_url: nil)
+          super()
+          @api_key = api_key
+          @base_url = base_url
+        end
+
+        def provider_name
+          'openai'
+        end
+
+        def models
+          AVAILABLE_MODELS
+        end
+
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument -- LLM adapter interface requires these params
+          body = build_request_body(
+            messages: messages, model: model, max_tokens: max_tokens,
+            tools: tools, system: system
+          )
+
+          return stream_request(body, on_text) if on_text
+
+          execute_with_retries(body, on_text)
+        end
+
+        private
+
+        # -- Auth ---------------------------------------------------------
+
+        def resolve_api_key
+          @api_key || ENV.fetch('OPENAI_API_KEY') { raise Client::AuthExpiredError, 'No OpenAI API key configured' }
+        end
+
+        # -- Execution ----------------------------------------------------
+
+        def execute_with_retries(body, on_text)
+          retries = 0
+          loop do
+            response = post_request(body)
+
+            if response.status == 429 && retries < MAX_RETRIES
+              RubynCode::Debug.llm("Rate limited (429), retry #{retries + 1}/#{MAX_RETRIES}")
+              sleep(RETRY_DELAYS[retries] || 10)
+              retries += 1
+              next
+            end
+
+            return finalize_response(response, on_text)
+          end
+        end
+
+        def post_request(body)
+          connection.post(api_url) do |req|
+            apply_headers(req)
+            req.body = JSON.generate(body)
+          end
+        end
+
+        def finalize_response(response, on_text)
+          resp = handle_api_response(response)
+          emit_full_text(resp, on_text)
+          resp
+        end
+
+        def emit_full_text(resp, on_text)
+          return unless on_text
+
+          text = resp.content.select { |b| b.respond_to?(:text) }.map(&:text).join
+          on_text.call(text) unless text.empty?
+        end
+
+        # -- Streaming ----------------------------------------------------
+
+        def stream_request(body, on_text)
+          streamer = build_streamer(on_text)
+          error_chunks = []
+
+          response = streaming_connection.post(api_url) do |req|
+            apply_headers(req)
+            req.body = JSON.generate(body.merge(stream: true))
+            req.options.on_data = on_data_proc(streamer, error_chunks)
+          end
+
+          handle_stream_errors(response, error_chunks)
+          streamer.finalize
+        end
+
+        def build_streamer(on_text)
+          OpenAIStreaming.new do |event|
+            on_text&.call(event.data[:text]) if event.type == :text_delta
+          end
+        end
+
+        def on_data_proc(streamer, error_chunks)
+          proc do |chunk, _bytes, env|
+            env.status == 200 ? streamer.feed(chunk) : error_chunks << chunk
+          end
+        end
+
+        def handle_stream_errors(response, error_chunks)
+          return if response.status == 200
+
+          body_text = error_chunks.join
+          error_msg = parse_json(body_text)&.dig('error', 'message') || body_text[0..500]
+          raise Client::AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+
+          raise Client::RequestError, "API streaming failed (#{response.status}): #{error_msg}"
+        end
+
+        # -- Connection ---------------------------------------------------
+
+        def api_url
+          @base_url ? "#{@base_url}/chat/completions" : API_URL
+        end
+
+        def connection
+          @connection ||= build_faraday_connection
+        end
+
+        def streaming_connection
+          @streaming_connection ||= build_faraday_connection
+        end
+
+        def build_faraday_connection
+          Faraday.new do |f|
+            f.options.timeout = 300
+            f.options.open_timeout = 30
+            f.adapter Faraday.default_adapter
+          end
+        end
+
+        # -- Headers ------------------------------------------------------
+
+        def apply_headers(req)
+          req.headers['Content-Type'] = 'application/json'
+          req.headers['Authorization'] = "Bearer #{resolve_api_key}"
+        end
+
+        # -- Request body -------------------------------------------------
+
+        def build_request_body(messages:, model:, max_tokens:, tools:, system:)
+          body = { model: model, max_tokens: max_tokens, messages: build_messages(messages, system) }
+          body[:tools] = format_tools(tools) if tools&.any?
+          body
+        end
+
+        def format_tools(tools)
+          tools.map do |tool|
+            {
+              type: 'function',
+              function: {
+                name: tool[:name] || tool['name'],
+                description: tool[:description] || tool['description'],
+                parameters: tool[:input_schema] || tool[:parameters] || tool['input_schema'] || tool['parameters']
+              }
+            }
+          end
+        end
+
+        # -- Response parsing ---------------------------------------------
+
+        def handle_api_response(response)
+          raise_on_error(response) unless response.success?
+
+          body = parse_json(response.body)
+          raise Client::RequestError, 'Invalid response from API' unless body
+
+          build_api_response(body)
+        end
+
+        def raise_on_error(response)
+          body = parse_json(response.body)
+          error_msg = body&.dig('error', 'message') || response.body[0..500]
+          log_api_error(response)
+
+          raise Client::AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
+          raise Client::PromptTooLongError, "Prompt too long: #{error_msg}" if response.status == 413
+
+          raise Client::RequestError, "API request failed (#{response.status}): #{error_msg}"
+        end
+
+        def log_api_error(response)
+          RubynCode::Debug.llm("API error #{response.status}: #{response.body[0..500]}")
+        end
+
+        def build_api_response(body)
+          message = body.dig('choices', 0, 'message') || {}
+          blocks = parse_response_content(message)
+          usage = parse_usage(body['usage'])
+          stop = normalize_stop_reason(body.dig('choices', 0, 'finish_reason'))
+
+          RubynCode::LLM::Response.new(id: body['id'], content: blocks, stop_reason: stop, usage: usage)
+        end
+
+        def parse_response_content(message)
+          blocks = []
+          blocks << RubynCode::LLM::TextBlock.new(text: message['content']) if message['content']
+          append_tool_call_blocks(blocks, message['tool_calls'])
+          blocks
+        end
+
+        def append_tool_call_blocks(blocks, tool_calls)
+          return unless tool_calls
+
+          tool_calls.each do |tc|
+            func = tc['function'] || {}
+            input = parse_json(func['arguments']) || {}
+            blocks << RubynCode::LLM::ToolUseBlock.new(id: tc['id'], name: func['name'], input: input)
+          end
+        end
+
+        def parse_usage(data)
+          return RubynCode::LLM::Usage.new(input_tokens: 0, output_tokens: 0) unless data
+
+          RubynCode::LLM::Usage.new(
+            input_tokens: data['prompt_tokens'].to_i,
+            output_tokens: data['completion_tokens'].to_i
+          )
+        end
+
+        def normalize_stop_reason(reason)
+          OpenAIStreaming::STOP_REASON_MAP[reason] || reason || 'end_turn'
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/openai_compatible.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Adapter for OpenAI-compatible providers (Groq, Together, Ollama, etc.).
+      #
+      # Inherits all OpenAI logic but overrides the base URL, provider name,
+      # available models, and API key resolution.
+      class OpenAICompatible < OpenAI
+        def initialize(provider:, base_url:, api_key: nil, available_models: [])
+          super(api_key: api_key, base_url: base_url)
+          @provider = provider
+          @available_models = available_models.freeze
+        end
+
+        def provider_name
+          @provider
+        end
+
+        def models
+          @available_models
+        end
+
+        private
+
+        def resolve_api_key
+          return @api_key if @api_key
+
+          env_key = "#{@provider.upcase}_API_KEY"
+          ENV.fetch(env_key) do
+            return 'no-key-required' if local_provider?
+
+            raise Client::AuthExpiredError, "No #{@provider} API key configured. Set #{env_key}."
+          end
+        end
+
+        def local_provider?
+          return false unless @base_url
+
+          @base_url.match?(/localhost|127\.0\.0\.1|0\.0\.0\.0/)
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/adapters/openai_message_translator.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Translates Anthropic-format messages to OpenAI Chat Completions format.
+      #
+      # Anthropic uses content blocks (tool_result, tool_use) inside message arrays,
+      # while OpenAI uses separate message roles and tool_calls arrays.
+      module OpenAIMessageTranslator
+        private
+
+        def build_messages(messages, system)
+          result = []
+          result << { role: 'system', content: system } if system
+          messages.each do |msg|
+            translated = translate_message(msg)
+            translated.is_a?(Array) ? result.concat(translated) : result.push(translated)
+          end
+          result
+        end
+
+        def translate_message(msg)
+          content = msg[:content] || msg['content']
+          role = msg[:role] || msg['role']
+
+          return translate_tool_results(content) if tool_results?(content)
+          return translate_assistant_tool_use(content) if role == 'assistant' && tool_use_blocks?(content)
+
+          { role: role, content: stringify_content(content) }
+        end
+
+        def tool_results?(content)
+          content.is_a?(Array) && content.any? { |b| block_type(b) == 'tool_result' }
+        end
+
+        def tool_use_blocks?(content)
+          content.is_a?(Array) && content.any? { |b| block_type(b) == 'tool_use' }
+        end
+
+        def translate_tool_results(content_blocks)
+          content_blocks.select { |b| block_type(b) == 'tool_result' }.map do |block|
+            tool_use_id = block[:tool_use_id] || block['tool_use_id']
+            text = stringify_content(block[:content] || block['content'])
+            { role: 'tool', tool_call_id: tool_use_id, content: text }
+          end
+        end
+
+        def translate_assistant_tool_use(content_blocks)
+          text_blocks, tool_blocks = partition_assistant_blocks(content_blocks)
+          msg = { role: 'assistant' }
+          msg[:content] = stringify_content(text_blocks) unless text_blocks.empty?
+          msg[:tool_calls] = tool_blocks.map { |b| build_tool_call_hash(b) } unless tool_blocks.empty?
+          msg
+        end
+
+        def partition_assistant_blocks(content_blocks)
+          texts, tools = content_blocks.partition { |b| block_type(b) != 'tool_use' }
+          [texts, tools]
+        end
+
+        def build_tool_call_hash(block)
+          input = block[:input] || block['input'] || {}
+          {
+            id: block[:id] || block['id'],
+            type: 'function',
+            function: {
+              name: block[:name] || block['name'],
+              arguments: input.is_a?(String) ? input : JSON.generate(input)
+            }
+          }
+        end
+
+        def stringify_content(content)
+          case content
+          when String then content
+          when Array
+            content.map { |b| b[:text] || b['text'] || b.to_s }.join
+          else
+            content.to_s
+          end
+        end
+
+        def block_type(block)
+          block[:type] || block['type']
+        end
+      end
+    end
+  end
+end