kward 0.67.0 → 0.68.0

data/lib/kward/model/client.rb

@@ -1,6 +1,7 @@
 require "json"
 require "net/http"
 require "uri"
+require_relative "../auth/anthropic_oauth"
 require_relative "../auth/github_oauth"
 require_relative "../auth/openai_oauth"
 require_relative "../cancellation"
@@ -11,15 +12,25 @@ require_relative "payloads"
 require_relative "../telemetry/logger"
 require_relative "stream_parser"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Provider-facing model client used by CLI, RPC, compaction, and memory flows.
+  #
+  # `Client` owns runtime provider selection, credential lookup, retry telemetry,
+  # and HTTP requests for the supported model backends. Provider-neutral payload
+  # construction and stream parsing live in `ModelPayloads` and
+  # `ModelStreamParser`; keep new provider mechanics there when they are reusable,
+  # and keep product policy such as configured provider/model selection here.
   class Client
     include ModelPayloads
     OPENROUTER_URL = URI("https://openrouter.ai/api/v1/chat/completions")
     OPENROUTER_MODELS_URL = URI("https://openrouter.ai/api/v1/models")
     CODEX_URL = URI("https://chatgpt.com/backend-api/codex/responses")
+    ANTHROPIC_URL = URI("https://api.anthropic.com/v1/messages")
     AUTH_ERROR = "No OpenAI OAuth login found. Run `ruby lib/main.rb login`, or set OPENAI_ACCESS_TOKEN/OPENROUTER_API_KEY."
     OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or add openrouter_api_key to your Kward config."
     COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `ruby lib/main.rb login github` or set COPILOT_GITHUB_TOKEN."
+    ANTHROPIC_AUTH_ERROR = "No Anthropic OAuth login found. Run `ruby lib/main.rb login anthropic`."
     DEFAULT_OPENAI_MODEL = ModelInfo::DEFAULT_OPENAI_MODEL
     DEFAULT_OPENROUTER_MODEL = ModelInfo::DEFAULT_OPENROUTER_MODEL
     DEFAULT_REASONING_EFFORT = ModelInfo::DEFAULT_REASONING_EFFORT
@@ -41,6 +52,7 @@ module Kward
     RequestError = Class.new(StandardError) do
       attr_reader :provider, :code, :body
 
+      # Creates an object for model provider requests.
       def initialize(provider:, code:, body:)
         @provider = provider
         @code = code.to_i
@@ -67,11 +79,13 @@ module Kward
     end
     TRANSIENT_NETWORK_ERRORS = [IOError, EOFError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout].freeze
 
-    def initialize(api_key: ENV["OPENROUTER_API_KEY"], model: nil, openai_access_token: ENV["OPENAI_ACCESS_TOKEN"], oauth: OpenAIOAuth.new, github_oauth: GithubOAuth.new, config_path: OpenAIOAuth.default_config_path, telemetry_logger: TelemetryLogger.new(config_path: config_path))
+    # Creates an object for model provider requests.
+    def initialize(api_key: ENV["OPENROUTER_API_KEY"], model: nil, openai_access_token: ENV["OPENAI_ACCESS_TOKEN"], oauth: OpenAIOAuth.new, github_oauth: GithubOAuth.new, anthropic_oauth: AnthropicOAuth.new, config_path: OpenAIOAuth.default_config_path, telemetry_logger: TelemetryLogger.new(config_path: config_path))
       @openrouter_api_key = presence(api_key)
       @openai_access_token = presence(openai_access_token)
       @oauth = oauth
       @github_oauth = github_oauth
+      @anthropic_oauth = anthropic_oauth
       @model = model
       @config_path = File.expand_path(config_path)
       @config = load_config
@@ -81,66 +95,48 @@ module Kward
       @openrouter_catalog = nil
     end
 
