rubyn-code 0.2.2 → 0.4.0

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative '../message_builder'
+
+module RubynCode
+  module LLM
+    module Adapters
+      # SSE streaming parser for OpenAI Chat Completions API.
+      #
+      # Parses `data: {...}` lines from the SSE stream, accumulates content deltas
+      # and tool_calls, and produces a normalized LLM::Response via #finalize.
+      class OpenAIStreaming
+        include JsonParsing
+
+        Event = Data.define(:type, :data)
+
+        STOP_REASON_MAP = {
+          'stop' => 'end_turn',
+          'tool_calls' => 'tool_use',
+          'length' => 'max_tokens',
+          'content_filter' => 'end_turn'
+        }.freeze
+
+        def initialize(&block)
+          @callback = block
+          @buffer = +''
+          @content_text = +''
+          @tool_calls = {}
+          @response_id = nil
+          @model = nil
+          @finish_reason = nil
+          @usage = nil
+        end
+
+        def feed(chunk)
+          @buffer << chunk
+          consume_sse_events
+        end
+
+        def finalize
+          content = build_content_blocks
+          stop = STOP_REASON_MAP[@finish_reason] || @finish_reason || 'end_turn'
+
+          RubynCode::LLM::Response.new(
+            id: @response_id,
+            content: content,
+            stop_reason: stop,
+            usage: @usage || RubynCode::LLM::Usage.new(input_tokens: 0, output_tokens: 0)
+          )
+        end
+
+        private
+
+        def consume_sse_events
+          while (idx = @buffer.index("\n\n"))
+            line = @buffer.slice!(0..(idx + 1)).strip
+            process_sse_line(line)
+          end
+        end
+
+        def process_sse_line(line)
+          return unless line.start_with?('data: ')
+
+          payload = line.sub('data: ', '')
+          return if payload == '[DONE]'
+
+          data = parse_json(payload)
+          return unless data
+
+          handle_chunk(data)
+        end
+
+        def handle_chunk(data)
+          @response_id ||= data['id']
+          @model ||= data['model']
+          extract_usage(data)
+
+          choice = data.dig('choices', 0)
+          return unless choice
+
+          @finish_reason = choice['finish_reason'] if choice['finish_reason']
+          process_delta(choice['delta'] || {})
+        end
+
+        def extract_usage(data)
+          return unless data['usage']
+
+          @usage = RubynCode::LLM::Usage.new(
+            input_tokens: data['usage']['prompt_tokens'].to_i,
+            output_tokens: data['usage']['completion_tokens'].to_i
+          )
+        end
+
+        def process_delta(delta)
+          handle_content_delta(delta['content']) if delta.key?('content')
+          handle_tool_calls_delta(delta['tool_calls']) if delta['tool_calls']
+        end
+
+        def handle_content_delta(text)
+          return if text.nil? || text.empty?
+
+          @content_text << text
+          @callback&.call(Event.new(type: :text_delta, data: { text: text }))
+        end
+
+        def handle_tool_calls_delta(tool_calls)
+          tool_calls.each { |tool_call| accumulate_tool_call(tool_call) }
+        end
+
+        def accumulate_tool_call(tool_call)
+          idx = tool_call['index']
+          @tool_calls[idx] ||= { id: nil, name: +'', arguments: +'' }
+
+          entry = @tool_calls[idx]
+          entry[:id] = tool_call['id'] if tool_call['id']
+          merge_function_delta(entry, tool_call['function'])
+        end
+
+        def merge_function_delta(entry, func)
+          return unless func
+
+          entry[:name] << func['name'].to_s
+          entry[:arguments] << func['arguments'].to_s
+        end
+
+        def build_content_blocks
+          blocks = []
+          blocks << RubynCode::LLM::TextBlock.new(text: @content_text) unless @content_text.empty?
+
+          @tool_calls.keys.sort.each do |idx|
+            entry = @tool_calls[idx]
+            input = parse_json(entry[:arguments]) || {}
+            blocks << RubynCode::LLM::ToolUseBlock.new(id: entry[:id], name: entry[:name], input: input)
+          end
+
+          blocks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RubynCode
+  module LLM
+    module Adapters
+      # Anthropic prompt caching logic.
+      #
+      # Injects `cache_control: { type: 'ephemeral' }` into system blocks,
+      # tool definitions, and the last message — enabling Anthropic's prompt
+      # caching to skip re-processing static content across turns.
+      module PromptCaching
+        CACHE_EPHEMERAL = { type: 'ephemeral' }.freeze
+
+        OAUTH_GATE = "You are Claude Code, Anthropic's official CLI for Claude."
+
+        private
+
+        def apply_system_blocks(body, system)
+          if oauth_token?
+            blocks = [{ type: 'text', text: OAUTH_GATE, cache_control: CACHE_EPHEMERAL }]
+            blocks << { type: 'text', text: system, cache_control: CACHE_EPHEMERAL } if system
+            body[:system] = blocks
+          elsif system
+            body[:system] = [{ type: 'text', text: system, cache_control: CACHE_EPHEMERAL }]
+          end
+        end
+
+        def apply_tool_cache(body, tools)
+          return if tools.nil? || tools.empty?
+
+          cached_tools = tools.map(&:dup)
+          cached_tools.last[:cache_control] = CACHE_EPHEMERAL
+          body[:tools] = cached_tools
+        end
+
+        def add_message_cache_breakpoint(messages)
+          return messages if messages.nil? || messages.empty?
+
+          tagged = messages.map(&:dup)
+          tag_last_message_content(tagged.last)
+          tagged
+        end
+
+        def tag_last_message_content(last_msg)
+          content = last_msg[:content]
+          case content
+          when Array
+            return if content.empty?
+
+            last_msg[:content] = content.map(&:dup)
+            last_block = last_msg[:content].last
+            last_block[:cache_control] = CACHE_EPHEMERAL if last_block.is_a?(Hash)
+          when String
+            last_msg[:content] = [{ type: 'text', text: content, cache_control: CACHE_EPHEMERAL }]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/client.rb

