kward 0.78.0 → 0.80.0

data/lib/kward/model/client.rb

@@ -2,6 +2,7 @@ require "json"
 require "net/http"
 require "uri"
 require_relative "../auth/anthropic_oauth"
+require_relative "../auth/api_key_store"
 require_relative "../auth/github_oauth"
 require_relative "../auth/openai_oauth"
 require_relative "../cancellation"
@@ -9,8 +10,10 @@ require_relative "../config_files"
 require_relative "../http"
 require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
+require_relative "azure_openai_config"
 require_relative "copilot_models"
 require_relative "model_info"
+require_relative "sources"
 require_relative "payloads"
 require_relative "../telemetry/logger"
 require_relative "stream_parser"
@@ -29,8 +32,15 @@ module Kward
     OPENROUTER_URL = URI("https://openrouter.ai/api/v1/chat/completions")
     CODEX_URL = URI("https://chatgpt.com/backend-api/codex/responses")
     ANTHROPIC_URL = URI("https://api.anthropic.com/v1/messages")
+    LOCAL_BASE_URLS = {
+      "ollama" => "http://127.0.0.1:11434/v1",
+      "lm_studio" => "http://127.0.0.1:1234/v1",
+      "llama_cpp" => "http://127.0.0.1:8080/v1"
+    }.freeze
     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."
+    OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or sign in with an API key."
+    OPENAI_API_AUTH_ERROR = "No OpenAI API key found. Set OPENAI_API_KEY or sign in with an API key."
+    AZURE_OPENAI_AUTH_ERROR = "No Azure OpenAI API key found. Set AZURE_OPENAI_API_KEY or sign in with an API key."
     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
@@ -82,7 +92,7 @@ module Kward
     TRANSIENT_NETWORK_ERRORS = [IOError, EOFError, SystemCallError, Net::OpenTimeout, Net::ReadTimeout].freeze
 
     # 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))
+    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, api_key_store: nil, 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
@@ -90,22 +100,24 @@ module Kward
       @anthropic_oauth = anthropic_oauth
       @model = model
       @config_path = File.expand_path(config_path)
+      @api_key_store = api_key_store || APIKeyStore.new(path: File.join(File.dirname(@config_path), "api_keys.json"), config_path: @config_path)
       @config = load_config
       @telemetry_logger = telemetry_logger
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: 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!
       requested_provider = provider
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && !requested_provider.to_s.empty?
+      if token.to_s.empty? && authentication_required?(resolved_provider) && !requested_provider.to_s.empty? && resolved_provider != "OpenAI"
         url, token, resolved_provider, account_id = credentials
         model = nil
         reasoning = nil
       end
-      raise auth_error_for(resolved_provider) if token.nil? || token.empty?
+      raise auth_error_for(resolved_provider) if authentication_required?(resolved_provider) && (token.nil? || token.empty?)
 
       current_model = model_for(resolved_provider, override_model: model)
       current_model = resolved_copilot_chat_model(current_model) if resolved_provider == "Copilot" && model.nil?
@@ -180,7 +192,10 @@ module Kward
 
     # Returns the known context window for a provider/model pair.
     def context_window(provider, model)
-      context_window_for(ModelInfo.provider_label(provider), model)
+      provider = ModelInfo.provider_label(provider)
+      return local_context_window if provider == "Local"
+
+      context_window_for(provider, model)
     end
 
     # Returns model choices suitable for settings UIs.
@@ -205,7 +220,8 @@ module Kward
         openrouter_model = model_for("OpenRouter")
         openrouter_choices = openrouter_model_choices
         models += openrouter_choices.map do |id|
-          model_entry("OpenRouter", id, current: provider == "OpenRouter" && openrouter_model == id)
+          metadata = openrouter_cached_model_entries.find { |entry| (entry["id"] || entry[:id]).to_s == id }
+          model_entry("OpenRouter", id, current: provider == "OpenRouter" && openrouter_model == id, metadata: metadata)
         end
       end
 
@@ -226,10 +242,42 @@ module Kward
         models << model_entry("Anthropic", anthropic_model, current: provider == "Anthropic") unless ModelInfo::ANTHROPIC_MODEL_CHOICES.include?(anthropic_model)
       end
 
