kward 0.74.0 → 0.75.0

data/lib/kward/mcp/server_config.rb

@@ -11,13 +11,17 @@ module Kward
       module_function
 
       def clients_from_config(config)
-        servers = ConfigFiles.mcp_servers(config)
-
-        servers.filter_map do |name, settings|
+        configured_servers(config).filter_map do |name, settings|
           client_from_settings(name, settings)
         end
       end
 
+      def configured_servers(config)
+        ConfigFiles.mcp_servers(config).select do |_name, settings|
+          settings.is_a?(Hash) && settings["enabled"] != false
+        end
+      end
+
       def client_from_settings(name, settings)
         return nil unless settings.is_a?(Hash)
         return nil if settings["enabled"] == false

data/lib/kward/mcp/stdio_transport.rb

@@ -10,6 +10,8 @@ module Kward
     class StdioTransport
       DEFAULT_TIMEOUT_SECONDS = 10
 
+      attr_reader :command
+
       def initialize(command:, args: [], env: {}, timeout_seconds: DEFAULT_TIMEOUT_SECONDS)
         @command = command.to_s
         @args = Array(args).map(&:to_s)
@@ -62,7 +64,11 @@ module Kward
         raise ArgumentError, "MCP server command is required" if @command.empty?
 
         @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(@env, @command, *@args)
-        @stderr_thread = Thread.new { @stderr.each_line { |_line| } }
+        @stderr_thread = Thread.new do
+          @stderr.each_line { |_line| }
+        rescue IOError
+          nil
+        end
         @started = true
       rescue SystemCallError => e
         raise "Failed to start MCP server #{@command}: #{e.message}"

data/lib/kward/memory/turn_context.rb

@@ -0,0 +1,19 @@
+require_relative "manager"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  module Memory
+    # Applies retrieved memory context to a conversation before a model turn.
+    module TurnContext
+      module_function
+
+      def apply(conversation:, input:, manager: Manager.new)
+        retrieval = manager.retrieve_relevant(input: input, workspace_root: conversation.workspace_root)
+        conversation.last_memory_retrieval = retrieval
+        conversation.memory_context = manager.memory_block(retrieval)
+        conversation.refresh_system_message!
+        retrieval
+      end
+    end
+  end
+end

data/lib/kward/message_access.rb

@@ -5,8 +5,8 @@ module Kward
   # Kward stores transcript entries as plain hashes because model payloads,
   # JSONL sessions, plugins, and RPC normalizers all need to pass them around
   # without framework objects. Restored sessions may contain either symbol keys,
-  # string keys, or Tauren-style camelCase aliases. `MessageAccess` centralizes
-  # those lookup rules so callers do not grow one-off compatibility branches.
+  # string keys, or camelCase aliases. `MessageAccess` centralizes those lookup
+  # rules so callers do not grow one-off compatibility branches.
   module MessageAccess
     module_function
 

data/lib/kward/message_text.rb

@@ -28,6 +28,20 @@ module Kward
       content_text(MessageAccess.content(message)).strip
     end
 
+    # Returns compact one-line text for session tree and list previews.
+    #
+    # @param message [Hash] persisted conversation message
+    # @param length [Integer] maximum preview length
+    # @return [String] whitespace-normalized text, truncated with ellipsis
+    def preview(message, length: 120)
+      text = if MessageAccess.role(message) == "compactionSummary"
+               MessageAccess.summary(message).to_s
+             else
+               full_text(message)
+             end
+      truncate_preview(text, length: length)
+    end
+
     # Converts message content into plain text without applying display-content
     # overrides.
     #
@@ -41,5 +55,10 @@ module Kward
         content.to_s
       end
     end
+
+    def truncate_preview(text, length: 120)
+      normalized = text.to_s.gsub(/\s+/, " ").strip
+      normalized.length > length ? "#{normalized.slice(0, length - 3)}..." : normalized
+    end
   end
 end

data/lib/kward/model/client.rb

@@ -8,6 +8,7 @@ require_relative "../cancellation"
 require_relative "../config_files"
 require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
+require_relative "copilot_models"
 require_relative "model_info"
 require_relative "payloads"
 require_relative "../telemetry/logger"
@@ -227,8 +228,8 @@ module Kward
     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)
+    def current_context_parts(messages, tools, provider: current_provider, model: nil)
+      build_context_parts(ModelInfo.provider_label(provider), messages, tools, model: model)
     end
 
     # Returns whether the active provider can accept steering while a turn is streaming.
@@ -525,30 +526,15 @@ module Kward
       live_models = fetch_copilot_models
       return static_copilot_model_choices if live_models.empty?
 