-    def chat(messages, tools: [], on_reasoning_delta: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, model: nil, reasoning: nil)
+    def chat(messages, tools: [], on_reasoning_delta: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
       cancellation&.raise_if_cancelled!
-      url, token, provider, account_id = credentials
-      raise auth_error_for(provider) if token.nil? || token.empty?
+      requested_provider = provider
+      url, token, resolved_provider, account_id = credentials(provider: requested_provider)
+      if token.to_s.empty? && !requested_provider.to_s.empty?
+        url, token, resolved_provider, account_id = credentials
+        model = nil
+        reasoning = nil
+      end
+      raise auth_error_for(resolved_provider) if token.nil? || token.empty?
 
-      current_model = model_for(provider, override_model: model)
-      current_model = resolved_copilot_chat_model(current_model) if provider == "Copilot" && model.nil?
+      current_model = model_for(resolved_provider, override_model: model)
+      current_model = resolved_copilot_chat_model(current_model) if resolved_provider == "Copilot" && model.nil?
 
-      validate_image_support!(provider, current_model, messages)
-      request_body = JSON.dump(request_body_payload(provider, messages, tools, max_tokens: max_tokens, model: current_model, reasoning: reasoning))
-      with_retries(provider, current_model, request_bytes: request_body.bytesize, on_retry: on_retry, cancellation: cancellation) do
+      validate_image_support!(resolved_provider, current_model, messages)
+      request_body = JSON.dump(request_body_payload(resolved_provider, messages, tools, max_tokens: max_tokens, model: current_model, reasoning: reasoning))
+      with_retries(resolved_provider, current_model, request_bytes: request_body.bytesize, on_retry: on_retry, cancellation: cancellation) do
         request_started_at = @telemetry_logger.monotonic_now
         message = nil
         status = "completed"
         error = nil
         begin
-        if provider == "Codex"
-          message = codex_chat(url, token, account_id, messages, tools, request_body: request_body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, max_tokens: max_tokens)
-          message = attach_response_metadata(message, provider: provider, model: current_model)
-          next message
-        end
-
-        if provider == "Copilot"
-          message = if copilot_responses_model?(current_model)
-                      copilot_responses_chat(token, request_body: request_body, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
-                    else
-                      copilot_chat(url, token, messages, tools, request_body: request_body, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
-                    end
-          message = attach_response_metadata(message, provider: provider, model: current_model)
-          next message
-        end
-
-        request = Net::HTTP::Post.new(url)
-        request["Authorization"] = "Bearer #{token}"
-        request["Content-Type"] = "application/json"
-        request.body = request_body
-
-        response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) do |http|
-          cancellation&.on_cancel { close_http(http) }
-          cancellation&.raise_if_cancelled!
-          http.request(request)
-        end
-        cancellation&.raise_if_cancelled!
-
-        unless response.is_a?(Net::HTTPSuccess)
-          raise RequestError.new(provider: provider, code: response.code, body: response.body)
-        end
-
-        body = JSON.parse(response.body)
-        message = body.fetch("choices").first.fetch("message")
-        cancellation&.raise_if_cancelled!
-        on_assistant_delta&.call(message.fetch("content", ""))
-        message = attach_response_metadata(message, provider: provider, model: current_model, usage: normalized_usage(body["usage"]))
-        message
+          message = chat_provider_request(
+            provider: resolved_provider,
+            url: url,
+            token: token,
+            account_id: account_id,
+            messages: messages,
+            tools: tools,
+            request_body: request_body,
+            current_model: current_model,
+            on_reasoning_delta: on_reasoning_delta,
+            on_assistant_delta: on_assistant_delta,
+            cancellation: cancellation,
+            max_tokens: max_tokens
+          )
         rescue StandardError => e
           status = "failed"
           error = e
           raise e
         ensure
-          log_model_request(provider: provider, model: current_model, request_bytes: request_body.bytesize, duration_ms: @telemetry_logger.duration_ms(request_started_at), status: status, error: error, usage: message && (message["usage"] || message[:usage]))
+          log_model_request(provider: resolved_provider, model: current_model, request_bytes: request_body.bytesize, duration_ms: @telemetry_logger.duration_ms(request_started_at), status: status, error: error, usage: message && (message["usage"] || message[:usage]))
         end
       end
     rescue *TRANSIENT_NETWORK_ERRORS => e
@@ -153,6 +149,7 @@ module Kward
       raise e
     end
 
+    # Returns the active provider label after applying env/config/credential fallback rules.
     def current_provider
       _url, _token, provider = credentials
       provider
@@ -163,58 +160,90 @@ module Kward
       openai_configured? ? "Codex" : "OpenRouter"
     end
 
+    # Returns the model id that will be used for the next request.
     def current_model
-      model_for(current_provider)
+      current_model_state[:model]
     end
 
+    # Returns the configured reasoning effort for providers that support it.
     def current_reasoning_effort
-      reasoning_effort(current_provider)
+      current_model_state[:reasoning_effort]
     end
 
+    # Returns the known context window for the active provider/model pair.
     def current_context_window
-      ModelInfo.context_window(current_provider, current_model)
+      state = current_model_state
+      ModelInfo.context_window(state[:provider], state[:model])
     end
 
+    # Returns model choices suitable for settings UIs.
+    #
+    # Only providers with configured credentials are listed. The active provider
+    # may use live catalog data. Inactive logged-in providers use static
+    # supported choices plus their configured model so listing models does not
+    # perform avoidable network calls for every configured credential.
     def available_models
       provider = current_provider
-      openai_model = model_for("Codex")
-      openrouter_model = model_for("OpenRouter")
-      copilot_model = model_for("Copilot")
-      openrouter_choices = openrouter_model_choices
-      copilot_choices = copilot_model_choices
-      models = ModelInfo::OPENAI_MODEL_CHOICES.map do |id|
-        { provider: "Codex", id: id, current: provider == "Codex" && openai_model == id }
+      models = []
+
+      if provider_logged_in?("Codex")
+        openai_model = model_for("Codex")
+        models += ModelInfo::OPENAI_MODEL_CHOICES.map do |id|
+          { provider: "Codex", id: id, current: provider == "Codex" && openai_model == id }
+        end
+        models << { provider: "Codex", id: openai_model, current: provider == "Codex" } unless ModelInfo::OPENAI_MODEL_CHOICES.include?(openai_model)
       end
-      models += openrouter_choices.map do |id|
-        { provider: "OpenRouter", id: id, current: provider == "OpenRouter" && openrouter_model == id }
+
+      if provider_logged_in?("OpenRouter")
+        openrouter_model = model_for("OpenRouter")
+        openrouter_choices = provider == "OpenRouter" ? openrouter_model_choices : ModelInfo::OPENROUTER_MODEL_CHOICES
+        models += openrouter_choices.map do |id|
+          { provider: "OpenRouter", id: id, current: provider == "OpenRouter" && openrouter_model == id }
+        end
+        models << { provider: "OpenRouter", id: openrouter_model, current: provider == "OpenRouter" } unless openrouter_choices.include?(openrouter_model)
       end
-      models += copilot_choices.map do |id|
-        { provider: "Copilot", id: id, current: provider == "Copilot" && copilot_model == id }
+
+      if provider_logged_in?("Copilot")
+        copilot_model = model_for("Copilot")
+        copilot_choices = provider == "Copilot" ? copilot_model_choices : static_copilot_model_choices
+        models += copilot_choices.map do |id|
+          { provider: "Copilot", id: id, current: provider == "Copilot" && copilot_model == id }
+        end
+        models << { provider: "Copilot", id: copilot_model, current: provider == "Copilot" } unless copilot_choices.include?(copilot_model)
+      end
+
+      if provider_logged_in?("Anthropic")
+        anthropic_model = model_for("Anthropic")
+        models += ModelInfo::ANTHROPIC_MODEL_CHOICES.map do |id|
+          { provider: "Anthropic", id: id, current: provider == "Anthropic" && anthropic_model == id }
+        end
+        models << { provider: "Anthropic", id: anthropic_model, current: provider == "Anthropic" } unless ModelInfo::ANTHROPIC_MODEL_CHOICES.include?(anthropic_model)
       end
-      models << { provider: "Codex", id: openai_model, current: provider == "Codex" } unless ModelInfo::OPENAI_MODEL_CHOICES.include?(openai_model)
-      models << { provider: "OpenRouter", id: openrouter_model, current: provider == "OpenRouter" } unless openrouter_choices.include?(openrouter_model)
-      models << { provider: "Copilot", id: copilot_model, current: provider == "Copilot" } unless copilot_choices.include?(copilot_model)
-      
+
       # Sort models by provider, then alphabetically by id
       models.sort_by { |model| [model[:provider], model[:id]] }
     end
 
+    # Fetches the full OpenRouter public model catalog for settings UIs.
     def openrouter_catalog
       fetch_openrouter_models(full_catalog: true).map do |id|
         { provider: "OpenRouter", id: id, current: current_provider == "OpenRouter" && model_for("OpenRouter") == id }
       end.sort_by { |model| model[:id] }
     end
 
+    # Projects messages/tools into the provider-specific context shape without sending it.
     def current_context_parts(messages, tools)
       build_context_parts(current_provider, messages, tools)
     end
 
+    # Returns whether the active provider can accept steering while a turn is streaming.
     def supports_in_flight_steer?
       current_provider == "Codex"
     rescue StandardError
       false
     end
 
+    # Reloads config-backed provider settings and clears live model catalog caches.
     def reload_config
       @config = load_config
       @copilot_models = nil
@@ -224,12 +253,147 @@ module Kward
 
     private
 
+    def current_model_state
+      provider = current_provider
+      {
+        provider: provider,
+        model: model_for(provider),
+        reasoning_effort: reasoning_effort(provider)
+      }
+    end
+
+    def chat_provider_request(provider:, url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:, max_tokens:)
+      case provider
+      when "Codex"
+        chat_codex_provider(
+          url: url,
+          token: token,
+          account_id: account_id,
+          messages: messages,
+          tools: tools,
+          request_body: request_body,
+          current_model: current_model,
+          on_reasoning_delta: on_reasoning_delta,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation,
+          max_tokens: max_tokens
+        )
+      when "Copilot"
+        chat_copilot_provider(
+          url: url,
+          token: token,
+          messages: messages,
+          tools: tools,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
+      when "Anthropic"
+        chat_anthropic_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_reasoning_delta: on_reasoning_delta,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
+      else
+        chat_openrouter_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
+      end
+    end
+
+    def chat_codex_provider(url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:, max_tokens:)
+      message = codex_chat(
+        url,
+        token,
+        account_id,
+        messages,
+        tools,
+        request_body: request_body,
+        on_reasoning_delta: on_reasoning_delta,
+        on_assistant_delta: on_assistant_delta,
+        cancellation: cancellation,
+        max_tokens: max_tokens
+      )
+      attach_response_metadata(message, provider: "Codex", model: current_model)
+    end
+
+    def chat_copilot_provider(url:, token:, messages:, tools:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      message = if copilot_responses_model?(current_model)
+                  copilot_responses_chat(token, request_body: request_body, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+                else
+                  copilot_chat(url, token, messages, tools, request_body: request_body, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+                end
+      attach_response_metadata(message, provider: "Copilot", model: current_model)
+    end
+
+    def chat_anthropic_provider(url:, token:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:)
+      request = Net::HTTP::Post.new(url)
+      request["Authorization"] = "Bearer #{token}"
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      anthropic_headers.each { |key, value| request[key] = value }
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: nil) do |http|
+        cancellation&.on_cancel { close_http(http) }
+        cancellation&.raise_if_cancelled!
+        http.request(request) do |response|
+          unless response.is_a?(Net::HTTPSuccess)
+            body = +""
+            response.read_body { |chunk| body << chunk }
+            raise RequestError.new(provider: "Anthropic", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_anthropic_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Anthropic", model: current_model)
+    end
+
+    def chat_openrouter_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      request = Net::HTTP::Post.new(url)
+      request["Authorization"] = "Bearer #{token}"
+      request["Content-Type"] = "application/json"
+      request.body = request_body
+
+      response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) do |http|
+        cancellation&.on_cancel { close_http(http) }
+        cancellation&.raise_if_cancelled!
+        http.request(request)
+      end
+      cancellation&.raise_if_cancelled!
+
+      unless response.is_a?(Net::HTTPSuccess)
+        raise RequestError.new(provider: "OpenRouter", code: response.code, body: response.body)
+      end
+
+      body = JSON.parse(response.body)
+      message = body.fetch("choices").first.fetch("message")
+      cancellation&.raise_if_cancelled!
+      on_assistant_delta&.call(message.fetch("content", ""))
+      attach_response_metadata(message, provider: "OpenRouter", model: current_model, usage: normalized_usage(body["usage"]))
+    end
+
     def auth_error_for(provider)
       case provider
       when "OpenRouter"
         OPENROUTER_AUTH_ERROR
       when "Copilot"
         COPILOT_AUTH_ERROR
+      when "Anthropic"
+        ANTHROPIC_AUTH_ERROR
       else
         AUTH_ERROR
       end
@@ -313,8 +477,12 @@ module Kward
     end
 
     def request_body_payload(provider, messages, tools, max_tokens: nil, model: nil, reasoning: nil)
+      reasoning = false unless ModelInfo.reasoning_supported?(provider, model)
+
       if provider == "Codex"
         codex_payload(messages, tools, max_tokens: max_tokens, model: model, reasoning: reasoning)
+      elsif provider == "Anthropic"
+        anthropic_payload(messages, tools, max_tokens: max_tokens, model: model, reasoning: reasoning)
       elsif provider == "Copilot" && copilot_responses_model?(model)
         copilot_responses_payload(messages, tools, max_tokens: max_tokens, model: model, reasoning: reasoning)
       else
@@ -357,9 +525,7 @@ module Kward
     end
 
     def parse_openrouter_models(body)
-      data = JSON.parse(body.to_s)
-      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
-      Array(entries).filter_map do |entry|
+      model_catalog_entries(body).filter_map do |entry|
         if entry.is_a?(Hash)
           entry["id"] || entry[:id] || entry["slug"] || entry[:slug]
         else
@@ -370,7 +536,16 @@ module Kward
 
     def copilot_model_choices
       live_models = fetch_copilot_models
-      choices = live_models.empty? ? ModelInfo::COPILOT_MODEL_CHOICES : live_models
+      return static_copilot_model_choices if live_models.empty?
+
+      supported_copilot_model_choices(live_models)
+    end
+
+    def static_copilot_model_choices
+      supported_copilot_model_choices(ModelInfo::COPILOT_MODEL_CHOICES)
+    end
+
+    def supported_copilot_model_choices(choices)
       choices.select { |model| copilot_supported_model?(model) }.uniq
     end
 
@@ -410,15 +585,19 @@ module Kward
     end
 
     def parse_copilot_models(body)
-      data = JSON.parse(body.to_s)
-      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
-      Array(entries).filter_map do |entry|
+      model_catalog_entries(body).filter_map do |entry|
         copilot_model_id(entry)
       end.uniq
     rescue JSON::ParserError
       []
     end
 
+    def model_catalog_entries(body)
+      data = JSON.parse(body.to_s)
+      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
+      Array(entries)
+    end
+
     def copilot_model_id(entry)
       return entry.to_s.strip unless entry.is_a?(Hash)
       return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
@@ -495,6 +674,16 @@ module Kward
       ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage))
     end
 
+    def anthropic_headers
+      {
+        "anthropic-version" => "2023-06-01",
+        "anthropic-beta" => "claude-code-20250219,oauth-2025-04-20",
+        "anthropic-dangerous-direct-browser-access" => "true",
+        "user-agent" => "claude-cli/2.1.75",
+        "x-app" => "cli"
+      }
+    end
+
     def copilot_headers(messages)
       headers = GithubOAuth::COPILOT_HEADERS.dup
       headers["X-Initiator"] = copilot_initiator(messages)
@@ -549,6 +738,10 @@ module Kward
       ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
 
+    def parse_anthropic_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)
+      ModelStreamParser.parse_anthropic_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+    end
+
     def close_http(http)
       http.finish if http&.started?
     rescue IOError
@@ -572,9 +765,9 @@ module Kward
       cache_read_tokens = positive_integer(
         nested_value(usage, "input_tokens_details", "cached_tokens") ||
         nested_value(usage, "prompt_tokens_details", "cached_tokens") ||
-        usage["cache_read_tokens"] || usage[:cache_read_tokens] || usage["cacheReadTokens"] || usage[:cacheReadTokens]
+        usage["cache_read_tokens"] || usage[:cache_read_tokens] || usage["cacheReadTokens"] || usage[:cacheReadTokens] || usage["cache_read_input_tokens"] || usage[:cache_read_input_tokens]
       )
-      cache_write_tokens = integer_value(usage, "cache_write_tokens", "cacheWriteTokens")
+      cache_write_tokens = integer_value(usage, "cache_write_tokens", "cacheWriteTokens", "cache_creation_input_tokens")
       total_tokens = integer_value(usage, "total_tokens", "totalTokens")
       total_tokens ||= [input_tokens, output_tokens, cache_read_tokens, cache_write_tokens].compact.sum
       return nil unless total_tokens&.positive? || input_tokens&.positive? || output_tokens&.positive?
@@ -610,12 +803,16 @@ module Kward
       integer.positive? ? integer : nil
     end
 
-    def credentials
-      provider = ModelInfo.provider_label(configured_provider)
+    def credentials(provider: nil)
+      provider = provider.to_s.empty? ? ModelInfo.provider_label(configured_provider) : ModelInfo.provider_label(provider)
       if provider == "Copilot"
         return [copilot_chat_url, github_access_token, provider, nil]
       end
 
+      if provider == "Anthropic"
+        return [ANTHROPIC_URL, anthropic_access_token, provider, nil]
+      end
+
       if provider == "OpenRouter"
         return [OPENROUTER_URL, openrouter_api_key, provider, nil]
       end
@@ -638,6 +835,23 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def provider_logged_in?(provider)
+      case provider
+      when "Codex"
+        openai_configured?
+      when "OpenRouter"
+        !openrouter_api_key.to_s.empty?
+      when "Copilot"
+        !github_access_token.to_s.empty?
+      when "Anthropic"
+        !anthropic_access_token.to_s.empty?
+      else
+        false
+      end
+    rescue StandardError
+      false
+    end
+
     def openai_configured?
       !@openai_access_token.to_s.empty? || @oauth.access_token.to_s != ""
     rescue StandardError
@@ -652,6 +866,10 @@ module Kward
       @github_oauth.access_token
     end
 
+    def anthropic_access_token
+      @anthropic_oauth.access_token
+    end
+
     def copilot_chat_url
       URI("#{@github_oauth.base_url}/chat/completions")
     end

data/lib/kward/model/context_overflow.rb

@@ -1,4 +1,6 @@
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Detects provider errors caused by context-window overflow.
   module ContextOverflow
     OVERFLOW_PATTERNS = [
       /prompt is too long/i,

data/lib/kward/model/context_usage.rb

@@ -1,7 +1,9 @@
 require "json"
 require_relative "../message_access"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Estimates provider context usage and compaction pressure.
   class ContextUsage
     OPENAI_CONTEXT_PROVIDERS = ["Codex", "OpenAI"].freeze
 
@@ -78,6 +80,7 @@ module Kward
     end
   end
 
+  # Structured context usage result returned to frontends.
   class TiktokenTokenCounter
     def count(text, model:)
       encoding(model).encode(text.to_s).length