kward 0.70.0 → 0.72.0

data/lib/kward/model/client.rb

@@ -6,6 +6,7 @@ require_relative "../auth/github_oauth"
 require_relative "../auth/openai_oauth"
 require_relative "../cancellation"
 require_relative "../config_files"
+require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
 require_relative "model_info"
 require_relative "payloads"
@@ -24,7 +25,6 @@ module Kward
   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."
@@ -32,7 +32,6 @@ module Kward
     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
     RETRY_DELAYS = [1, 2].freeze
     NON_RETRYABLE_PROVIDER_LIMIT_PATTERNS = [
@@ -92,7 +91,6 @@ module Kward
       @telemetry_logger = telemetry_logger
       @copilot_models = nil
       @openrouter_models = nil
-      @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, provider: nil, model: nil, reasoning: nil)
@@ -173,7 +171,12 @@ module Kward
     # Returns the known context window for the active provider/model pair.
     def current_context_window
       state = current_model_state
-      ModelInfo.context_window(state[:provider], state[:model])
+      context_window(state[:provider], state[:model])
+    end
+
+    # Returns the known context window for a provider/model pair.
+    def context_window(provider, model)
+      context_window_for(ModelInfo.provider_label(provider), model)
     end
 
     # Returns model choices suitable for settings UIs.
@@ -189,48 +192,40 @@ module Kward
       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 }
+          model_entry("Codex", 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)
+        models << model_entry("Codex", openai_model, current: provider == "Codex") unless ModelInfo::OPENAI_MODEL_CHOICES.include?(openai_model)
       end
 
       if provider_logged_in?("OpenRouter")
         openrouter_model = model_for("OpenRouter")
-        openrouter_choices = provider == "OpenRouter" ? openrouter_model_choices : ModelInfo::OPENROUTER_MODEL_CHOICES
+        openrouter_choices = openrouter_model_choices
         models += openrouter_choices.map do |id|
-          { provider: "OpenRouter", id: id, current: provider == "OpenRouter" && openrouter_model == id }
+          model_entry("OpenRouter", id, current: provider == "OpenRouter" && openrouter_model == id)
         end
-        models << { provider: "OpenRouter", id: openrouter_model, current: provider == "OpenRouter" } unless openrouter_choices.include?(openrouter_model)
       end
 
       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 }
+          model_entry("Copilot", id, current: provider == "Copilot" && copilot_model == id)
         end
-        models << { provider: "Copilot", id: copilot_model, current: provider == "Copilot" } unless copilot_choices.include?(copilot_model)
+        models << model_entry("Copilot", 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 }
+          model_entry("Anthropic", 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)
+        models << model_entry("Anthropic", anthropic_model, current: provider == "Anthropic") unless ModelInfo::ANTHROPIC_MODEL_CHOICES.include?(anthropic_model)
       end
 
       # 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)
@@ -248,7 +243,6 @@ module Kward
       @config = load_config
       @copilot_models = nil
       @openrouter_models = nil
-      @openrouter_catalog = nil
     end
 
     private
@@ -494,44 +488,37 @@ module Kward
       model.to_s.match?(/\Agpt-5(?:\.|-|\z)/)
     end
 
-    def openrouter_model_choices
-      live_models = fetch_openrouter_models(full_catalog: false)
-      choices = live_models.empty? ? ModelInfo::OPENROUTER_MODEL_CHOICES : live_models
-      choices.uniq
+    def model_entry(provider, id, current: false)
+      {
+        provider: provider,
+        id: id,
+        current: current,
+        contextWindow: context_window_for(provider, id)
+      }.compact
     end
 
-    def fetch_openrouter_models(full_catalog: false)
-      cache = full_catalog ? @openrouter_catalog : @openrouter_models
-      return cache if cache
-
-      token = openrouter_api_key.to_s
-      return [] if token.empty? && !full_catalog
+    def context_window_for(provider, id)
+      ModelInfo.context_window(provider, id, openrouter_models: openrouter_cached_model_entries)
+    end
 
-      request = Net::HTTP::Get.new(OPENROUTER_MODELS_URL)
-      request["Authorization"] = "Bearer #{token}" unless full_catalog || token.empty?
-      request["Accept"] = "application/json"
+    def openrouter_model_choices
+      openrouter_cached_models.uniq
+    end
 
-      response = Net::HTTP.start(OPENROUTER_MODELS_URL.hostname, OPENROUTER_MODELS_URL.port, use_ssl: true) { |http| http.request(request) }
-      return [] unless response.is_a?(Net::HTTPSuccess)
+    def openrouter_cached_models
+      openrouter_cached_model_entries.filter_map do |model|
+        model.is_a?(Hash) ? model["id"] || model[:id] : model
+      end.map(&:to_s).map(&:strip).reject(&:empty?)
+    end
 