-      supported_copilot_model_choices(live_models)
+      CopilotModels.supported_choices(live_models)
     end
 
     def static_copilot_model_choices
-      supported_copilot_model_choices(ModelInfo::COPILOT_MODEL_CHOICES)
-    end
-
-    def supported_copilot_model_choices(choices)
-      choices.select { |model| copilot_supported_model?(model) }.uniq
+      CopilotModels.supported_choices(ModelInfo::COPILOT_MODEL_CHOICES)
     end
 
     def resolved_copilot_chat_model(configured_model)
-      choices = fetch_copilot_models
-      return configured_model if choices.empty? || choices.include?(configured_model)
-
-      supported = choices.find { |model| copilot_supported_model?(model) }
-      raise "No Copilot models supported by Kward are available for this account. Kward currently supports Copilot GPT-5 Responses and Gemini/GPT-4.1 chat models." unless supported
-
-      supported
-    end
-
-    def copilot_supported_model?(model)
-      text = model.to_s
-      copilot_responses_model?(text) || text.match?(/\A(?:gemini-|gpt-4\.1|oswe-)/)
+      CopilotModels.resolved_chat_model(configured_model, fetch_copilot_models)
     end
 
     def fetch_copilot_models
@@ -566,33 +552,11 @@ module Kward
       response = Net::HTTP.start(url.hostname, url.port, use_ssl: true) { |http| http.request(request) }
       return [] unless response.is_a?(Net::HTTPSuccess)
 
-      @copilot_models = parse_copilot_models(response.body)
+      @copilot_models = CopilotModels.parse(response.body)
     rescue StandardError
       []
     end
 
-    def parse_copilot_models(body)
-      model_catalog_entries(body).filter_map do |entry|
-        copilot_model_id(entry)
-      end.uniq
-    rescue JSON::ParserError
-      []
-    end
-
-    def model_catalog_entries(body)
-      data = JSON.parse(body.to_s)
-      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
-      Array(entries)
-    end
-
-    def copilot_model_id(entry)
-      return entry.to_s.strip unless entry.is_a?(Hash)
-      return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
-
-      id = entry["id"] || entry["model"] || entry["name"]
-      id.to_s.strip unless id.to_s.strip.empty?
-    end
-
     def copilot_responses_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
       parts = build_context_parts("CopilotResponses", messages, tools, model: model)
       payload = {
@@ -718,11 +682,11 @@ module Kward
     end
 
     def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil)
-      ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+      ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
 
     def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil)
-      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
+      ModelStreamParser.parse_codex_sse_stream(response, on_reasoning_delta: on_reasoning_delta, 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)
@@ -871,6 +835,10 @@ module Kward
       ConfigFiles.config_value(@config, *keys)
     end
 
+    def codex_show_raw_reasoning?
+      @config["codex_show_raw_reasoning"] == true
+    end
+
     def load_config
       ConfigFiles.read_config(@config_path)
     end

data/lib/kward/model/context_usage.rb

@@ -80,6 +80,10 @@ module Kward
 
   # Structured context usage result returned to frontends.
   class TiktokenTokenCounter
+    def initialize
+      @encodings = {}
+    end
+
     def count(text, model:)
       text = text.to_s
       tokenizer = encoding(model)
@@ -93,11 +97,13 @@ module Kward
     private
 
     def encoding(model)
-      require "tiktoken_ruby"
+      @encodings[model.to_s] ||= begin
+        require "tiktoken_ruby"
 
-      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)) if defined?(Tiktoken)
+        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)) if defined?(Tiktoken)
+      end
     end
 
     def rough_count(text)

data/lib/kward/model/copilot_models.rb

@@ -0,0 +1,44 @@
+require "json"
+
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Parses and filters GitHub Copilot model catalog responses.
+  module CopilotModels
+    module_function
+
+    def parse(body)
+      catalog_entries(body).filter_map { |entry| model_id(entry) }.uniq
+    rescue JSON::ParserError
+      []
+    end
+
+    def supported?(model)
+      text = model.to_s
+      text.match?(/\Agpt-5(?:\.|-|\z)/) || text.match?(/\A(?:gemini-|gpt-4\.1|oswe-)/)
+    end
+
+    def supported_choices(choices)
+      choices.select { |model| supported?(model) }.uniq
+    end
+
+    def resolved_chat_model(configured_model, choices)
+      return configured_model if choices.empty? || choices.include?(configured_model)
+
+      choices.find { |model| supported?(model) } || raise("No Copilot models supported by Kward are available for this account. Kward currently supports Copilot GPT-5 Responses and Gemini/GPT-4.1 chat models.")
+    end
+
+    def catalog_entries(body)
+      data = JSON.parse(body.to_s)
+      entries = data.is_a?(Hash) ? data["data"] || data["models"] || data["items"] || [] : data
+      Array(entries)
+    end
+
+    def model_id(entry)
+      return entry.to_s.strip unless entry.is_a?(Hash)
+      return nil if entry.key?("model_picker_enabled") && entry["model_picker_enabled"] == false
+
+      id = entry["id"] || entry["model"] || entry["name"]
+      id.to_s.strip unless id.to_s.strip.empty?
+    end
+  end
+end

