kward 0.79.0 → 0.80.1

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"
@@ -35,7 +38,9 @@ module Kward
       "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
@@ -87,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
@@ -95,6 +100,7 @@ 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
@@ -106,7 +112,7 @@ module Kward
       cancellation&.raise_if_cancelled!
       requested_provider = provider
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && authentication_required?(resolved_provider) && !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
@@ -214,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
 
@@ -235,6 +242,19 @@ 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|
@@ -247,6 +267,17 @@ module Kward
       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)
@@ -280,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,
@@ -329,6 +388,7 @@ module Kward
         chat_openrouter_provider(
           url: url,
           token: token,
+          provider: provider,
           request_body: request_body,
           current_model: current_model,
           on_assistant_delta: on_assistant_delta,
@@ -337,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,
@@ -365,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
@@ -414,7 +567,7 @@ module Kward
       attach_response_metadata(message, provider: "Local", model: current_model)
     end
 
-    def chat_openrouter_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+    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"
@@ -428,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"
@@ -531,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)
@@ -546,12 +710,15 @@ 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
 
@@ -707,13 +874,15 @@ module Kward
       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
-      {
-        "anthropic-version" => "2023-06-01",
+    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)
@@ -783,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)
@@ -869,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]
@@ -904,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
@@ -964,7 +1157,7 @@ module Kward
     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
@@ -972,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?

data/lib/kward/model/model_info.rb

@@ -1,4 +1,5 @@
 require_relative "../config_files"
+require_relative "provider_catalog"
 
 # Namespace for the Kward CLI agent runtime.
 module Kward
@@ -127,6 +128,17 @@ module Kward
     def model_for(provider, config:, override_model: nil, env: ENV)
       return override_model if override_model
 
+      if provider_label(provider) == "OpenAI"
+        runtime = ProviderCatalog.runtime("openai")
+        return env["OPENAI_API_MODEL"] || ConfigFiles.config_value(config, runtime.model_config_key) || DEFAULT_OPENAI_MODEL
+      end
+
+      catalog_provider = ProviderCatalog.find_by_name(provider) || ProviderCatalog.find(provider.to_s.downcase)
+      if catalog_provider && !["anthropic", "openrouter", "copilot"].include?(catalog_provider.id)
+        runtime = ProviderCatalog.runtime(catalog_provider.id)
+        return env["#{catalog_provider.id.upcase}_MODEL"] || ConfigFiles.config_value(config, runtime.model_config_key, "model")
+      end
+
       case provider
       when "Local"
         env["KWARD_LOCAL_MODEL"] || ConfigFiles.config_value(config, "local_model")
@@ -176,6 +188,11 @@ module Kward
     end
 
     def reasoning_effort(config:, env: ENV, provider: nil)
+      if provider_label(provider) == "OpenAI"
+        runtime = ProviderCatalog.runtime("openai")
+        return env["OPENAI_API_REASONING_EFFORT"] || ConfigFiles.config_value(config, runtime.reasoning_config_key) || DEFAULT_REASONING_EFFORT
+      end
+
       case provider.to_s
       when "Local"
         nil
@@ -191,6 +208,11 @@ module Kward
     end
 
     def provider_label(provider)
+      return "OpenAI" if provider.to_s == "OpenAI" || provider.to_s.downcase == "openai_api"
+
+      catalog_provider = ProviderCatalog.find(provider.to_s.downcase) || ProviderCatalog.find_by_name(provider)
+      return catalog_provider.name if catalog_provider && !["openai", "copilot"].include?(catalog_provider.id)
+
       case provider.to_s.downcase
       when "openrouter" then "OpenRouter"
       when "copilot" then "Copilot"
@@ -202,6 +224,11 @@ module Kward
     end
 
     def provider_config_value(provider)
+      return ProviderCatalog.runtime("openai").id if provider_label(provider) == "OpenAI"
+
+      catalog_provider = ProviderCatalog.find(provider.to_s.downcase) || ProviderCatalog.find_by_name(provider)
+      return ProviderCatalog.runtime(catalog_provider.id).id if catalog_provider && catalog_provider.id != "openai"
+
       case provider.to_s.downcase
       when "openrouter" then "openrouter"
       when "copilot" then "copilot"
@@ -212,6 +239,11 @@ module Kward
     end
 
     def config_key_for_provider(provider)
+      return ProviderCatalog.runtime("openai").model_config_key if provider_label(provider) == "OpenAI"
+
+      catalog_provider = ProviderCatalog.find(provider.to_s.downcase) || ProviderCatalog.find_by_name(provider)
+      return ProviderCatalog.runtime(catalog_provider.id).model_config_key if catalog_provider && catalog_provider.id != "openai"
+
       case provider.to_s.downcase
       when "openrouter" then "openrouter_model"
       when "copilot" then "copilot_model"
@@ -222,6 +254,11 @@ module Kward
     end
 
     def reasoning_config_key_for_provider(provider)
+      return ProviderCatalog.runtime("openai").reasoning_config_key if provider_label(provider) == "OpenAI"
+
+      catalog_provider = ProviderCatalog.find(provider.to_s.downcase) || ProviderCatalog.find_by_name(provider)
+      return ProviderCatalog.runtime(catalog_provider.id).reasoning_config_key if catalog_provider && catalog_provider.id != "openai"
+
       case provider.to_s.downcase
       when "openrouter" then "openrouter_reasoning_effort"
       when "copilot" then "copilot_reasoning_effort"