-      models = parse_openrouter_models(response.body)
-      if full_catalog
-        @openrouter_catalog = models
-      else
-        @openrouter_models = models
-      end
+    def openrouter_cached_model_entries
+      @openrouter_models ||= openrouter_model_cache.models
     rescue StandardError
       []
     end
 
-    def parse_openrouter_models(body)
-      model_catalog_entries(body).filter_map do |entry|
-        if entry.is_a?(Hash)
-          entry["id"] || entry[:id] || entry["slug"] || entry[:slug]
-        else
-          entry
-        end
-      end.map(&:to_s).map(&:strip).reject(&:empty?).uniq
+    def openrouter_model_cache
+      OpenRouterModelCache.new(api_key: openrouter_api_key, path: File.join(File.dirname(@config_path), "cache", "openrouter_models.json"))
     end
 
     def copilot_model_choices

data/lib/kward/model/context_usage.rb

@@ -5,14 +5,11 @@ require_relative "../message_access"
 module Kward
   # Estimates provider context usage and compaction pressure.
   class ContextUsage
-    OPENAI_CONTEXT_PROVIDERS = ["Codex", "OpenAI"].freeze
-
     def initialize(token_counter: TiktokenTokenCounter.new)
       @token_counter = token_counter
     end
 
     def call(provider:, model:, context_window:, context_parts:)
-      return nil unless OPENAI_CONTEXT_PROVIDERS.include?(provider.to_s)
       return nil unless context_window
 
       parts = redact_image_data(stringify_keys(context_parts || {}))
@@ -84,7 +81,13 @@ module Kward
   # Structured context usage result returned to frontends.
   class TiktokenTokenCounter
     def count(text, model:)
-      encoding(model).encode(text.to_s).length
+      text = text.to_s
+      tokenizer = encoding(model)
+      return rough_count(text) unless tokenizer.respond_to?(:encode)
+
+      tokenizer.encode(text).length
+    rescue StandardError
+      rough_count(text)
     end
 
     private
@@ -92,9 +95,13 @@ module Kward
     def encoding(model)
       require "tiktoken_ruby"
 
-      Tiktoken.encoding_for_model(model.to_s)
+      Tiktoken.encoding_for_model(model.to_s) || Tiktoken.get_encoding(encoding_name_for_model(model))
     rescue StandardError
-      Tiktoken.get_encoding(encoding_name_for_model(model))
+      Tiktoken.get_encoding(encoding_name_for_model(model)) if defined?(Tiktoken)
+    end
+
+    def rough_count(text)
+      [(text.length / 4.0).ceil, 1].max
     end
 
     def encoding_name_for_model(model)

data/lib/kward/model/model_info.rb

@@ -5,15 +5,10 @@ module Kward
   # Static and configured model metadata helpers.
   module ModelInfo
     DEFAULT_OPENAI_MODEL = "gpt-5.5"
-    DEFAULT_OPENROUTER_MODEL = "openai/gpt-5.5"
     DEFAULT_COPILOT_MODEL = "gpt-5-mini"
     DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6"
     DEFAULT_REASONING_EFFORT = "medium"
     OPENAI_MODEL_CHOICES = %w[gpt-5.5 gpt-5.4 gpt-5.4-mini gpt-5.3-codex-spark].freeze
-    OPENROUTER_MODEL_CHOICES = [
-      *OPENAI_MODEL_CHOICES.map { |model| "openai/#{model}" },
-      "z-ai/glm-5.2"
-    ].freeze
     ANTHROPIC_MODEL_CHOICES = %w[
       claude-opus-4-8
       claude-sonnet-4-6
@@ -118,9 +113,6 @@ module Kward
     GEMINI_CONTEXT_WINDOWS = [
       [/\Agemini-(?:2\.5-pro|3(?:\.1)?-pro|3(?:\.5)?-flash)/, 1_048_576]
     ].freeze
-    OPENROUTER_CONTEXT_WINDOWS = [
-      [/\Az-ai\/glm-5\.2\z/, 1_048_576]
-    ].freeze
 
     module_function
 
@@ -129,7 +121,7 @@ module Kward
 
       case provider
       when "OpenRouter"
-        env["OPENROUTER_MODEL"] || ConfigFiles.config_value(config, "openrouter_model", "model") || DEFAULT_OPENROUTER_MODEL
+        env["OPENROUTER_MODEL"] || ConfigFiles.config_value(config, "openrouter_model", "model")
       when "Copilot"
         normalize_copilot_model(env["COPILOT_MODEL"] || ConfigFiles.config_value(config, "copilot_model", "model") || DEFAULT_COPILOT_MODEL)
       when "Anthropic"
@@ -234,16 +226,27 @@ module Kward
       }
     end
 
-    def context_window(provider, id)
+    def context_window(provider, id, openrouter_models: nil)
       case provider
       when "Codex"
