rubyn-code 0.5.1 → 0.8.0

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require 'json'
 require 'securerandom'
 require_relative '../message_builder'
@@ -8,6 +7,7 @@ require_relative '../message_builder'
 module RubynCode
   module LLM
     module Adapters
+      # rubocop:disable Metrics/ClassLength -- auth helpers + streaming + finalize are all needed
       class Anthropic < Base
         include JsonParsing
         include PromptCaching
@@ -17,12 +17,33 @@ module RubynCode
         MAX_RETRIES = 3
         RETRY_DELAYS = [2, 5, 10].freeze
 
+        # Fable/Mythos/Opus 5 models opt into a server-side Opus 4.8 fallback
+        # by default: a declined request (safety-classifier refusal) is
+        # transparently re-served by the fallback model in the same call.
+        # No config toggle — hardcoded for these model families only.
+        FALLBACK_ELIGIBLE_MODELS = /\Aclaude-(fable|mythos|opus-5)/
+        FALLBACK_BETA = 'server-side-fallback-2026-06-01'
+
+        TASK_BUDGET_BETA = 'task-budgets-2026-03-13'
+        TASK_BUDGET_MIN_TOKENS = 20_000 # API minimum; below this, task_budget is omitted entirely
+        TASK_BUDGET_MODELS = /\Aclaude-(fable|mythos|sonnet-5|opus-5|opus-4-[78])/
+
         AVAILABLE_MODELS = %w[
-          claude-sonnet-4-20250514
+          claude-fable-5
+          claude-opus-5
+          claude-opus-4-8
+          claude-opus-4-7
           claude-opus-4-6
-          claude-haiku-4-20250506
+          claude-sonnet-5
+          claude-sonnet-4-6
+          claude-haiku-4-5
         ].freeze
 
+        # Models on the adaptive-thinking API surface (Claude 4.6+).
+        # budget_tokens is removed there and returns a 400; older models
+        # (Haiku 4.5, Sonnet/Opus 4.5 and earlier) still take enabled + budget.
+        ADAPTIVE_THINKING_MODELS = /\Aclaude-(fable|mythos|opus-5|opus-4-[678]|sonnet-5|sonnet-4-6)/
+
         def provider_name
           'anthropic'
         end
@@ -31,14 +52,16 @@ module RubynCode
           AVAILABLE_MODELS
         end
 
-        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil) # rubocop:disable Metrics/ParameterLists -- mirrors LLM adapter interface
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, # rubocop:disable Metrics/ParameterLists -- mirrors LLM adapter interface
+                 task_budget: nil, thinking: nil, effort: nil)
           ensure_valid_token!
           use_streaming = on_text && oauth_token?
 
           body = build_request_body(
             messages: messages, tools: tools, system: system,
             model: model, max_tokens: max_tokens,
-            stream: use_streaming, task_budget: task_budget
+            stream: use_streaming, task_budget: task_budget,
+            thinking: thinking, effort: effort
           )
 
           return stream_request(body, on_text) if use_streaming
@@ -46,30 +69,73 @@ module RubynCode
           execute_with_retries(body, on_text)
         end
 
-        private
+        # -- Auth helpers ----------------------------------------------
 
-        def api_url
-          API_URL
-        end
+        # Validate the active auth path before sending the request.
+        # Raises Client::AuthExpiredError with a clear message instead
+        # of letting the HTTP request fail with a 401.
+        def ensure_valid_token!
+          return if token_valid? && access_token && !access_token.empty?
 
-        # -- Auth ---------------------------------------------------------
+          return if !oauth_token? && api_key && !api_key.empty?
 
-        def oauth_token?
-          access_token.include?('sk-ant-oat')
+          raise Client::AuthExpiredError, 'No valid authentication configured'
         end
 
-        def ensure_valid_token!
-          return if Auth::TokenStore.valid?
+        # @return [Boolean] true when using the OAuth token (vs API key).
+        #   A token from the keychain (or marked source: :keychain /
+        #   :oauth) is treated as OAuth; a token from :env or
+        #   :tokens_file is treated as a long-lived API key.
+        def oauth_token?
+          token = raw_access_token
+          return false unless token.is_a?(Hash)
 
-          raise Client::AuthExpiredError,
-                'No valid authentication. Run `rubyn-code --auth` or set ANTHROPIC_API_KEY.'
+          source = token[:source] || token['source']
+          [:keychain, 'keychain', :oauth].include?(source)
         end
 
+        # @return [String, nil] the access token in use.
+        #   Accepts either a raw String token or a Hash like
+        #   { access_token: "...", expires_at: ..., source: :keychain }.
+        #   Memoized per-instance so that repeated calls during one
+        #   request don't re-hit the token store.
         def access_token