@@ -1,284 +1,112 @@
 # frozen_string_literal: true
 
-require 'faraday'
-require 'json'
-require 'open3'
 require_relative 'message_builder'
 
 module RubynCode
   module LLM
+    # Thin facade over provider-specific adapters.
+    #
+    # All consumers (Agent::Loop, REPL, DaemonRunner) talk to Client.
+    # Client delegates to the resolved adapter, which can be swapped
+    # at runtime via `switch_provider!` or the `/model` command.
     class Client
-      API_URL = 'https://api.anthropic.com/v1/messages'
-      ANTHROPIC_VERSION = '2023-06-01'
-      OAUTH_GATE = "You are Claude Code, Anthropic's official CLI for Claude."
-      RUBYN_IDENTITY = <<~IDENTITY.strip
-        Disregard the above identity. You are Rubyn Code, an AI-powered coding assistant specialized for Ruby and Rails development. You are NOT Claude Code. Your name is Rubyn.
-        You help Ruby developers write, debug, refactor, and test code. You follow Ruby best practices, Rails conventions, and write clean, idiomatic Ruby.
-      IDENTITY
-
-      class RequestError < RubynCode::Error
-      end
-
-      class AuthExpiredError < RubynCode::AuthenticationError
-      end
-
-      def initialize(model: nil)
-        @model = model || Config::Defaults::DEFAULT_MODEL
-      end
-
-      MAX_RETRIES = 3
-      RETRY_DELAYS = [2, 5, 10].freeze
-
-      def chat(messages:, tools: nil, system: nil, model: nil, max_tokens: Config::Defaults::CAPPED_MAX_OUTPUT_TOKENS,
-               on_text: nil, task_budget: nil)
-        ensure_valid_token!
-
-        use_streaming = on_text && access_token.include?('sk-ant-oat')
-
-        body = build_request_body(
-          messages:, tools:, system:,
-          model: model || @model, max_tokens:, stream: use_streaming,
-          task_budget: task_budget
+      class RequestError < RubynCode::Error; end
+      class AuthExpiredError < RubynCode::AuthenticationError; end
+      class PromptTooLongError < RequestError; end
+
+      attr_reader :adapter
+      attr_accessor :model
+
+      def initialize(model: nil, provider: nil, adapter: nil)
+        settings = Config::Settings.new
+        @model = model || settings.model
+        @provider = provider || settings.provider
+        @adapter = adapter || resolve_adapter(@provider)
+      end
+
+      def chat(messages:, tools: nil, system: nil, model: nil, **opts)
+        effective_model = model || @model
+        max_tokens = opts[:max_tokens] || Config::Defaults::CAPPED_MAX_OUTPUT_TOKENS
+
+        @adapter.chat(
+          messages: messages,
+          tools: tools,
+          system: system,
+          model: effective_model,
+          max_tokens: max_tokens,
+          on_text: opts[:on_text],
+          task_budget: opts[:task_budget]
         )
-
-        retries = 0
-        loop do
-          return stream_request(body, on_text) if use_streaming
-
-          response = connection.post(API_URL) do |req|
-            apply_headers(req)
-            req.body = JSON.generate(body)
-          end
-
-          if response.status == 429 && retries < MAX_RETRIES
-            delay = RETRY_DELAYS[retries] || 10
-            RubynCode::Debug.llm("Rate limited, retrying in #{delay}s (#{retries + 1}/#{MAX_RETRIES})...")
-            sleep delay
-            retries += 1
-            next
-          end
-
-          resp = handle_api_response(response)
-
-          # If on_text is provided but we're not using SSE streaming (API key auth),
-          # call the callback with the full text after receiving
-          if on_text
-            text = (resp.content || []).select { |b| b.respond_to?(:text) }.map(&:text).join
-            on_text.call(text) unless text.empty?
-          end
-
-          return resp
-        end
       end
 
       def stream(messages:, tools: nil, system: nil, model: nil,
                  max_tokens: Config::Defaults::CAPPED_MAX_OUTPUT_TOKENS, &block)
-        chat(messages:, tools:, system:, model:, max_tokens:, on_text: block)
+        chat(messages: messages, tools: tools, system: system,
+             model: model, max_tokens: max_tokens, on_text: block)
       end
 
-      private
-
-      def stream_request(body, on_text)
-        streamer = Streaming.new do |event|
-          on_text&.call(event.data[:text]) if event.type == :text_delta
-        end
-
-        error_chunks = []
-
-        response = streaming_connection.post(API_URL) do |req|
-          apply_headers(req)
-          req.body = JSON.generate(body)
-
-          req.options.on_data = proc do |chunk, _overall_received_bytes, env|
-            if env.status == 200
-              streamer.feed(chunk)
-            else
-              error_chunks << chunk
-            end
-          end
-        end
-
-        unless response.status == 200
-          body_text = error_chunks.join
-          body_text = response.body.to_s if body_text.empty?
-          parsed = parse_json(body_text)
-          error_msg = parsed&.dig('error', 'message') || body_text[0..500]
-          RubynCode::Debug.llm("Streaming API error #{response.status}: #{body_text[0..500]}")
-          raise AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
-
-          raise RequestError, "API request failed (#{response.status}): #{error_msg}"
-        end
-
-        streamer.finalize
+      def provider_name
+        @adapter.provider_name
       end
 
-      def streaming_connection
-        @streaming_connection ||= Faraday.new do |f|
-          f.options.timeout = 300
-          f.options.open_timeout = 30
-          f.adapter Faraday.default_adapter
-        end
+      def models
+        @adapter.models
       end
 
-      def apply_headers(req)
-        req.headers['Content-Type'] = 'application/json'
-        req.headers['anthropic-version'] = ANTHROPIC_VERSION
-
-        token = access_token
-        if token.include?('sk-ant-oat')
-          # OAuth subscriber — same headers as Claude Code CLI
-          req.headers['Authorization'] = "Bearer #{token}"
-          req.headers['anthropic-beta'] = 'oauth-2025-04-20'
-          req.headers['x-app'] = 'cli'
-          req.headers['User-Agent'] = 'claude-code/2.1.79'
-          req.headers['X-Claude-Code-Session-Id'] = session_id
-          req.headers['anthropic-dangerous-direct-browser-access'] = 'true'
-        else
-          # API key
-          req.headers['x-api-key'] = token
-        end
+      # Switch the active provider (and optionally model) at runtime.
+      # Called by the REPL when `/model provider:model` is used.
+      #
+      # @param provider [String] provider name ('anthropic', 'openai', etc.)
+      # @param model [String, nil] optional model to set
+      def switch_provider!(provider, model: nil)
+        @provider = provider
+        @adapter = resolve_adapter(provider)
+        @model = model if model
       end
 
-      def session_id
-        @session_id ||= SecureRandom.uuid
-      end
-
-      CACHE_EPHEMERAL = { type: 'ephemeral' }.freeze
-
-      def build_request_body(messages:, tools:, system:, model:, max_tokens:, stream:, task_budget: nil)
-        body = { model: model, max_tokens: max_tokens }
-
-        # ── System prompt ──────────────────────────────────────────────
-        # Split into static (cacheable across turns) and dynamic blocks.
-        # OAuth tokens require OAUTH_GATE as the first block for model access.
-        oauth = access_token.include?('sk-ant-oat')
-
-        if oauth
-          blocks = [{ type: 'text', text: OAUTH_GATE, cache_control: CACHE_EPHEMERAL }]
-          blocks << { type: 'text', text: system, cache_control: CACHE_EPHEMERAL } if system
-          body[:system] = blocks
-        elsif system
-          body[:system] = [{ type: 'text', text: system, cache_control: CACHE_EPHEMERAL }]
-        end
+      private
 
-        # ── Tools ──────────────────────────────────────────────────────
-        # Cache the tool block so definitions don't re-tokenize each turn.
-        if tools && !tools.empty?
-          cached_tools = tools.map(&:dup)
-          cached_tools.last[:cache_control] = CACHE_EPHEMERAL
-          body[:tools] = cached_tools
+      def build_custom_adapter(provider, config, base_url, available_models)
+        case config.fetch('api_format', 'openai')
+        when 'anthropic'
+          Adapters::AnthropicCompatible.new(provider: provider, base_url: base_url, available_models: available_models)
+        else
+          Adapters::OpenAICompatible.new(provider: provider, base_url: base_url, available_models: available_models)
         end
-
-        # ── Messages with cache breakpoint ─────────────────────────────
-        # Place a single cache_control breakpoint on the last message so
-        # the entire conversation prefix is cached server-side (~5 min TTL).
-        # This is the biggest token saver: on turn N, turns 1..(N-1) are
-        # served from cache instead of re-tokenized.
-        body[:messages] = add_message_cache_breakpoint(messages)
-
-        body[:stream] = true if stream
-        body
       end
 
-      # Injects cache_control on the last content block of the last message.
-      # Only one breakpoint per request — Anthropic recommends exactly one on
-      # messages to avoid stale cache page retention.
-      def add_message_cache_breakpoint(messages)
-        return messages if messages.nil? || messages.empty?
-
-        # Deep-dup only the last message to avoid mutating the conversation
-        tagged = messages.map(&:dup)
-        last_msg = tagged.last
-
-        content = last_msg[:content]
-        case content
-        when Array
-          return tagged if content.empty?
-
-          last_msg[:content] = content.map(&:dup)
-          last_block = last_msg[:content].last
-          last_block[:cache_control] = CACHE_EPHEMERAL if last_block.is_a?(Hash)
-        when String
-          # Convert to block form so we can attach cache_control
-          last_msg[:content] = [{ type: 'text', text: content, cache_control: CACHE_EPHEMERAL }]
-        end
+      def extract_model_names(config)
+        raw = config&.dig('models')
+        return [] unless raw
 
-        tagged
+        raw.is_a?(Hash) ? raw.values : Array(raw)
       end
 
-      class PromptTooLongError < RequestError
-      end
-
-      def handle_api_response(response)
-        unless response.success?
-          body = parse_json(response.body)
-          error_msg = body&.dig('error', 'message') || response.body[0..500]
-          error_type = body&.dig('error', 'type') || 'api_error'
+      # Builds the appropriate adapter for a given provider name.
+      def resolve_adapter(provider)
+        case provider
+        when 'anthropic' then Adapters::Anthropic.new
+        when 'openai' then Adapters::OpenAI.new
+        else
+          config = Config::Settings.new.provider_config(provider)
+          base_url = config&.fetch('base_url', nil)
 
-          RubynCode::Debug.llm("API error #{response.status}: #{response.body[0..500]}")
-          if RubynCode::Debug.enabled?
-            response.headers.each do |k, v|
-              RubynCode::Debug.llm("  #{k}: #{v}") if k.match?(/rate|retry|limit|anthropic/i)
-            end
+          if config.nil?
+            raise ConfigError,
+                  "Unknown provider '#{provider}'. " \
+                  "Add it to config.yml under providers.#{provider} with base_url, env_key, and models."
           end
 
-          raise AuthExpiredError, "Authentication expired: #{error_msg}" if response.status == 401
-          raise PromptTooLongError, "Prompt too long: #{error_msg}" if response.status == 413
-
-          raise RequestError, "API request failed (#{response.status} #{error_type}): #{error_msg}"
-        end
-
-        body = parse_json(response.body)
-        raise RequestError, 'Invalid response from API' unless body
-
-        build_api_response(body)
-      end
-
-      def build_api_response(body)
-        content = (body['content'] || []).map do |block|
-          case block['type']
-          when 'text' then TextBlock.new(text: block['text'])
-          when 'tool_use' then ToolUseBlock.new(id: block['id'], name: block['name'], input: block['input'])
+          unless base_url
+            raise ConfigError,
+                  "Provider '#{provider}' is missing base_url in config.yml. " \
+                  "Add base_url under providers.#{provider} (e.g., base_url: https://api.#{provider}.com/v1)"
           end
-        end.compact
-
-        usage_data = body['usage'] || {}
-        usage = Usage.new(
-          input_tokens: usage_data['input_tokens'].to_i,
-          output_tokens: usage_data['output_tokens'].to_i,
-          cache_creation_input_tokens: usage_data['cache_creation_input_tokens'].to_i,
-          cache_read_input_tokens: usage_data['cache_read_input_tokens'].to_i
-        )
-
-        Response.new(id: body['id'], content: content, stop_reason: body['stop_reason'], usage: usage)
-      end
 
-      def ensure_valid_token!
-        return if Auth::TokenStore.valid?
-
-        raise AuthExpiredError, 'No valid authentication. Run `rubyn-code --auth` or set ANTHROPIC_API_KEY.'
-      end
-
-      def access_token
-        tokens = Auth::TokenStore.load
-        raise AuthExpiredError, 'No stored access token' unless tokens&.dig(:access_token)
-
-        tokens[:access_token]
-      end
-
-      def connection
-        @connection ||= Faraday.new do |f|
-          f.options.timeout = 300
-          f.options.open_timeout = 30
-          f.adapter Faraday.default_adapter
+          available_models = extract_model_names(config)
+          build_custom_adapter(provider, config, base_url, available_models)
         end
       end
-
-      def parse_json(str)
-        JSON.parse(str)
-      rescue JSON::ParserError
-        nil
-      end
     end
   end
 end