kward 0.70.0 → 0.71.0

data/lib/kward/cli/slash_commands.rb

@@ -32,9 +32,6 @@ module Kward
           models = run_busy_local_command_and_requeue { normalized_available_models }
           configure_model(agent.conversation, models: models)
           [true, nil]
-        when "openrouter/catalog"
-          run_busy_local_command_and_requeue { print_openrouter_catalog }
-          [true, nil]
         when "reasoning"
           configure_reasoning(agent.conversation)
           [true, nil]
@@ -52,15 +49,36 @@ module Kward
           path = argument.to_s.strip
           if path.empty?
             sessions = run_busy_local_command_and_requeue { session_store.recent_tree(limit: nil) }
-            path = select_session_path_from_sessions(sessions)
+            path = select_session_path_from_sessions(sessions, session_store: session_store)
+          end
+          replacement_agent = nil
+          selection = path
+          loop do
+            replacement_agent = if selection.respond_to?(:conversation)
+                                  selection
+                                elsif selection.is_a?(Hash) && selection[:action] == :clone
+                                  run_busy_local_command_and_requeue(activity: "cloning") { clone_session_from_path(session_store, selection[:path]) }
+                                elsif selection.is_a?(Hash) && selection[:action] == :fork
+                                  selection = reopen_sessions_after_fork(session_store, selection[:path], selection[:choice_label])
+                                  next
+                                elsif selection.to_s.empty?
+                                  nil
+                                else
+                                  run_busy_local_command_and_requeue { resume_session(session_store, selection) }
+                                end
+            break
           end
-          replacement_agent = path.to_s.empty? ? nil : run_busy_local_command_and_requeue { resume_session(session_store, path) }
           [true, replacement_agent]
         when "name"
-          run_busy_local_command_and_requeue { rename_session(argument) }
+          rename_session(argument)
+          [true, nil]
+        when "rename"
+          rename_session(argument, require_name: true)
           [true, nil]
         when "clone"
           [true, run_busy_local_command_and_requeue { clone_session(session_store, agent) }]
+        when "fork"
+          [true, fork_session(session_store)]
         when "rewind"
           [true, run_busy_local_command_and_requeue { rewind_session(session_store) }]
         when "tree"

data/lib/kward/cli.rb

@@ -29,6 +29,7 @@ require_relative "model/retry_message"
 require_relative "rpc/server"
 require_relative "session_diff"
 require_relative "session_store"
+require_relative "session_trash"
 require_relative "session_tree_renderer"
 require_relative "starter_pack_installer"
 require_relative "steering"
@@ -41,6 +42,7 @@ require_relative "cli/auth_commands"
 require_relative "cli/doctor"
 require_relative "cli/sysprompt"
 require_relative "cli/stats"
+require_relative "cli/openrouter_commands"
 require_relative "cli/runtime_helpers"
 require_relative "cli/slash_commands"
 require_relative "cli/memory_commands"
@@ -72,6 +74,7 @@ module Kward
     include CLI::Doctor
     include CLI::Sysprompt
     include CLI::Stats
+    include CLI::OpenRouterCommands
     include CLI::RuntimeHelpers
     include CLI::SlashCommands
     include CLI::MemoryCommands
@@ -193,6 +196,16 @@ module Kward
         return
       end
 
+      if @argv.first == "openrouter"
+        if help_option_arguments?(@argv[1..] || [])
+          print_command_help("openrouter")
+          return
+        end
+
+        handle_openrouter_command(@argv[1..] || [])
+        return
+      end
+
       if pan_mode?
         if help_option_arguments?(@argv[1..] || [])
           print_command_help("pan")

data/lib/kward/compactor.rb

@@ -665,7 +665,10 @@ module Kward
         ## Critical Context
         - [Preserve important context, add new context needed to continue]
 
-        Keep each section concise. Preserve exact file paths, class names, module names, method names, constants, commands, spec names, migration names, error messages, user requirements, and unresolved problems. Do not invent work that did not happen.
+        ## Available Tool Artifacts
+        - [Preserve any toolout_* ids from compacted tool outputs, with what each id contains and why it may matter]
+
+        Keep each section concise. Preserve exact file paths, class names, module names, method names, constants, commands, spec names, migration names, error messages, toolout_* artifact ids, user requirements, and unresolved problems. Do not invent work that did not happen.
       PROMPT
 
       SPLIT_TURN_PROMPT = <<~PROMPT.strip.freeze

data/lib/kward/config_files.rb

@@ -97,6 +97,10 @@ module Kward
       File.join(cache_dir, "code_search")
     end
 
+    def openrouter_models_cache_path
+      File.join(cache_dir, "openrouter_models.json")
+    end
+
     # @return [String] directory containing structured memory files
     def memory_dir
       File.join(config_dir, "memory")
@@ -189,12 +193,6 @@ module Kward
       composer["busy_help"] != false
     end
 
-    # Returns whether the terminal startup banner should be displayed.
-    def banner_enabled?(config = read_config)
-      banner = config["banner"].is_a?(Hash) ? config["banner"] : {}
-      banner["enabled"] != false
-    end
-
     # Returns whether file tools must stay inside the active workspace root.
     def workspace_guardrails_enabled?(config = read_config)
       tools = config["tools"].is_a?(Hash) ? config["tools"] : {}

data/lib/kward/conversation.rb

@@ -1,3 +1,4 @@
+require "digest"
 require "set"
 require_relative "image_attachments"
 require_relative "message_access"
@@ -57,6 +58,8 @@ module Kward
     attr_accessor :plugin_registry
     # @return [String, nil] plugin prompt context used in the current system prompt
     attr_reader :last_plugin_prompt_context
