kward 0.78.0 → 0.80.0

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,7 +128,20 @@ 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")
       when "OpenRouter"
         env["OPENROUTER_MODEL"] || ConfigFiles.config_value(config, "openrouter_model", "model")
       when "Copilot"
@@ -174,7 +188,14 @@ 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
       when "OpenRouter"
         env["OPENROUTER_REASONING_EFFORT"] || ConfigFiles.config_value(config, "openrouter_reasoning_effort", "reasoning_effort", "thinking_level") || DEFAULT_REASONING_EFFORT
       when "Copilot"
@@ -187,38 +208,62 @@ 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"
       when "anthropic", "claude" then "Anthropic"
+      when "local" then "Local"
       when "codex", "openai" then "Codex"
       else provider.to_s
       end
     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"
       when "anthropic", "claude" then "anthropic"
+      when "local" then "local"
       else "codex"
       end
     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"
       when "anthropic", "claude" then "anthropic_model"
+      when "local" then "local_model"
       else "openai_model"
       end
     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"
       when "anthropic", "claude" then "anthropic_reasoning_effort"
+      when "local" then "local_reasoning_effort"
       else "openai_reasoning_effort"
       end
     end
@@ -236,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) ||
@@ -357,7 +412,9 @@ module Kward
       pattern_context_window(ANTHROPIC_CONTEXT_WINDOWS, normalize_anthropic_model(id))
     end
 
-    def supports_images?(_provider, id)
+    def supports_images?(provider, id)
+      return false if provider == "Local"
+
       IMAGE_UNSUPPORTED_MODELS.none? { |pattern| id.to_s.match?(pattern) }
     end
 
@@ -417,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

@@ -26,6 +26,7 @@ module Kward
 
       payload = { model: parts[:model], messages: parts[:messages], tools: parts[:tools] }
       payload[:reasoning] = { effort: reasoning || reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
+      payload[:stream] = true if provider == "Local"
       payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
       payload
     end
@@ -113,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],
@@ -127,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
@@ -160,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,

data/lib/kward/model/provider_catalog.rb