-        pattern_context_window(CODEX_CONTEXT_WINDOWS, id)
+        pattern_context_window(CODEX_CONTEXT_WINDOWS, id) ||
+          openrouter_inferred_context_window(provider, id, openrouter_models: openrouter_models) ||
+          conservative_context_window(id)
       when "OpenRouter"
-        openrouter_context_window(id)
+        openrouter_cached_context_window(openrouter_models, id) ||
+          openrouter_context_window(id) ||
+          conservative_openrouter_context_window(id) ||
+          conservative_unknown_context_window(id)
       when "Copilot"
-        copilot_context_window(id)
+        copilot_context_window(id) ||
+          openrouter_inferred_context_window(provider, id, openrouter_models: openrouter_models) ||
+          conservative_context_window(id) ||
+          conservative_unknown_context_window(id)
       when "Anthropic"
-        anthropic_context_window(id)
+        anthropic_context_window(id) ||
+          openrouter_inferred_context_window(provider, id, openrouter_models: openrouter_models) ||
+          conservative_context_window(normalize_anthropic_model(id)) ||
+          conservative_anthropic_context_window(id)
       end
     end
 
@@ -252,13 +255,87 @@ module Kward
       match&.last
     end
 
+    def openrouter_cached_context_window(models, id)
+      model = Array(models).find do |entry|
+        next false unless entry.respond_to?(:key?)
+
+        entry["id"].to_s == id.to_s || entry[:id].to_s == id.to_s
+      end
+      value = model && (model["contextWindow"] || model[:contextWindow] || model["context_window"] || model[:context_window])
+      positive_integer(value)
+    end
+
+    def openrouter_inferred_context_window(provider, id, openrouter_models: nil)
+      openrouter_equivalent_ids(provider, id).filter_map do |candidate|
+        openrouter_cached_context_window(openrouter_models, candidate)
+      end.min
+    end
+
+    def openrouter_equivalent_ids(provider, id)
+      text = id.to_s.strip
+      return [] if text.empty?
+
+      case provider
+      when "Codex"
+        ["openai/#{text.delete_prefix("openai/")}"]
+      when "Anthropic"
+        raw = text.delete_prefix("anthropic/")
+        normalized = normalize_anthropic_model(raw)
+        ["anthropic/#{raw}", "anthropic/#{normalized}"].uniq
+      when "Copilot"
+        copilot_openrouter_equivalent_ids(text)
+      else
+        []
+      end
+    end
+
+    def copilot_openrouter_equivalent_ids(id)
+      return ["openai/#{id.delete_prefix("openai/")}"] if id.start_with?("openai/") || id.match?(/\A(?:gpt-|o\d)/)
+      return ["google/#{id.delete_prefix("google/")}"] if id.start_with?("google/") || id.start_with?("gemini-")
+
+      if id.start_with?("anthropic/") || id.start_with?("claude-")
+        raw = id.delete_prefix("anthropic/")
+        normalized = normalize_anthropic_model(raw)
+        return ["anthropic/#{raw}", "anthropic/#{normalized}"].uniq
+      end
+
+      []
+    end
+
+    def positive_integer(value)
+      integer = Integer(value)
+      integer.positive? ? integer : nil
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+    def conservative_context_window(id)
+      text = id.to_s
+      return 128_000 if text.match?(/\A(?:gpt-|o\d)/)
+      return 200_000 if text.start_with?("claude-")
+      return 128_000 if text.start_with?("gemini-")
+    end
+
+    def conservative_anthropic_context_window(id)
+      id.to_s.strip.empty? ? nil : 200_000
+    end
+
+    def conservative_unknown_context_window(id)
+      id.to_s.strip.empty? ? nil : 128_000
+    end
+
     def openrouter_context_window(id)
       text = id.to_s
       return pattern_context_window(OPENAI_CONTEXT_WINDOWS, text.delete_prefix("openai/")) if text.start_with?("openai/")
       return anthropic_context_window(text.delete_prefix("anthropic/")) if text.start_with?("anthropic/")
       return pattern_context_window(GEMINI_CONTEXT_WINDOWS, text.delete_prefix("google/")) if text.start_with?("google/")
+    end
 
-      pattern_context_window(OPENROUTER_CONTEXT_WINDOWS, text)
+    def conservative_openrouter_context_window(id)
+      text = id.to_s
+      return conservative_context_window(text.delete_prefix("openai/")) if text.start_with?("openai/")
+      return conservative_context_window(normalize_anthropic_model(text.delete_prefix("anthropic/"))) if text.start_with?("anthropic/")
+      return conservative_context_window(text.delete_prefix("google/")) if text.start_with?("google/")
     end
 
     def copilot_context_window(id)
@@ -304,7 +381,6 @@ module Kward
 
     def openai_reasoning_effort_choices(id)
       text = id.to_s.delete_prefix("openai/")
