kward 0.73.1 → 0.75.0

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

data/lib/kward/model/stream_parser.rb

@@ -45,11 +45,12 @@ module Kward
       raise "Copilot returned invalid SSE JSON: #{e.message}"
     end
 
-    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    def parse_codex_sse(body, on_reasoning_delta: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
+      state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       body.split(/\r?\n\r?\n/).each do |block|
         process_codex_sse_block(block, state, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class)
       end
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
     rescue JSON::ParserError => e
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
@@ -60,8 +61,8 @@ module Kward
     # Deltas are yielded as soon as complete SSE blocks arrive so interactive
     # frontends can render streamed assistant and reasoning text without waiting
     # for the provider to close the response.
-    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, request_error_class: nil)
-      state = codex_sse_state
+    def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)
+      state = codex_sse_state(show_raw_reasoning: show_raw_reasoning)
       buffer = +""
 
       response.read_body do |chunk|
@@ -76,6 +77,7 @@ module Kward
       end
       cancellation&.raise_if_cancelled!
       process_codex_sse_block(buffer, state, on_reasoning_delta: on_reasoning_delta, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer, request_error_class: request_error_class) unless buffer.empty?
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       codex_sse_message(state)
     rescue JSON::ParserError => e
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
@@ -218,17 +220,21 @@ module Kward
       end
     end
 
-    def codex_sse_state
+    def codex_sse_state(show_raw_reasoning: false)
       {
         content: +"",
         raw_content: +"",
         emitted_message_keys: [],
         reasoning_summary: +"",
+        raw_reasoning_visible: +"",
+        pending_reasoning_delta: +"",
+        show_raw_reasoning: show_raw_reasoning,
         tool_calls: [],
         response_item_keys: [],
         items_by_id: {},
         active_item_id: nil,
         current_text_content_part: nil,
+        current_reasoning_content_part: nil,
         usage: nil
       }
     end
@@ -252,7 +258,9 @@ module Kward
       when "response.reasoning_summary_part.done"
         codex_reasoning_part_done(state, on_reasoning_delta: on_reasoning_delta)
       when "response.reasoning_text.delta"
-        codex_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+        codex_raw_reasoning_delta(state, event["delta"], on_reasoning_delta: on_reasoning_delta)
+      when "response.reasoning_text.done"
+        codex_raw_reasoning_done(state, event["text"], on_reasoning_delta: on_reasoning_delta)
       when "response.function_call_arguments.delta", "response.custom_tool_call_input.delta"
         codex_tool_arguments_delta(state, event["delta"])
       when "response.function_call_arguments.done"
@@ -299,6 +307,7 @@ module Kward
       remember_codex_item(state, item)
       state[:active_item_id] = codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_content_part_added(state, part)
@@ -333,20 +342,53 @@ module Kward
 
       item["summary"] ||= []
       item["summary"] << deep_dup_hash(part)
+      state[:current_reasoning_content_part] = nil
     end
 
     def codex_reasoning_delta(state, delta, on_reasoning_delta: nil)
+      text = visible_codex_reasoning_delta(state, delta)
+      return if text.empty?
+
+      append_codex_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta)
+    end
+
+    def codex_raw_reasoning_delta(state, delta, on_reasoning_delta: nil)
       text = delta.to_s
       return if text.empty?
 
       item = active_codex_item(state)
-      if item&.fetch("type", nil) == "reasoning"
-        item["summary"] ||= []
-        item["summary"] << { "type" => "summary_text", "text" => +"" } if item["summary"].empty?
-        item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = part["text"].to_s + text
+        state[:current_reasoning_content_part] = part
       end
-      state[:reasoning_summary] << text
-      on_reasoning_delta&.call(text)
+      return unless state[:show_raw_reasoning]
+
+      visible = visible_codex_reasoning_delta(state, text)
+      append_codex_raw_reasoning_text(state, visible, on_reasoning_delta: on_reasoning_delta) unless visible.empty?
+    end
+
+    def codex_raw_reasoning_done(state, text, on_reasoning_delta: nil)
+      item = active_codex_item(state)
+      full_text = text.to_s
+      if item&.fetch("type", nil) == "reasoning" && state[:show_raw_reasoning]
+        item["content"] ||= [{ "type" => "reasoning_text", "text" => +"" }]
+        part = state[:current_reasoning_content_part] || item["content"].last
+        part = item["content"].last unless part.is_a?(Hash)
+        part["type"] ||= "reasoning_text"
+        part["text"] = full_text
+        state[:current_reasoning_content_part] = part
+      end
+      return unless state[:show_raw_reasoning]
+
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
+      visible = sanitize_codex_reasoning_text(full_text)
+      emitted = state[:raw_reasoning_visible]
+      text = visible.start_with?(emitted) ? visible[emitted.length..].to_s : (emitted.empty? ? visible : +"")
+      append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
     end
 
     def codex_reasoning_part_done(state, on_reasoning_delta: nil)