+      ProviderCatalog.api_key_providers.each do |catalog_provider|
+        next unless ["openai_chat", "openai_responses", "gemini", "azure_openai"].include?(catalog_provider.protocol)
+        next if catalog_provider.id == "openrouter"
+        next unless provider_logged_in?(catalog_provider.name)
+
+        selected_model = model_for(catalog_provider.name)
+        provider_models = ModelSources.new(provider_id: catalog_provider.id, api_key: @api_key_store.fetch(catalog_provider.id)).models
+        provider_models.each do |entry|
+          models << model_entry(catalog_provider.name, entry.fetch("id"), current: provider == catalog_provider.name && selected_model == entry.fetch("id"), metadata: entry)
+        end
+        models << model_entry(catalog_provider.name, selected_model, current: provider == catalog_provider.name) unless selected_model.to_s.empty? || provider_models.any? { |entry| entry.fetch("id") == selected_model }
+      end
+
+      if provider_logged_in?("Local")
+        local_model = model_for("Local")
+        local_model_choices.each do |id|
+          models << model_entry("Local", id, current: provider == "Local" && local_model == id)
+        end
+        models << model_entry("Local", local_model, current: provider == "Local") unless local_model.to_s.empty? || local_model_choices.include?(local_model)
+      end
+
       # Sort models by provider, then alphabetically by id
       models.sort_by { |model| [model[:provider], model[:id]] }
     end
 
+    # Refreshes cached choices for an API-key provider.
+    def refresh_available_models(provider: nil)
+      provider ||= current_provider
+      catalog_provider = ProviderCatalog.find_by_name(provider) || ProviderCatalog.find(provider.to_s.downcase)
+      return available_models unless catalog_provider&.api_key?
+      return available_models unless ProviderCatalog.runtime(catalog_provider.id).automatic_model_discovery?
+
+      ModelSources.new(provider_id: catalog_provider.id, api_key: @api_key_store.fetch(catalog_provider.id)).refresh
+      available_models
+    end
+
     # Projects messages/tools into the provider-specific context shape without sending it.
     def current_context_parts(messages, tools, provider: current_provider, model: nil)
       build_context_parts(ModelInfo.provider_label(provider), messages, tools, model: model)
@@ -247,6 +295,7 @@ module Kward
       @config = load_config
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     private
@@ -262,6 +311,34 @@ module Kward
 
     def chat_provider_request(provider:, url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_reasoning_boundary:, on_assistant_delta:, cancellation:, max_tokens:)
       case provider