-          tokens = Auth::TokenStore.load
-          raise Client::AuthExpiredError, 'No stored access token' unless tokens&.dig(:access_token)
+          return @access_token if defined?(@access_token)
+
+          token = raw_access_token
+          @access_token =
+            case token
+            when nil    then nil
+            when String then token.empty? ? nil : token
+            when Hash   then token[:access_token] || token['access_token']
+            end
+        end
+
+        # @return [String, nil] the API key (ANTHROPIC_API_KEY), or nil
+        def api_key
+          ENV.fetch('ANTHROPIC_API_KEY', nil)
+        end
+
+        # @return [Boolean] true if the token store says the active
+        #   credential is still valid
+        def token_valid?
+          return true unless defined?(Auth::TokenStore)
+          return true unless Auth::TokenStore.respond_to?(:valid?)
+
+          Auth::TokenStore.valid?
+        end
+
+        def raw_access_token
+          return @raw_access_token if defined?(@raw_access_token)
+
+          @raw_access_token =
+            (Auth::TokenStore.load if defined?(Auth::TokenStore) && Auth::TokenStore.respond_to?(:load))
+        end
+
+        private
 
-          tokens[:access_token]
+        def api_url
+          API_URL
         end
 
         # -- Request execution --------------------------------------------
@@ -93,7 +159,7 @@ module RubynCode
 
         def post_request(body)
           connection.post(api_url) do |req|
-            apply_headers(req)
+            apply_headers(req, body)
             req.body = JSON.generate(body)
           end
         end
@@ -118,7 +184,7 @@ module RubynCode
           error_chunks = []
 
           response = streaming_connection.post(api_url) do |req|
-            apply_headers(req)
+            apply_headers(req, body)
             req.body = JSON.generate(body)
             req.options.on_data = on_data_proc(streamer, error_chunks)
           end
@@ -167,6 +233,7 @@ module RubynCode
         end
 
         def build_faraday_connection
+          require 'faraday'
           Faraday.new do |f|
             f.options.timeout = 300
             f.options.open_timeout = 30
@@ -176,23 +243,35 @@ module RubynCode
 
         # -- Headers ------------------------------------------------------
 
-        def apply_headers(req)
+        def apply_headers(req, body = {})
           req.headers['Content-Type'] = 'application/json'
           req.headers['anthropic-version'] = ANTHROPIC_VERSION
-          oauth_token? ? apply_oauth_headers(req) : apply_api_key_headers(req)
+          oauth_token? ? apply_oauth_headers(req, body) : apply_api_key_headers(req, body)
         end
 
-        def apply_oauth_headers(req)
+        def apply_oauth_headers(req, body)
           req.headers['Authorization'] = "Bearer #{access_token}"
-          req.headers['anthropic-beta'] = 'oauth-2025-04-20'
+          # The subscription-auth beta must stay present, so feature betas append rather than replace.
+          betas = ['oauth-2025-04-20']
+          betas << TASK_BUDGET_BETA if task_budget_on_wire?(body)
+          betas << FALLBACK_BETA if body[:fallbacks]
+          req.headers['anthropic-beta'] = betas.join(',')
           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'
         end
 
-        def apply_api_key_headers(req)
+        def apply_api_key_headers(req, body)
           req.headers['x-api-key'] = access_token
+          betas = []
+          betas << TASK_BUDGET_BETA if task_budget_on_wire?(body)
+          betas << FALLBACK_BETA if body[:fallbacks]
+          req.headers['anthropic-beta'] = betas.join(',') unless betas.empty?
+        end
+
+        def task_budget_on_wire?(body)
+          !!body&.dig(:output_config, :task_budget)
         end
 
         def session_id
@@ -201,15 +280,70 @@ module RubynCode
 
         # -- Request body -------------------------------------------------
 
-        def build_request_body(messages:, tools:, system:, model:, max_tokens:, stream:, **_opts) # rubocop:disable Metrics/ParameterLists -- API request builder mirrors Claude API params
-          body = { model: model, max_tokens: max_tokens }
+        def build_request_body(messages:, tools:, system:, model:, max_tokens:, stream:, # rubocop:disable Metrics/ParameterLists -- API request builder mirrors Claude API params
+                               thinking: nil, effort: nil, task_budget: nil, **_opts)
+          body = { model: model, max_tokens: ensure_max_tokens_for_thinking(max_tokens, thinking) }
+          apply_thinking(body, thinking)
+          apply_effort(body, effort)
+          apply_task_budget(body, task_budget, model)
           apply_system_blocks(body, system)
           apply_tool_cache(body, tools)