@@ -354,12 +396,97 @@ module Kward
       return unless item&.fetch("type", nil) == "reasoning"
       return if item["summary"].to_a.empty?
 
+      flush_codex_reasoning_delta(state, on_reasoning_delta: on_reasoning_delta)
       text = "\n\n"
       item["summary"].last["text"] = item["summary"].last["text"].to_s + text
       state[:reasoning_summary] << text
       on_reasoning_delta&.call(text)
     end
 
+    def append_codex_reasoning_text(state, text, on_reasoning_delta: nil)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
+
+      item = active_codex_item(state)
+      if item&.fetch("type", nil) == "reasoning"
+        item["summary"] ||= []
+        item["summary"] << { "type" => "summary_text", "text" => +"" } if item["summary"].empty?
+        item["summary"].last["text"] = item["summary"].last["text"].to_s + text
+      end
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def append_codex_raw_reasoning_text(state, text, on_reasoning_delta: nil)
+      text = compact_codex_reasoning_delta_spacing(state[:reasoning_summary], text)
+      return if text.empty?
+
+      state[:raw_reasoning_visible] << text
+      state[:reasoning_summary] << text
+      on_reasoning_delta&.call(text)
+    end
+
+    def visible_codex_reasoning_delta(state, delta)
+      state[:pending_reasoning_delta] << delta.to_s
+      sanitized = sanitize_codex_reasoning_text(state[:pending_reasoning_delta], keep_incomplete_comment: true)
+      text, pending_prefix = split_trailing_comment_prefix(sanitized[:text])
+      state[:pending_reasoning_delta].replace(pending_prefix + sanitized[:pending])
+      text
+    end
+
+    def flush_codex_reasoning_delta(state, on_reasoning_delta: nil)
+      pending = state[:pending_reasoning_delta].to_s
+      state[:pending_reasoning_delta].clear
+      text = sanitize_codex_reasoning_text(pending)
+      append_codex_raw_reasoning_text(state, text, on_reasoning_delta: on_reasoning_delta) unless text.empty?
+    end
+
+    def split_trailing_comment_prefix(text)
+      string = text.to_s
+      prefix = ["<!-", "<!", "<"].find { |candidate| string.end_with?(candidate) }
+      return [string, +""] unless prefix
+
+      [string[0...-prefix.length], prefix.dup]
+    end
+
+    def sanitize_codex_reasoning_text(text, keep_incomplete_comment: false)
+      string = text.to_s
+      visible = +""
+      index = 0
+
+      while (start_index = string.index("<!--", index))
+        end_index = string.index("-->", start_index + 4)
+        if end_index
+          visible << string[index...start_index]
+          index = end_index + 3
+        elsif keep_incomplete_comment
+          visible << string[index...start_index]
+          return { text: visible, pending: string[start_index..] }
+        else
+          visible << string[index..]
+          index = string.length
+        end
+      end
+
+      visible << string[index..].to_s
+      visible = compact_blank_codex_reasoning_lines(visible)
+      keep_incomplete_comment ? { text: visible, pending: +"" } : visible
+    end
+
+    def compact_blank_codex_reasoning_lines(text)
+      text.to_s.gsub(/(?:[ \t]*\n){3,}/, "\n\n")
+    end
+
+    def compact_codex_reasoning_delta_spacing(existing, text)
+      text = compact_blank_codex_reasoning_lines(text)
+      trailing_newlines = existing.to_s[/\n+\z/].to_s.length
+      leading_newlines = text[/\A\n+/].to_s.length
+      excess_newlines = trailing_newlines + leading_newlines - 2
+      return text unless excess_newlines.positive? && leading_newlines.positive?
+
+      text[[excess_newlines, leading_newlines].min..].to_s
+    end
+
     def codex_tool_arguments_delta(state, delta)
       item = active_codex_item(state)
       return unless item && ["function_call", "custom_tool_call"].include?(item["type"])
@@ -379,10 +506,40 @@ module Kward
       return unless item.is_a?(Hash)
 
       item = merge_codex_item(active_or_known_codex_item(state, item), item)
+      item = codex_visible_reasoning_item(state, item)
       remember_codex_item(state, item)
       collect_codex_item_output(state, item, on_assistant_delta: on_assistant_delta, on_reasoning_delta: on_reasoning_delta)
       state[:active_item_id] = nil if state[:active_item_id] == codex_item_key(item)
       state[:current_text_content_part] = nil