-      return REASONING_EFFORT_CHOICES if text == "z-ai/glm-5.2"
       return REASONING_EFFORT_CHOICES if text.match?(/\Agpt-5\.[23]-codex/)
 
       OPENAI_REASONING_EFFORT_CHOICES

data/lib/kward/model/payloads.rb

@@ -21,6 +21,8 @@ module Kward
 
     def request_payload(provider, messages, tools, max_tokens: nil, model: nil, reasoning: nil)
       parts = build_context_parts(provider, messages, tools, model: model)
+      raise "OpenRouter model is not configured. Run `kward openrouter refresh` and select a cached model." if provider == "OpenRouter" && parts[:model].to_s.empty?
+
       payload = { model: parts[:model], messages: parts[:messages], tools: parts[:tools] }
       payload[:reasoning] = { effort: reasoning || reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
       payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?

data/lib/kward/openrouter_model_cache.rb

@@ -0,0 +1,120 @@
+require "digest"
+require "json"
+require "net/http"
+require "time"
+require "uri"
+require_relative "config_files"
+require_relative "private_file"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Fetches and stores the OpenRouter model list available to the configured API key.
+  class OpenRouterModelCache
+    MODELS_URL = URI("https://openrouter.ai/api/v1/models/user")
+    VERSION = 1
+
+    attr_reader :path
+
+    def initialize(api_key:, path: ConfigFiles.openrouter_models_cache_path)
+      @api_key = api_key.to_s
+      @path = File.expand_path(path)
+    end
+
+    def self.model_entry?(entry)
+      return false unless entry.is_a?(Hash)
+
+      architecture = entry["architecture"].is_a?(Hash) ? entry["architecture"] : {}
+      input_modalities = Array(architecture["input_modalities"]).map(&:to_s)
+      output_modalities = Array(architecture["output_modalities"]).map(&:to_s)
+      input_modalities.include?("text") && output_modalities.include?("text")
+    end
+
+    def refresh
+      raise "No OpenRouter API key found. Set OPENROUTER_API_KEY or add openrouter_api_key to your Kward config." if @api_key.empty?
+
+      response = Net::HTTP.start(MODELS_URL.hostname, MODELS_URL.port, use_ssl: true) do |http|
+        http.request(refresh_request)
+      end
+      unless response.is_a?(Net::HTTPSuccess)
+        raise "OpenRouter model refresh failed: #{response.code} #{redact(response.body)}"
+      end
+
+      entries = model_entries(response.body)
+      models = entries.select { |entry| self.class.model_entry?(entry) }.map { |entry| normalize_model(entry) }.uniq { |model| model["id"] }.sort_by { |model| model["id"] }
+      data = cache_data(models)
+      PrivateFile.write_json(@path, data)
+      data
+    end
+
+    def read
+      return nil unless File.exist?(@path)
+
+      data = JSON.parse(File.read(@path))
+      return nil unless data.is_a?(Hash) && data["version"] == VERSION
+
+      data
+    rescue JSON::ParserError
+      nil
+    end
+
+    def models
+      Array(read&.fetch("models", []))
+    end
+
+    def matching_key?
+      data = read
+      return false unless data
+
+      data["api_key_sha256"] == api_key_sha256
+    end
+
+    private
+
+    def refresh_request
+      Net::HTTP::Get.new(MODELS_URL).tap do |request|
+        request["Authorization"] = "Bearer #{@api_key}"
+        request["Accept"] = "application/json"
+      end
+    end
+
+    def model_entries(body)
+      data = JSON.parse(body.to_s)
+      entries = data.is_a?(Hash) ? data["data"] || [] : data
+      Array(entries).select { |entry| entry.is_a?(Hash) }
+    rescue JSON::ParserError
+      raise "OpenRouter model refresh returned invalid JSON"
+    end
+
+    def normalize_model(entry)
+      {
+        "provider" => "OpenRouter",
+        "id" => entry.fetch("id").to_s,
+        "name" => entry["name"].to_s.empty? ? entry.fetch("id").to_s : entry["name"].to_s,
+        "contextWindow" => entry["context_length"],
+        "supportedParameters" => Array(entry["supported_parameters"]).map(&:to_s)
+      }.compact
+    end
+
+    def cache_data(models)
+      {
+        "version" => VERSION,
+        "refreshed_at" => Time.now.utc.iso8601,
+        "source" => MODELS_URL.to_s,
+        "filter" => {
+          "input_modalities" => ["text"],
+          "output_modalities" => ["text"]
+        },
+        "api_key_sha256" => api_key_sha256,
+        "models" => models
+      }
+    end
+
+    def api_key_sha256
+      Digest::SHA256.hexdigest(@api_key)
+    end
+
+    def redact(text)
+      text.to_s.gsub(@api_key, "[REDACTED]")
+    end
+  end
+end