+      when "Azure OpenAI"
+        chat_azure_openai_provider(
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
+      when "Google Gemini"
+        chat_gemini_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
+      when "OpenAI"
+        chat_openai_responses_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_reasoning_delta: on_reasoning_delta,
+          on_reasoning_boundary: on_reasoning_boundary,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
       when "Codex"
         chat_codex_provider(
           url: url,
@@ -298,10 +375,20 @@ module Kward
           on_assistant_delta: on_assistant_delta,
           cancellation: cancellation
         )
+      when "Local"
+        chat_local_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
       else
         chat_openrouter_provider(
           url: url,
           token: token,
+          provider: provider,
           request_body: request_body,
           current_model: current_model,
           on_assistant_delta: on_assistant_delta,
@@ -310,6 +397,95 @@ module Kward
       end
     end
 
+    def chat_azure_openai_provider(token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      request_url = azure_openai_config(deployment: current_model).chat_completions_url
+      request = Http.apply_user_agent(Net::HTTP::Post.new(request_url))
+      request["api-key"] = token
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(request_url.hostname, request_url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) 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: "Azure OpenAI", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, provider_label: "Azure OpenAI")
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Azure OpenAI", model: current_model)
+    end
+
+    def chat_gemini_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      model = current_model.to_s.delete_prefix("models/")
+      request_url = URI("#{url.to_s.sub(%r{/+\z}, "")}/models/#{URI.encode_www_form_component(model)}:streamGenerateContent?alt=sse")
+      request = Http.apply_user_agent(Net::HTTP::Post.new(request_url))
+      request["x-goog-api-key"] = token
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(request_url.hostname, request_url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) 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: "Google Gemini", code: response.code, body: redact(body, token))
+          end
+
+          message = ModelStreamParser.parse_gemini_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:gemini_usage))
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Google Gemini", model: current_model)
+    end
+
+    def gemini_usage(usage)
+      return nil unless usage.is_a?(Hash)
+
+      normalized_usage(
+        "input_tokens" => usage["promptTokenCount"],
+        "output_tokens" => usage["candidatesTokenCount"],
+        "cache_read_tokens" => usage["cachedContentTokenCount"],
+        "total_tokens" => usage["totalTokenCount"]
+      )
+    end
+
+    def chat_openai_responses_provider(url:, token:, request_body:, current_model:, on_reasoning_delta:, on_reasoning_boundary:, on_assistant_delta:, cancellation:)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
+      request["Authorization"] = "Bearer #{token}"
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) 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: "OpenAI", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_responses_sse_stream(response, provider: "OpenAI", on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "OpenAI", model: current_model)
+    end
+
     def chat_codex_provider(url:, token:, account_id:, messages:, tools:, request_body:, current_model:, on_reasoning_delta:, on_reasoning_boundary:, on_assistant_delta:, cancellation:, max_tokens:)
       message = codex_chat(
         url,
@@ -338,10 +514,14 @@ module Kward
 
     def chat_anthropic_provider(url:, token:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:)
       request = Http.apply_user_agent(Net::HTTP::Post.new(url))
-      request["Authorization"] = "Bearer #{token}"
+      if anthropic_api_key
+        request["x-api-key"] = token
+      else
+        request["Authorization"] = "Bearer #{token}"
+      end
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
-      anthropic_headers.each { |key, value| request[key] = value }
+      anthropic_headers(api_key: !anthropic_api_key.nil?).each { |key, value| request[key] = value }
       request.body = request_body
 
       message = nil
@@ -362,7 +542,32 @@ module Kward
       attach_response_metadata(message, provider: "Anthropic", model: current_model)
     end
 
-    def chat_openrouter_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+    def chat_local_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
+      request["Authorization"] = "Bearer #{token}" unless token.to_s.empty?
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) 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: "Local", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, provider_label: "Local")
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Local", model: current_model)
+    end
+
+    def chat_openrouter_provider(url:, token:, provider: "OpenRouter", request_body:, current_model:, on_assistant_delta:, cancellation:)
       request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Content-Type"] = "application/json"
@@ -376,18 +581,23 @@ module Kward
       cancellation&.raise_if_cancelled!
 
       unless response.is_a?(Net::HTTPSuccess)
-        raise RequestError.new(provider: "OpenRouter", code: response.code, body: response.body)
+        body = provider == "OpenRouter" ? response.body : redact(response.body, token)
+        raise RequestError.new(provider: provider, code: response.code, body: 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"]))
+      attach_response_metadata(message, provider: provider, model: current_model, usage: normalized_usage(body["usage"]))
     end
 
     def auth_error_for(provider)
       case provider
+      when "Azure OpenAI"
+        AZURE_OPENAI_AUTH_ERROR
+      when "OpenAI"
+        OPENAI_API_AUTH_ERROR
       when "OpenRouter"
         OPENROUTER_AUTH_ERROR
       when "Copilot"
@@ -479,7 +689,13 @@ module Kward
     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"
+      if provider == "Azure OpenAI"
+        request_payload(provider, messages, tools, max_tokens: max_tokens, model: model, reasoning: false).merge(stream: true, stream_options: { include_usage: true })
+      elsif provider == "Google Gemini"
+        gemini_payload(messages, tools, max_tokens: max_tokens, model: model)
+      elsif provider == "OpenAI"
+        openai_responses_payload(messages, tools, max_tokens: max_tokens, model: model, reasoning: reasoning)
+      elsif 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)
@@ -494,19 +710,43 @@ module Kward
       model.to_s.match?(/\Agpt-5(?:\.|-|\z)/)
     end
 