+      state[:current_reasoning_content_part] = nil
+    end
+
+    def codex_visible_reasoning_item(state, item)
+      return item unless item.is_a?(Hash) && item["type"] == "reasoning"
+
+      visible = deep_dup_hash(item)
+      sanitize_codex_reasoning_summary_item(visible)
+      visible.delete("content") unless state[:show_raw_reasoning]
+      return visible unless state[:show_raw_reasoning]
+      return visible if visible["summary"].is_a?(Array) && !visible["summary"].empty?
+
+      text = sanitize_codex_reasoning_text(raw_reasoning_from_codex_items([visible]))
+      visible["summary"] = [{ "type" => "summary_text", "text" => text }] unless text.empty?
+      visible
+    end
+
+    def sanitize_codex_reasoning_summary_item(item)
+      return unless item["summary"].is_a?(Array)
+
+      pending = +""
+      item["summary"].each do |part|
+        next unless part.is_a?(Hash) && part.key?("text")
+
+        pending << part["text"].to_s
+        sanitized = sanitize_codex_reasoning_text(pending, keep_incomplete_comment: true)
+        part["text"] = sanitized[:text]
+        pending.replace(sanitized[:pending])
+      end
     end
 
     def collect_codex_item_output(state, item, on_assistant_delta: nil, on_reasoning_delta: nil)
@@ -398,7 +555,7 @@ module Kward
           state[:emitted_message_keys] << key
         end
       when "reasoning"
-        text = reasoning_summary_from_codex_items([item])
+        text = sanitize_codex_reasoning_text(reasoning_summary_from_codex_items([item]))
         if state[:reasoning_summary].empty? && !text.empty?
           state[:reasoning_summary] << text
           on_reasoning_delta&.call(text)
@@ -563,5 +720,13 @@ module Kward
         end
       end.join
     end
+
+    def raw_reasoning_from_codex_items(items)
+      items.flat_map do |item|
+        next [] unless item.is_a?(Hash) && item["type"] == "reasoning" && item["content"].is_a?(Array)
+
+        item["content"].filter_map { |part| part["text"] if part.is_a?(Hash) && part["type"] == "reasoning_text" }
+      end.join
+    end
   end
 end

data/lib/kward/pan/server.rb

@@ -9,6 +9,8 @@ require_relative "../agent"
 require_relative "../config_files"
 require_relative "../events"
 require_relative "../model/retry_message"
+require_relative "../plugin_registry"
+require_relative "../prompts/commands"
 require_relative "../rpc/transcript_normalizer"
 require_relative "../session_store"
 require_relative "../tools/tool_call"
@@ -42,10 +44,14 @@ module Kward
         reasoning_effort: (@client.current_reasoning_effort if @client.respond_to?(:current_reasoning_effort))
       )
       @session.attach(@conversation)
+      hook_context = lifecycle_hook_context
+      hook_manager = lifecycle_hook_manager
       @agent = Agent.new(
         client: @client,
-        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false),
-        conversation: @conversation
+        tool_registry: ToolRegistry.new(workspace: @workspace, ask_user_question_enabled: false, hook_manager: hook_manager, hook_context: hook_context),
+        conversation: @conversation,
+        hook_manager: hook_manager,
+        hook_context: hook_context
       )
       @prompt_queue = Queue.new
       @subscribers = []
@@ -97,6 +103,49 @@ module Kward
 
     private
 
+    def lifecycle_hook_manager
+      manager = Hooks::ConfigLoader.new(ConfigFiles.lifecycle_hooks_config(@workspace.root)).manager
+      manager.on_result = method(:broadcast_lifecycle_hook_event)
+      plugin_registry.hook_handlers.each do |hook|
+        manager.register(hook.event, id: hook.id, source: hook.path, order: hook.order, match: hook.match, failure_policy: hook.failure_policy) do |event, context|
+          hook.handler.call(event, context)
+        end
+      end
+      manager
+    end
+
+    def broadcast_lifecycle_hook_event(event, result)
+      broadcast("hook_event", {
+        event: {
+          id: event.id,
+          name: event.name,
+          phase: event.phase,
+          timestamp: event.timestamp.iso8601,
+          payloadKeys: event.payload.keys.map(&:to_s).sort
+        },
+        result: {
+          decision: result.decision.decision,
+          warnings: result.warnings,
+          messages: result.messages,
+          decisionCount: result.decisions.length
+        }
+      })
+    end
+
+    def lifecycle_hook_context
+      PluginRegistry::Context.new(
+        conversation: @conversation,
+        args: "",
+        session: @session,
+        workspace_root: @workspace.root.to_s,
+        say_callback: lambda { |message| broadcast("hook_message", { message: message.to_s }) }
+      )
+    end
+
+    def plugin_registry
+      @plugin_registry ||= PluginRegistry.load(reserved_commands: PromptCommands::BUILTIN_RESERVED_COMMAND_NAMES)
+    end
+
     def start_worker
       return if @worker_started
 

data/lib/kward/path_guard.rb

@@ -0,0 +1,13 @@
+# Namespace for the Kward CLI agent runtime.
+module Kward
+  # Shared path containment predicate for local filesystem guardrails.
+  module PathGuard
+    module_function
+
+    def inside?(path, root)
+      path = path.to_s
+      root = root.to_s
+      path == root || path.start_with?(root + File::SEPARATOR)
+    end
+  end
+end