data/lib/kward/model/model_info.rb

@@ -412,6 +412,30 @@ module Kward
       }.compact
     end
 
+    def normalize_available(models, current_provider:, current_model:, current_reasoning_effort: nil)
+      Array(models).map do |model|
+        normalize(
+          model,
+          current_provider: current_provider,
+          current_model: current_model,
+          current_reasoning_effort: current_reasoning_effort
+        )
+      end
+    end
+
+    def current_payload(provider:, model:, reasoning_effort: nil, context_window: nil)
+      normalize(
+        {
+          provider: provider,
+          id: model,
+          model: model,
+          reasoningEffort: reasoning_effort,
+          contextWindow: context_window,
+          current: true
+        }
+      )
+    end
+
     def boolean_value(value, default: false)
       return default if value.nil?
       return value if value == true || value == false

data/lib/kward/model/payloads.rb

@@ -188,14 +188,12 @@ module Kward
           text = plain_content(content).to_s
           blocks << { type: "text", text: text } unless text.empty?
           MessageAccess.tool_calls(message).each do |tool_call|
-            function = tool_call[:function] || tool_call["function"] || {}
-            name = function[:name] || function["name"]
-            arguments = function[:arguments] || function["arguments"] || "{}"
+            name = ToolCall.name(tool_call)
             blocks << {
               type: "tool_use",
-              id: normalize_anthropic_tool_call_id(tool_call[:id] || tool_call["id"] || "call_#{name}"),
+              id: normalize_anthropic_tool_call_id(ToolCall.id(tool_call) || "call_#{name}"),
               name: claude_code_tool_name(name),
-              input: parse_tool_arguments(arguments)
+              input: parse_tool_arguments(ToolCall.raw_arguments(tool_call) || "{}")
             }
           end
           output << { role: "assistant", content: blocks } unless blocks.empty?
@@ -260,11 +258,11 @@ module Kward
     end
 
     def anthropic_tool_schema(tool)
-      function = tool[:function] || tool["function"] || {}
-      schema = function[:parameters] || function["parameters"] || {}
+      function = ToolCall.function(tool)
+      schema = ToolCall.value(function, :parameters) || {}
       {
-        name: claude_code_tool_name(function[:name] || function["name"]),
-        description: function[:description] || function["description"] || "",
+        name: claude_code_tool_name(ToolCall.value(function, :name)),
+        description: ToolCall.value(function, :description) || "",
         input_schema: {
           type: "object",
           properties: schema[:properties] || schema["properties"] || {},
@@ -296,12 +294,12 @@ module Kward
             content = plain_content(content)
             input << codex_message("assistant", content.to_s) unless content.to_s.empty?
             MessageAccess.tool_calls(message).each do |tool_call|
-              function = tool_call[:function] || tool_call["function"] || {}
+              name = ToolCall.name(tool_call)
               input << {
                 type: "function_call",
-                call_id: tool_call[:id] || tool_call["id"] || function[:name] || function["name"] || "tool-call",
-                name: function[:name] || function["name"],
-                arguments: function[:arguments] || function["arguments"] || "{}"
+                call_id: ToolCall.id(tool_call) || name || "tool-call",
+                name: name,
+                arguments: ToolCall.raw_arguments(tool_call) || "{}"
               }
             end
           else
@@ -420,12 +418,12 @@ module Kward
     end
 
     def codex_tool_schema(tool)
-      function = tool[:function] || tool["function"] || {}
+      function = ToolCall.function(tool)
       {
         type: "function",
-        name: function[:name] || function["name"],
-        description: function[:description] || function["description"] || "",
-        parameters: function[:parameters] || function["parameters"] || {},
+        name: ToolCall.value(function, :name),
+        description: ToolCall.value(function, :description) || "",
+        parameters: ToolCall.value(function, :parameters) || {},
         strict: false
       }
     end