-    def model_entry(provider, id, current: false)
+    def model_entry(provider, id, current: false, metadata: nil)
+      metadata ||= {}
       {
         provider: provider,
         id: id,
         current: current,
-        contextWindow: context_window_for(provider, id)
+        contextWindow: metadata["contextWindow"] || metadata[:contextWindow] || context_window_for(provider, id),
+        supportedParameters: metadata["supportedParameters"] || metadata[:supportedParameters],
+        source: metadata["source"] || metadata[:source]
       }.compact
     end
 
     def context_window_for(provider, id)
+      return local_context_window if provider == "Local"
+
       ModelInfo.context_window(provider, id, openrouter_models: openrouter_cached_model_entries)
     end
 
+    def local_model_choices
+      return @local_models if @local_models
+
+      url = local_models_url
+      request = Http.apply_user_agent(Net::HTTP::Get.new(url))
+      request["Authorization"] = "Bearer #{local_api_key}" unless local_api_key.to_s.empty?
+      request["Accept"] = "application/json"
+      response = Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) { |http| http.request(request) }
+      return @local_models = [] unless response.is_a?(Net::HTTPSuccess)
+
+      body = JSON.parse(response.body)
+      entries = body["data"] || body["models"] || []
+      @local_models = Array(entries).filter_map do |entry|
+        entry.is_a?(Hash) ? entry["id"] || entry[:id] || entry["model"] || entry[:model] : entry
+      end.map(&:to_s).map(&:strip).reject(&:empty?).uniq
+    rescue StandardError
+      @local_models = []
+    end
+
     def openrouter_model_choices
       openrouter_cached_models.uniq
     end
@@ -627,16 +867,22 @@ module Kward
     end
 
     def parse_openai_chat_sse(body, on_assistant_delta: nil)
-      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage))
+      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage), provider_label: "Copilot")
     end
 
-    def anthropic_headers
-      {
-        "anthropic-version" => "2023-06-01",
+    def parse_openai_chat_sse_stream(response, on_assistant_delta: nil, cancellation: nil, provider_label: "OpenAI-compatible provider")
+      ModelStreamParser.parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), provider_label: provider_label)
+    end
+
+    def anthropic_headers(api_key: false)
+      headers = { "anthropic-version" => "2023-06-01" }
+      return headers if api_key
+
+      headers.merge(
         "anthropic-beta" => "claude-code-20250219,oauth-2025-04-20",
         "anthropic-dangerous-direct-browser-access" => "true",
         "x-app" => "cli"
-      }
+      )
     end
 
     def copilot_headers(messages)
@@ -706,7 +952,11 @@ module Kward
     end
 
     def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil)
-      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+      parse_responses_sse_stream(response, provider: "Codex", on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation)
+    end
+
+    def parse_responses_sse_stream(response, provider:, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil)
+      ModelStreamParser.parse_codex_sse_stream(response, provider_label: provider, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, cancellation: cancellation, show_raw_reasoning: codex_show_raw_reasoning?, 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)
@@ -776,6 +1026,10 @@ module Kward
 
     def credentials(provider: nil)
       provider = provider.to_s.empty? ? ModelInfo.provider_label(configured_provider) : ModelInfo.provider_label(provider)
+      if provider == "Local"
+        return [local_chat_url, local_api_key, provider, nil]
+      end
+
       if provider == "Copilot"
         return [copilot_chat_url, github_access_token, provider, nil]
       end
@@ -788,6 +1042,25 @@ module Kward
         return [OPENROUTER_URL, openrouter_api_key, provider, nil]
       end
 
+      if provider == "OpenAI"
+        runtime = ProviderCatalog.runtime("openai")
+        return [URI(runtime.chat_url), @api_key_store.fetch("openai"), provider, nil]
+      end
+
+      if provider == "Google Gemini"
+        runtime = ProviderCatalog.runtime("gemini")
+        return [URI(runtime.chat_url), @api_key_store.fetch("gemini"), provider, nil]
+      end
+
+      if provider == "Azure OpenAI"
+        return [azure_openai_config.chat_completions_url, @api_key_store.fetch("azure_openai"), provider, nil]
+      end
+
+      if (catalog_provider = ProviderCatalog.find_by_name(provider)) && catalog_provider.protocol == "openai_chat"
+        runtime = ProviderCatalog.runtime(catalog_provider.id)
+        return [URI(runtime.chat_url), @api_key_store.fetch(catalog_provider.id), provider, nil]
+      end
+
       openai_token = @openai_access_token || @oauth.access_token
       if openai_token
         [CODEX_URL, openai_token, "Codex", @oauth.respond_to?(:account_id) ? @oauth.account_id : nil]