+    # @return [Hash] original large tool outputs retained outside model context
+    attr_reader :tool_output_artifacts
 
     def initialize(system_message: DEFAULT_SYSTEM_MESSAGE, messages: [], read_paths: [], on_append: nil, on_compact: nil, on_tool_execution: nil, on_runtime_update: nil, workspace_root: Dir.pwd, compaction_system_message: DEFAULT_SYSTEM_MESSAGE, provider: nil, model: nil, reasoning_effort: nil, memory_context: nil, session_memories: [], last_memory_retrieval: nil, plugin_registry: nil)
       @workspace_root = ConfigFiles.canonical_workspace_root(workspace_root)
@@ -71,13 +74,13 @@ module Kward
           system_message = restored_system_message
         else
           @last_plugin_prompt_context = plugin_prompt_context
-          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: memory_context, plugin_context: @last_plugin_prompt_context)
+          system_message = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: memory_context, plugin_context: @last_plugin_prompt_context)
         end
       end
       @system_message = system_message
       @system_message_enabled = !@system_message.nil?
       if compaction_system_message.equal?(DEFAULT_SYSTEM_MESSAGE)
-        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort) : nil
+        compaction_system_message = @system_message_enabled ? Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time) : nil
       end
       @compaction_system_message = compaction_system_message
       @workspace_agents_mtime = workspace_agents_mtime
@@ -85,6 +88,7 @@ module Kward
       @memory_context = memory_context
       @session_memories = Array(session_memories)
       @last_memory_retrieval = last_memory_retrieval
+      @tool_output_artifacts = {}
       @messages.concat(transcript_messages)
       @read_paths = Set.new(read_paths)
       @on_append = on_append
@@ -111,19 +115,54 @@ module Kward
     end
 
     def append_tool(tool_call_id:, name:, content:)
-      content = normalize_tool_content(content) if content.is_a?(String)
       append_message({
         role: "tool",
         tool_call_id: tool_call_id,
         name: name,
-        content: content
+        content: self.class.normalize_tool_content(content)
       })
     end
 
+    # Tool results may arrive as ASCII-8BIT (BINARY) strings, e.g. from
+    # Net::HTTP response bodies or shell command output. When such a string
+    # is later concatenated with a UTF-8 string containing non-ASCII bytes
+    # (during compaction or JSON serialization), Ruby raises
+    # Encoding::CompatibilityError. Re-tag BINARY strings as UTF-8 when the
+    # bytes are valid UTF-8; otherwise scrub so the content is always
+    # serializable and concatenable.
+    def self.normalize_tool_content(content)
+      return content unless content.is_a?(String) && content.encoding == Encoding::ASCII_8BIT
+
+      probe = content.dup.force_encoding(Encoding::UTF_8)
+      probe.valid_encoding? ? probe : probe.scrub
+    end
+
     def append_tool_execution(tool_call:, content:)
       @on_tool_execution&.call(tool_call, content)
     end
 
+    def tool_output_artifact_id_for(tool_name:, content:)
+      self.class.tool_output_artifact_id(tool_name: tool_name, content: self.class.normalize_tool_content(content))
+    end
+
+    def store_tool_output_artifact(tool_name:, content:)
+      text = self.class.normalize_tool_content(content)
+      id = tool_output_artifact_id_for(tool_name: tool_name, content: text)
+      @tool_output_artifacts[id] = {
+        id: id,
+        tool_name: tool_name,
+        content: text,
+        bytes: text.bytesize,
+        created_at: Time.now.utc
+      }
+      id
+    end
+
+    def self.tool_output_artifact_id(tool_name:, content:)
+      digest = Digest::SHA256.hexdigest("#{tool_name}\0#{content}")[0, 16]
+      "toolout_#{digest}"
+    end
+
     # @return [Array<Hash>] provider request context: current system prompt plus durable transcript
     def context_messages
       @system_message ? [@system_message] + @messages : @messages.dup
@@ -139,10 +178,10 @@ module Kward
       return nil unless @system_message_enabled
 
       @last_plugin_prompt_context = plugin_prompt_context
-      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context)
+      replacement = Prompts.system_message(workspace_root: @workspace_root, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time, memory_context: @memory_context, plugin_context: @last_plugin_prompt_context)
       @system_message = replacement
       @on_system_message_change&.call(replacement)
-      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort)
+      @compaction_system_message = Prompts.system_message(workspace_root: @workspace_root, include_workspace_personality: false, model: @model, reasoning_effort: @reasoning_effort, now: prompt_time)
       @workspace_agents_mtime = workspace_agents_mtime
       replacement
     end
@@ -230,6 +269,10 @@ module Kward
       [system_message, transcript_messages]
     end
 
+    def prompt_time
+      Time.at(0)
+    end
+
     def workspace_agents_mtime
       path = File.join(@workspace_root, "AGENTS.md")
       File.exist?(path) ? File.mtime(path) : nil
@@ -242,19 +285,5 @@ module Kward
       message
     end
 
-    # Tool results may arrive as ASCII-8BIT (BINARY) strings, e.g. from
-    # Net::HTTP response bodies or shell command output. When such a string
-    # is later concatenated with a UTF-8 string containing non-ASCII bytes
-    # (during compaction or JSON serialization), Ruby raises
-    # Encoding::CompatibilityError. Re-tag BINARY strings as UTF-8 when the
-    # bytes are valid UTF-8; otherwise scrub so the content is always
-    # serializable and concatenable.
-    def normalize_tool_content(string)
-      return string unless string.encoding == Encoding::ASCII_8BIT
-
-      probe = string.dup.force_encoding(Encoding::UTF_8)
-      probe.valid_encoding? ? probe : probe.scrub
-    end
-
   end
 end

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?