@@ -0,0 +1,114 @@
+# Namespace for Kward model-provider definitions.
+module Kward
+  # Stable, frontend-neutral descriptions of providers Kward can present to users.
+  # Runtime request and authentication mechanics remain in their respective clients.
+  module ProviderCatalog
+    Definition = Struct.new(
+      :id,
+      :name,
+      :api_key_env,
+      :protocol,
+      :oauth_name,
+      :requires_setup,
+      keyword_init: true
+    ) do
+      def api_key?
+        !api_key_env.empty?
+      end
+
+      def oauth?
+        !oauth_name.nil?
+      end
+    end
+
+    Runtime = Struct.new(:id, :model_config_key, :reasoning_config_key, :chat_url, :model_list_url, :model_discovery, keyword_init: true) do
+      def automatic_model_discovery?
+        model_discovery == :live
+      end
+    end
+
+    CHAT_URLS = {
+      "anthropic" => "https://api.anthropic.com/v1/messages",
+      "cerebras" => "https://api.cerebras.ai/v1/chat/completions",
+      "deepseek" => "https://api.deepseek.com/chat/completions",
+      "fireworks" => "https://api.fireworks.ai/inference/v1/chat/completions",
+      "gemini" => "https://generativelanguage.googleapis.com/v1beta",
+      "groq" => "https://api.groq.com/openai/v1/chat/completions",
+      "mistral" => "https://api.mistral.ai/v1/chat/completions",
+      "nvidia" => "https://integrate.api.nvidia.com/v1/chat/completions",
+      "openai" => "https://api.openai.com/v1/responses",
+      "openrouter" => "https://openrouter.ai/api/v1/chat/completions",
+      "together" => "https://api.together.xyz/v1/chat/completions",
+      "xai" => "https://api.x.ai/v1/chat/completions"
+    }.freeze
+    MODEL_LIST_URLS = {
+      "anthropic" => "https://api.anthropic.com/v1/models",
+      "cerebras" => "https://api.cerebras.ai/v1/models",
+      "deepseek" => "https://api.deepseek.com/models",
+      "fireworks" => "https://api.fireworks.ai/inference/v1/models",
+      "gemini" => "https://generativelanguage.googleapis.com/v1beta/models",
+      "groq" => "https://api.groq.com/openai/v1/models",
+      "mistral" => "https://api.mistral.ai/v1/models",
+      "nvidia" => "https://integrate.api.nvidia.com/v1/models",
+      "openai" => "https://api.openai.com/v1/models",
+      "together" => "https://api.together.xyz/v1/models",
+      "xai" => "https://api.x.ai/v1/models"
+    }.freeze
+
+    DEFINITIONS = [
+      Definition.new(id: "anthropic", name: "Anthropic", api_key_env: ["ANTHROPIC_API_KEY"], protocol: "anthropic_messages", oauth_name: "Anthropic Claude"),
+      Definition.new(id: "azure_openai", name: "Azure OpenAI", api_key_env: ["AZURE_OPENAI_API_KEY"], protocol: "azure_openai", requires_setup: true),
+      Definition.new(id: "cerebras", name: "Cerebras", api_key_env: ["CEREBRAS_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "deepseek", name: "DeepSeek", api_key_env: ["DEEPSEEK_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "fireworks", name: "Fireworks AI", api_key_env: ["FIREWORKS_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "gemini", name: "Google Gemini", api_key_env: ["GEMINI_API_KEY"], protocol: "gemini"),
+      Definition.new(id: "groq", name: "Groq", api_key_env: ["GROQ_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "mistral", name: "Mistral", api_key_env: ["MISTRAL_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "nvidia", name: "NVIDIA NIM", api_key_env: ["NVIDIA_API_KEY", "NGC_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "openai", name: "OpenAI", api_key_env: ["OPENAI_API_KEY"], protocol: "openai_responses", oauth_name: "ChatGPT"),
+      Definition.new(id: "openrouter", name: "OpenRouter", api_key_env: ["OPENROUTER_API_KEY"], protocol: "openai_chat", oauth_name: "OpenRouter"),
+      Definition.new(id: "together", name: "Together AI", api_key_env: ["TOGETHER_API_KEY"], protocol: "openai_chat"),
+      Definition.new(id: "xai", name: "xAI", api_key_env: ["XAI_API_KEY"], protocol: "openai_chat", oauth_name: "xAI Grok"),
+      Definition.new(id: "copilot", name: "GitHub Copilot", api_key_env: [], protocol: "copilot", oauth_name: "GitHub Copilot")
+    ].freeze
+
+    module_function
+
+    def all
+      DEFINITIONS
+    end
+
+    def fetch(id)
+      find(id) || raise(ArgumentError, "Unknown provider: #{id}")
+    end
+
+    def find(id)
+      DEFINITIONS.find { |provider| provider.id == id.to_s }
+    end
+
+    def find_by_name(name)
+      DEFINITIONS.find { |provider| provider.name.casecmp?(name.to_s) }
+    end
+
+    def runtime(id)
+      provider = fetch(id)
+      runtime_id = provider.id == "openai" ? "openai_api" : provider.id
+      Runtime.new(
+        id: runtime_id,
+        model_config_key: "#{runtime_id}_model",
+        reasoning_config_key: "#{runtime_id}_reasoning_effort",
+        chat_url: CHAT_URLS[provider.id],
+        model_list_url: MODEL_LIST_URLS[provider.id],
+        model_discovery: provider.id == "azure_openai" ? :configured : (MODEL_LIST_URLS.key?(provider.id) ? :live : :curated)
+      )
+    end
+
+    def api_key_providers
+      DEFINITIONS.select(&:api_key?)
+    end
+
+    def oauth_providers
+      DEFINITIONS.select(&:oauth?)
+    end
+  end
+end

data/lib/kward/model/sources.rb

@@ -0,0 +1,70 @@
+require_relative "catalog"
+require_relative "model_info"
+require_relative "provider_catalog"
+
+# Namespace for Kward model catalogs.
+module Kward
+  # Combines live, cached, and curated provider models for selection UIs.
+  class ModelSources
+    CURATED_MODELS = {
+      "anthropic" => %w[claude-sonnet-5 claude-opus-4-8 claude-haiku-4-5],
+      "azure_openai" => [],
+      "cerebras" => [],
+      "deepseek" => %w[deepseek-chat deepseek-reasoner],
+      "fireworks" => [],
+      "gemini" => %w[gemini-2.5-pro gemini-2.5-flash],
+      "groq" => [],
+      "mistral" => %w[mistral-large-latest],
+      "nvidia" => [],
+      "openai" => ModelInfo::OPENAI_MODEL_CHOICES,
+      "openrouter" => [],
+      "together" => [],
+      "xai" => %w[grok-3 grok-3-mini],
+      "copilot" => ModelInfo::COPILOT_MODEL_CHOICES
+    }.freeze
+
+    def initialize(provider_id:, api_key: nil, catalog: nil)
+      @provider = ProviderCatalog.fetch(provider_id)
+      @catalog = catalog || ModelCatalog.new(provider_id: @provider.id, api_key: api_key)
+    end
+
+    def models
+      merge(cached_models, curated_models)
+    end
+
+    def refresh
+      merge(live_models, curated_models)
+    rescue StandardError
+      models
+    end
+
+    def manual(id)
+      value = id.to_s.strip
+      raise ArgumentError, "Model ID must be a non-empty string" if value.empty?
+
+      { "provider" => @provider.id, "id" => value, "name" => value, "source" => "manual" }
+    end
+
+    private
+
+    def live_models
+      @catalog.refresh.map { |model| model.merge("source" => "live") }
+    end
+
+    def cached_models
+      @catalog.models.map { |model| model.merge("source" => "cached") }
+    end
+
+    def curated_models
+      CURATED_MODELS.fetch(@provider.id, []).map do |id|
+        { "provider" => @provider.id, "id" => id, "name" => id, "source" => "curated" }
+      end
+    end
+
+    def merge(*groups)
+      groups.flatten.each_with_object({}) do |model, result|
+        result[model.fetch("id")] ||= model
+      end.values.sort_by { |model| model.fetch("id") }
+    end
+  end
+end