+          apply_fallbacks(body, model)
           body[:messages] = add_message_cache_breakpoint(messages)
           body[:stream] = true if stream
           body
         end
 
+        def apply_fallbacks(body, model)
+          return unless model.to_s.match?(FALLBACK_ELIGIBLE_MODELS)
+
+          body[:fallbacks] = [{ model: 'claude-opus-4-8' }]
+        end
+
+        # Advisory pacing signal only — Claude sees a running countdown and paces
+        # itself, but max_tokens remains the enforced hard cap per response.
+        def apply_task_budget(body, task_budget, model)
+          return unless task_budget.is_a?(Hash)
+          return unless model.to_s.match?(TASK_BUDGET_MODELS)
+
+          # `remaining` is what's left for the task, matching what the model should pace against.
+          total = task_budget[:remaining].to_i
+          return if total < TASK_BUDGET_MIN_TOKENS
+
+          (body[:output_config] ||= {})[:task_budget] = { type: 'tokens', total: total }
+        end
+
+        def apply_thinking(body, thinking)
+          return unless thinking.is_a?(Hash) && thinking[:budget_tokens].to_i.positive?
+
+          body[:thinking] =
+            if body[:model].to_s.match?(ADAPTIVE_THINKING_MODELS)
+              { type: 'adaptive' }
+            else
+              { type: 'enabled', budget_tokens: thinking[:budget_tokens].to_i }
+            end
+        end
+
+        # Merges into `output_config` (rather than assigning a whole hash) so
+        # this composes with other output_config keys, e.g. task_budget.
+        def apply_effort(body, effort)
+          return unless effort
+
+          (body[:output_config] ||= {})[:effort] = effort
+        end
+
+        # Anthropic requires max_tokens > budget_tokens. When thinking is on,
+        # raise max_tokens to budget + 1024 if not already large enough.
+        def ensure_max_tokens_for_thinking(max_tokens, thinking)
+          return max_tokens unless thinking.is_a?(Hash)
+
+          budget = thinking[:budget_tokens].to_i
+          return max_tokens if budget.zero?
+          return max_tokens if max_tokens >= budget + 1024
+
+          budget + 1024
+        end
+
         # -- Response parsing ---------------------------------------------
 
         def handle_api_response(response)
@@ -245,13 +379,17 @@ module RubynCode
         def build_api_response(body)
           content = parse_content_blocks(body['content'])
           usage = parse_usage(body['usage'])
-          Response.new(id: body['id'], content: content, stop_reason: body['stop_reason'], usage: usage)
+          Response.new(
+            id: body['id'], content: content, stop_reason: body['stop_reason'],
+            stop_details: body['stop_details'], usage: usage
+          )
         end
 
         def parse_content_blocks(blocks)
           (blocks || []).filter_map do |block|
             case block['type']
             when 'text' then TextBlock.new(text: block['text'])
+            when 'thinking' then ThinkingBlock.new(text: block['thinking'] || block['text'])
             when 'tool_use'
               ToolUseBlock.new(id: block['id'], name: block['name'], input: block['input'])
             end
@@ -270,5 +408,6 @@ module RubynCode
         end
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

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

@@ -35,8 +35,10 @@ module RubynCode
           @content_blocks = []
           @current_block_index = nil
           @current_text = +''
+          @current_thinking_text = +''
           @current_tool_input_json = +''
           @stop_reason = nil
+          @stop_details = nil
           @usage = nil
         end
 
@@ -51,6 +53,7 @@ module RubynCode
             id: @response_id,
             content: @content_blocks.compact,
             stop_reason: @stop_reason,
+            stop_details: @stop_details,
             usage: @usage
           )
         end
@@ -107,6 +110,8 @@ module RubynCode
           case block['type']
           when 'text'
             @current_text = +(block['text'] || '')
+          when 'thinking'
+            @current_thinking_text = +(block['thinking'] || '')
           when 'tool_use'
             @current_tool_id = block['id']
             @current_tool_name = block['name']
@@ -124,6 +129,10 @@ module RubynCode
             text = delta['text'] || ''
             @current_text << text
             emit(:text_delta, { index: data['index'], text: text })
+          when 'thinking_delta'
+            text = delta['thinking'] || ''
+            @current_thinking_text << text
+            emit(:thinking_delta, { index: data['index'], text: text })
           when 'input_json_delta'
             json_chunk = delta['partial_json'] || ''
             @current_tool_input_json << json_chunk