@@ -244,6 +281,16 @@ module Kward
 
     def context_window(provider, id, openrouter_models: nil)
       case provider
+      when "Azure OpenAI"
+        pattern_context_window(OPENAI_CONTEXT_WINDOWS, id) ||
+          conservative_unknown_context_window(id)
+      when "Google Gemini"
+        pattern_context_window(GEMINI_CONTEXT_WINDOWS, id.to_s.delete_prefix("models/")) ||
+          conservative_unknown_context_window(id)
+      when "OpenAI"
+        pattern_context_window(OPENAI_CONTEXT_WINDOWS, id) ||
+          conservative_context_window(id) ||
+          conservative_unknown_context_window(id)
       when "Codex"
         pattern_context_window(CODEX_CONTEXT_WINDOWS, id) ||
           openrouter_inferred_context_window(provider, id, openrouter_models: openrouter_models) ||
@@ -427,6 +474,8 @@ module Kward
         reasoning: reasoning,
         reasoningEffort: reasoning_effort,
         contextWindow: model["contextWindow"] || model["context_window"] || context_window(provider, id),
+        supportedParameters: model["supportedParameters"] || model["supported_parameters"],
+        source: model["source"],
         current: boolean_value(model["current"], default: provider == current_provider && id == current_model)
       }.compact
     end

data/lib/kward/model/payloads.rb

@@ -114,8 +114,67 @@ module Kward
       payload
     end
 
+    def gemini_payload(messages, tools, max_tokens: nil, model: nil)
+      system_parts = messages.filter_map do |message|
+        plain_content(MessageAccess.content(message)).to_s if MessageAccess.role(message).to_s == "system"
+      end.reject(&:empty?).map { |text| { text: text } }
+      payload = {
+        contents: messages.filter_map { |message| gemini_message(message) },
+        tools: tools.empty? ? nil : [{ functionDeclarations: tools.map { |tool| gemini_tool_schema(tool) } }]
+      }.compact
+      payload[:systemInstruction] = { parts: system_parts } unless system_parts.empty?
+      payload[:generationConfig] = { maxOutputTokens: max_tokens.to_i } if max_tokens.to_i.positive?
+      payload
+    end
+
+    def gemini_message(message)
+      role = MessageAccess.role(message).to_s
+      content = MessageAccess.content(message)
+      case role
+      when "system"
+        nil
+      when "assistant", "compactionSummary"
+        parts = []
+        text = role == "compactionSummary" ? MessageAccess.summary(message) || content.to_s : plain_content(content).to_s
+        parts << { text: text } unless text.empty?
+        MessageAccess.tool_calls(message).each do |tool_call|
+          function = ToolCall.function(tool_call)
+          parts << { functionCall: { name: ToolCall.value(function, :name), args: parse_tool_arguments(ToolCall.value(function, :arguments)) } }
+        end
+        { role: "model", parts: parts }
+      when "tool", "toolResult"
+        name = MessageAccess.tool_name(message) || MessageAccess.tool_call_id(message) || "tool"
+        response = JSON.parse(plain_content(content).to_s)
+        response = { "result" => response } unless response.is_a?(Hash)
+        { role: "user", parts: [{ functionResponse: { name: name, response: response } }] }
+      else
+        { role: "user", parts: [{ text: plain_content(content).to_s }] }
+      end
+    rescue JSON::ParserError
+      { role: "user", parts: [{ functionResponse: { name: name, response: { result: plain_content(content).to_s } } }] }
+    end
+
+    def gemini_tool_schema(tool)
+      function = ToolCall.function(tool)
+      {
+        name: ToolCall.value(function, :name),
+        description: ToolCall.value(function, :description) || "",
+        parameters: ToolCall.value(function, :parameters) || {}
+      }
+    end
+
     def codex_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
-      parts = build_context_parts("Codex", messages, tools, model: model)
+      responses_payload("Codex", messages, tools, model: model, reasoning: reasoning)
+    end
+
+    def openai_responses_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
+      payload = responses_payload("OpenAI", messages, tools, model: model, reasoning: reasoning)
+      payload[:max_output_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
+      payload
+    end
+
+    def responses_payload(provider, messages, tools, model:, reasoning:)
+      parts = build_context_parts(provider, messages, tools, model: model)
       payload = {
         model: parts[:model],
         instructions: parts[:instructions],
@@ -128,10 +187,10 @@ module Kward
         include: []
       }
       unless reasoning == false
-        effort = reasoning || reasoning_effort("Codex")
+        effort = reasoning || reasoning_effort(provider)
         payload[:reasoning] = { effort: effort, summary: "auto" }
         # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
-        payload[:reasoning][:context] = "all_turns" if parts[:model] == "gpt-5.6-luna"
+        payload[:reasoning][:context] = "all_turns" if provider == "Codex" && parts[:model] == "gpt-5.6-luna"
       end
       payload
     end
@@ -161,7 +220,7 @@ module Kward
           input: input,
           tools: tools.map { |tool| codex_tool_schema(tool) }
         }
-      elsif provider == "Codex"
+      elsif ["Codex", "OpenAI"].include?(provider)
         instructions, input = codex_messages(messages)
         {
           provider: provider,