@@ -806,8 +1079,14 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def authentication_required?(provider)
+      provider != "Local"
+    end
+
     def provider_logged_in?(provider)
       case provider
+      when "Local"
+        local_configured?
       when "Codex"
         openai_configured?
       when "OpenRouter"
@@ -817,7 +1096,8 @@ module Kward
       when "Anthropic"
         !anthropic_access_token.to_s.empty?
       else
-        false
+        catalog_provider = ProviderCatalog.find_by_name(provider)
+        catalog_provider&.api_key? && !@api_key_store.fetch(catalog_provider.id).to_s.empty?
       end
     rescue StandardError
       false
@@ -829,8 +1109,55 @@ module Kward
       false
     end
 
+    def local_configured?
+      configured_provider == "local" || !local_model.to_s.empty? || !config_value("local_base_url").to_s.empty? || !ENV["KWARD_LOCAL_BASE_URL"].to_s.empty?
+    end
+
+    def local_model
+      ENV["KWARD_LOCAL_MODEL"] || config_value("local_model")
+    end
+
+    def local_context_window
+      value = ENV["KWARD_LOCAL_CONTEXT_WINDOW"] || config_value("local_context_window")
+      positive_integer(value)
+    end
+
+    def local_api_key
+      ENV["KWARD_LOCAL_API_KEY"] || config_value("local_api_key")
+    end
+
+    def local_backend
+      presence(ENV["KWARD_LOCAL_BACKEND"].to_s.strip) || presence(config_value("local_backend").to_s.strip) || "ollama"
+    end
+
+    def local_base_url
+      configured = presence(ENV["KWARD_LOCAL_BASE_URL"].to_s.strip) || presence(config_value("local_base_url").to_s.strip)
+      return configured if configured
+
+      LOCAL_BASE_URLS.fetch(local_backend) { raise "Unknown local model backend: #{local_backend}" }
+    end
+
+    def local_chat_url
+      local_url("chat/completions")
+    end
+
+    def local_models_url
+      local_url("models")
+    end
+
+    def local_url(path)
+      base = URI.parse(local_base_url)
+      unless base.is_a?(URI::HTTP) && base.host && !base.host.empty? && base.user.nil? && base.password.nil? && base.query.nil? && base.fragment.nil?
+        raise "Invalid local model URL: #{local_base_url}"
+      end
+
+      URI("#{base.to_s.sub(%r{/+\z}, "")}/#{path}")
+    rescue URI::InvalidURIError
+      raise "Invalid local model URL: #{local_base_url}"
+    end
+
     def openrouter_api_key
-      @openrouter_api_key || config_value("openrouter_api_key")
+      @openrouter_api_key || @api_key_store.stored_value("openrouter") || config_value("openrouter_api_key")
     end
 
     def github_access_token
@@ -838,13 +1165,25 @@ module Kward
     end
 
     def anthropic_access_token
-      @anthropic_oauth.access_token
+      anthropic_api_key || @anthropic_oauth.access_token
+    end
+
+    def anthropic_api_key
+      @api_key_store.fetch("anthropic")
     end
 
     def copilot_chat_url
       URI("#{@github_oauth.base_url}/chat/completions")
     end
 
+    def azure_openai_config(deployment: nil)
+      AzureOpenAIConfig.new(
+        endpoint: config_value("azure_openai_endpoint"),
+        deployment: deployment || config_value("azure_openai_model"),
+        api_version: config_value("azure_openai_api_version")
+      )
+    end
+
     def configured_provider
       value = ENV["KWARD_PROVIDER"].to_s.strip
       value = config_value("provider") if value.empty?
@@ -869,6 +1208,8 @@ module Kward
     end
 
     def redact(text, token)
+      return text.to_s if token.to_s.empty?
+
       text.to_s.gsub(token.to_s, "[REDACTED]")
     end