@@ -141,6 +150,7 @@ module RubynCode
         def handle_message_delta(data)
           delta = data['delta'] || {}
           @stop_reason = delta['stop_reason'] if delta['stop_reason']
+          @stop_details = delta['stop_details'] if delta['stop_details']
           update_output_tokens(data['usage']) if data['usage']
           emit(:message_delta, data)
         end
@@ -167,6 +177,9 @@ module RubynCode
           elsif !@current_text.empty?
             @content_blocks[index] = TextBlock.new(text: @current_text.dup)
             @current_text = +''
+          elsif !@current_thinking_text.empty?
+            @content_blocks[index] = ThinkingBlock.new(text: @current_thinking_text.dup)
+            @current_thinking_text = +''
           end
         end
 

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

@@ -15,8 +15,9 @@ module RubynCode
         # @param system [String, nil] System prompt text
         # @param on_text [Proc, nil] Streaming text callback
         # @param task_budget [Hash, nil] Optional task budget context
+        # @param thinking [Hash, nil] Optional {budget_tokens: Integer} for extended reasoning
         # @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
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists -- LLM adapter interface requires these params
           raise NotImplementedError, "#{self.class}#chat must be implemented"
         end
 

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

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'faraday'
 require 'json'
 require_relative '../message_builder'
 
@@ -31,7 +30,7 @@ module RubynCode
           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
+        def chat(messages:, model:, max_tokens:, tools: nil, system: nil, on_text: nil, task_budget: nil, thinking: 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
@@ -141,6 +140,7 @@ module RubynCode
         end
 
         def build_faraday_connection
+          require 'faraday'
           Faraday.new do |f|
             f.options.timeout = 300
             f.options.open_timeout = 30

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

@@ -27,6 +27,10 @@ module RubynCode
           return translate_tool_results(content) if tool_results?(content)
           return translate_assistant_tool_use(content) if role == 'assistant' && tool_use_blocks?(content)
 
+          if content.is_a?(Array) && content.any? { |b| block_type(b) == 'image' }
+            return { role: role, content: translate_user_content_with_images(content) }
+          end
+
           { role: role, content: stringify_content(content) }
         end
 
@@ -34,6 +38,23 @@ module RubynCode
           content.is_a?(Array) && content.any? { |b| block_type(b) == 'tool_result' }
         end
 
+        # Emit OpenAI multipart content: text blocks stay text, image blocks
+        # become {type: 'image_url', image_url: {url: 'data:<media>;base64,...'}}.
+        def translate_user_content_with_images(content)
+          content.map do |block|
+            case block_type(block)
+            when 'image'
+              source = block[:source] || block['source']
+              media = source[:media_type] || source['media_type']
+              data = source[:data] || source['data']
+              { type: 'image_url', image_url: { url: "data:#{media};base64,#{data}" } }
+            else
+              text = block[:text] || block['text'] || ''
+              { type: 'text', text: text }
+            end
+          end
+        end
+
         def tool_use_blocks?(content)
           content.is_a?(Array) && content.any? { |b| block_type(b) == 'tool_use' }
         end

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

@@ -36,7 +36,11 @@ module RubynCode
         def add_message_cache_breakpoint(messages)
           return messages if messages.nil? || messages.empty?
 
-          tagged = messages.map(&:dup)
+          # Only the last message gets the cache_control tag, so only it
+          # needs to be duped — copying the whole history every call is
+          # wasted work on long conversations.
+          tagged = messages.dup
+          tagged[-1] = tagged[-1].dup
           tag_last_message_content(tagged.last)
           tagged
         end

data/lib/rubyn_code/llm/client.rb

@@ -15,20 +15,22 @@ module RubynCode
       class PromptTooLongError < RequestError; end
 
       attr_reader :adapter
-      attr_accessor :model
+      attr_accessor :model, :thinking_budget_tokens, :effort
 
       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)
+        @thinking_budget_tokens = 0
       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
+        effective_thinking = opts[:thinking] || current_thinking_hash
 
-        @adapter.chat(
+        kwargs = {
           messages: messages,
           tools: tools,
           system: system,
@@ -36,7 +38,18 @@ module RubynCode
           max_tokens: max_tokens,
           on_text: opts[:on_text],
           task_budget: opts[:task_budget]
-        )
+        }
+        kwargs[:thinking] = effective_thinking if effective_thinking
+        kwargs[:effort] = @effort if @effort
+
+        @adapter.chat(**kwargs)
+      end
+
+      def current_thinking_hash
+        budget = @thinking_budget_tokens.to_i
+        return nil unless budget.positive?
+
+        { budget_tokens: budget }
       end
 
       def stream(messages:, tools: nil, system: nil, model: nil,

data/lib/rubyn_code/llm/image_reader.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module RubynCode
+  # Pulls in ImageBlock so the constant is loaded before ImageReader resolves it.
+  module LLM
+    autoload :ImageBlock, 'rubyn_code/llm/message_builder'
+  end
+
+  module LLM
+    # Reads image files from disk and returns image content blocks suitable for
+    # sending to the LLM as part of a user turn. Supports common raster formats
+    # accepted by both Anthropic and OpenAI vision APIs.
+    module ImageReader
+      MAX_BYTES = 8 * 1024 * 1024
+
+      MEDIA_TYPES = {
+        '.png' => 'image/png',
+        '.jpg' => 'image/jpeg',
+        '.jpeg' => 'image/jpeg',
+        '.gif' => 'image/gif',
+        '.webp' => 'image/webp'
+      }.freeze
+
+      EXTENSIONS_REGEX = /\.(png|jpe?g|gif|webp)\z/i
+
+      module_function
+
+      # Build a base64 data URI of the form:
+      #   "data:image/png;base64,iVBORw0KG..."
+      # Returns nil for non-image paths or unreadable/oversized files.
+      def data_uri(path)
+        block = for_path(path)
+        return nil unless block
+
+        "data:#{block.media_type};base64,#{block.data}"
+      end
+
+      # @return [LLM::ImageBlock, nil] nil for non-image / unreadable paths
+      def for_path(path)
+        ext = File.extname(path)
+        media = MEDIA_TYPES[ext.downcase] || MEDIA_TYPES[".#{ext.sub(/^\./, '').downcase}"]
+        return nil unless media
+        return nil unless File.file?(path)
+
+        bytes = File.binread(path)
+        return nil if bytes.bytesize > MAX_BYTES
+
+        ImageBlock.new(media_type: media, data: Base64.strict_encode64(bytes))
+      rescue Errno::ENOENT, Errno::EACCES, ArgumentError
+        nil
+      end
+
+      def image_extension?(path)
+        path.to_s.match?(EXTENSIONS_REGEX)
+      end
+    end
+  end
+end

data/lib/rubyn_code/llm/message_builder.rb

@@ -6,6 +6,14 @@ module RubynCode
       def type = 'text'
     end
 
+    ThinkingBlock = Data.define(:text) do
+      def type = 'thinking'
+    end
+
+    ImageBlock = Data.define(:media_type, :data) do
+      def type = 'image'
+    end
+
     ToolUseBlock = Data.define(:id, :name, :input) do
       def type = 'tool_use'
     end
@@ -24,7 +32,11 @@ module RubynCode
       end
     end
 
-    Response = Data.define(:id, :content, :stop_reason, :usage) do
+    Response = Data.define(:id, :content, :stop_reason, :stop_details, :usage) do
+      def initialize(id:, content:, stop_reason:, usage:, stop_details: nil)
+        super
+      end
+
       def text
         content.select { |b| b.type == 'text' }.map(&:text).join
       end
@@ -36,6 +48,10 @@ module RubynCode
       def tool_use?
         stop_reason == 'tool_use'
       end
+
+      def refusal?
+        stop_reason == 'refusal'
+      end
     end
 
     class MessageBuilder
@@ -102,6 +118,10 @@ module RubynCode
           case block
           when TextBlock
             { type: 'text', text: block.text }
+          when ThinkingBlock
+            { type: 'thinking', text: block.text }
+          when ImageBlock
+            { type: 'image', source: { type: 'base64', media_type: block.media_type, data: block.data } }
           when ToolUseBlock
             { type: 'tool_use', id: block.id, name: block.name, input: block.input }
           when ToolResultBlock

data/lib/rubyn_code/llm/model_router.rb

@@ -13,8 +13,8 @@ module RubynCode
     #       env_key: ANTHROPIC_API_KEY
     #       models:
     #         cheap: claude-haiku-4-5
-    #         mid: claude-sonnet-4-6
-    #         top: claude-opus-4-6
+    #         mid: claude-sonnet-5
+    #         top: claude-opus-5
     #     openai:
     #       env_key: OPENAI_API_KEY
     #       models:
@@ -46,11 +46,11 @@ module RubynCode
           %w[openai gpt-5.4-nano]
         ].freeze,
         mid: [
-          %w[anthropic claude-sonnet-4-6],
+          %w[anthropic claude-sonnet-5],
           %w[openai gpt-5.4-mini]
         ].freeze,
         top: [
-          %w[anthropic claude-opus-4-6],
+          %w[anthropic claude-opus-5],
           %w[openai gpt-5.4]
         ].freeze
       }.freeze