kward 0.77.0 → 0.79.0

data/lib/kward/local_command_runner.rb

@@ -18,7 +18,7 @@ module Kward
       @terminate_on_output_limit = terminate_on_output_limit
     end
 
-    def run(*command, env: {}, cwd: Dir.pwd, cancellation: nil, &block)
+    def run(*command, env: {}, cwd: Dir.pwd, cancellation: nil, unsetenv_others: false, &block)
       cancellation&.raise_if_cancelled!
       stdout_buffer = +""
       stderr_buffer = +""
@@ -27,7 +27,7 @@ module Kward
       timed_out = false
       queue = Queue.new
 
-      Open3.popen3(env.to_h, *command, chdir: cwd.to_s, pgroup: true) do |stdin, stdout, stderr, wait_thread|
+      Open3.popen3(env.to_h, *command, chdir: cwd.to_s, pgroup: true, unsetenv_others: unsetenv_others) do |stdin, stdout, stderr, wait_thread|
         stdin.close
         readers = [
           read_stream(stdout, :stdout, queue),

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 "../http"
 require_relative "../openrouter_model_cache"
 require_relative "context_overflow"
 require_relative "copilot_models"
@@ -28,6 +29,11 @@ module Kward
     OPENROUTER_URL = URI("https://openrouter.ai/api/v1/chat/completions")
     CODEX_URL = URI("https://chatgpt.com/backend-api/codex/responses")
     ANTHROPIC_URL = URI("https://api.anthropic.com/v1/messages")
+    LOCAL_BASE_URLS = {
+      "ollama" => "http://127.0.0.1:11434/v1",
+      "lm_studio" => "http://127.0.0.1:1234/v1",
+      "llama_cpp" => "http://127.0.0.1:8080/v1"
+    }.freeze
     AUTH_ERROR = "No OpenAI OAuth login found. Run `ruby lib/main.rb login`, or set OPENAI_ACCESS_TOKEN/OPENROUTER_API_KEY."
     OPENROUTER_AUTH_ERROR = "No OpenRouter API key found. Set OPENROUTER_API_KEY or add openrouter_api_key to your Kward config."
     COPILOT_AUTH_ERROR = "No GitHub Copilot OAuth login found. Run `ruby lib/main.rb login github` or set COPILOT_GITHUB_TOKEN."
@@ -35,6 +41,7 @@ module Kward
     DEFAULT_OPENAI_MODEL = ModelInfo::DEFAULT_OPENAI_MODEL
     DEFAULT_REASONING_EFFORT = ModelInfo::DEFAULT_REASONING_EFFORT
     RETRY_DELAYS = [1, 2].freeze
+    DEFAULT_STREAM_IDLE_TIMEOUT_SECONDS = 120
     NON_RETRYABLE_PROVIDER_LIMIT_PATTERNS = [
       /GoUsageLimitError/i,
       /FreeUsageLimitError/i,
@@ -92,18 +99,19 @@ module Kward
       @telemetry_logger = telemetry_logger
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     def chat(messages, tools: [], on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, on_retry: nil, cancellation: nil, steering: nil, max_tokens: nil, provider: nil, model: nil, reasoning: nil)
       cancellation&.raise_if_cancelled!
       requested_provider = provider
       url, token, resolved_provider, account_id = credentials(provider: requested_provider)
-      if token.to_s.empty? && !requested_provider.to_s.empty?
+      if token.to_s.empty? && authentication_required?(resolved_provider) && !requested_provider.to_s.empty?
         url, token, resolved_provider, account_id = credentials
         model = nil
         reasoning = nil
       end
-      raise auth_error_for(resolved_provider) if token.nil? || token.empty?
+      raise auth_error_for(resolved_provider) if authentication_required?(resolved_provider) && (token.nil? || token.empty?)
 
       current_model = model_for(resolved_provider, override_model: model)
       current_model = resolved_copilot_chat_model(current_model) if resolved_provider == "Copilot" && model.nil?
@@ -178,7 +186,10 @@ module Kward
 
     # Returns the known context window for a provider/model pair.
     def context_window(provider, model)
-      context_window_for(ModelInfo.provider_label(provider), model)
+      provider = ModelInfo.provider_label(provider)
+      return local_context_window if provider == "Local"
+
+      context_window_for(provider, model)
     end
 
     # Returns model choices suitable for settings UIs.
@@ -224,6 +235,14 @@ module Kward
         models << model_entry("Anthropic", anthropic_model, current: provider == "Anthropic") unless ModelInfo::ANTHROPIC_MODEL_CHOICES.include?(anthropic_model)
       end
 
+      if provider_logged_in?("Local")
+        local_model = model_for("Local")
+        local_model_choices.each do |id|
+          models << model_entry("Local", id, current: provider == "Local" && local_model == id)
+        end
+        models << model_entry("Local", local_model, current: provider == "Local") unless local_model.to_s.empty? || local_model_choices.include?(local_model)
+      end
+
       # Sort models by provider, then alphabetically by id
       models.sort_by { |model| [model[:provider], model[:id]] }
     end
@@ -245,6 +264,7 @@ module Kward
       @config = load_config
       @copilot_models = nil
       @openrouter_models = nil
+      @local_models = nil
     end
 
     private
@@ -296,6 +316,15 @@ module Kward
           on_assistant_delta: on_assistant_delta,
           cancellation: cancellation
         )
+      when "Local"
+        chat_local_provider(
+          url: url,
+          token: token,
+          request_body: request_body,
+          current_model: current_model,
+          on_assistant_delta: on_assistant_delta,
+          cancellation: cancellation
+        )
       else
         chat_openrouter_provider(
           url: url,
@@ -335,7 +364,7 @@ module Kward
     end
 
     def chat_anthropic_provider(url:, token:, request_body:, current_model:, on_reasoning_delta:, on_assistant_delta:, cancellation:)
-      request = Net::HTTP::Post.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
@@ -343,7 +372,7 @@ module Kward
       request.body = request_body
 
       message = nil
-      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: nil) do |http|
+      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) do |http|
         cancellation&.on_cancel { close_http(http) }
         cancellation&.raise_if_cancelled!
         http.request(request) do |response|
@@ -360,8 +389,33 @@ module Kward
       attach_response_metadata(message, provider: "Anthropic", model: current_model)
     end
 
+    def chat_local_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
+      request["Authorization"] = "Bearer #{token}" unless token.to_s.empty?
+      request["Content-Type"] = "application/json"
+      request["Accept"] = "text/event-stream"
+      request.body = request_body
+
+      message = nil
+      Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) do |http|
+        cancellation&.on_cancel { close_http(http) }
+        cancellation&.raise_if_cancelled!
+        http.request(request) do |response|
+          unless response.is_a?(Net::HTTPSuccess)
+            body = +""
+            response.read_body { |chunk| body << chunk }
+            raise RequestError.new(provider: "Local", code: response.code, body: redact(body, token))
+          end
+
+          message = parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, provider_label: "Local")
+        end
+      end
+      cancellation&.raise_if_cancelled!
+      attach_response_metadata(message, provider: "Local", model: current_model)
+    end
+
     def chat_openrouter_provider(url:, token:, request_body:, current_model:, on_assistant_delta:, cancellation:)
-      request = Net::HTTP::Post.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Content-Type"] = "application/json"
       request.body = request_body
@@ -502,9 +556,30 @@ module Kward
     end
 
     def context_window_for(provider, id)
+      return local_context_window if provider == "Local"
+
       ModelInfo.context_window(provider, id, openrouter_models: openrouter_cached_model_entries)
     end
 
+    def local_model_choices
+      return @local_models if @local_models
+
+      url = local_models_url
+      request = Http.apply_user_agent(Net::HTTP::Get.new(url))
+      request["Authorization"] = "Bearer #{local_api_key}" unless local_api_key.to_s.empty?
+      request["Accept"] = "application/json"
+      response = Net::HTTP.start(url.hostname, url.port, use_ssl: url.scheme == "https", read_timeout: stream_idle_timeout_seconds) { |http| http.request(request) }
+      return @local_models = [] unless response.is_a?(Net::HTTPSuccess)
+
+      body = JSON.parse(response.body)
+      entries = body["data"] || body["models"] || []
+      @local_models = Array(entries).filter_map do |entry|
+        entry.is_a?(Hash) ? entry["id"] || entry[:id] || entry["model"] || entry[:model] : entry
+      end.map(&:to_s).map(&:strip).reject(&:empty?).uniq
+    rescue StandardError
+      @local_models = []
+    end
+
     def openrouter_model_choices
       openrouter_cached_models.uniq
     end
@@ -547,7 +622,7 @@ module Kward
       return [] if token.empty?
 
       url = URI("#{@github_oauth.base_url}/models")
-      request = Net::HTTP::Get.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Get.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Accept"] = "application/json"
       copilot_headers([]).each { |key, value| request[key] = value }
@@ -577,7 +652,7 @@ module Kward
 
     def copilot_responses_chat(token, request_body:, on_assistant_delta: nil, cancellation: nil)
       url = URI("#{@github_oauth.base_url}/responses")
-      request = Net::HTTP::Post.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
@@ -585,7 +660,7 @@ module Kward
       request.body = request_body
 
       message = nil
-      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: nil) do |http|
+      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) do |http|
         cancellation&.on_cancel { close_http(http) }
         cancellation&.raise_if_cancelled!
         http.request(request) do |response|
@@ -603,7 +678,7 @@ module Kward
     end
 
     def copilot_chat(url, token, messages, tools, request_body: nil, on_assistant_delta: nil, cancellation: nil)
-      request = Net::HTTP::Post.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
@@ -625,7 +700,11 @@ module Kward
     end
 
     def parse_openai_chat_sse(body, on_assistant_delta: nil)
-      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage))
+      ModelStreamParser.parse_openai_chat_sse(body, on_assistant_delta: on_assistant_delta, usage_normalizer: method(:normalized_usage), provider_label: "Copilot")
+    end
+
+    def parse_openai_chat_sse_stream(response, on_assistant_delta: nil, cancellation: nil, provider_label: "OpenAI-compatible provider")
+      ModelStreamParser.parse_openai_chat_sse_stream(response, on_assistant_delta: on_assistant_delta, cancellation: cancellation, usage_normalizer: method(:normalized_usage), provider_label: provider_label)
     end
 
     def anthropic_headers
@@ -633,7 +712,6 @@ module Kward
         "anthropic-version" => "2023-06-01",
         "anthropic-beta" => "claude-code-20250219,oauth-2025-04-20",
         "anthropic-dangerous-direct-browser-access" => "true",
-        "user-agent" => "claude-cli/2.1.75",
         "x-app" => "cli"
       }
     end
@@ -653,16 +731,16 @@ module Kward
     end
 
     def codex_chat(url, token, account_id, messages, tools, request_body: nil, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, cancellation: nil, max_tokens: nil)
-      request = Net::HTTP::Post.new(url)
+      request = Http.apply_user_agent(Net::HTTP::Post.new(url))
       request["Authorization"] = "Bearer #{token}"
       request["ChatGPT-Account-Id"] = account_id if account_id
       request["Content-Type"] = "application/json"
       request["Accept"] = "text/event-stream"
-      request["originator"] = "codex_cli_rs"
       request.body = request_body || JSON.dump(codex_payload(messages, tools, max_tokens: max_tokens))
+      apply_codex_identity(request, luna: luna_request?(request.body))
 
       message = nil
-      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: nil) do |http|
+      Net::HTTP.start(url.hostname, url.port, use_ssl: true, read_timeout: stream_idle_timeout_seconds) do |http|
         cancellation&.on_cancel { close_http(http) }
         cancellation&.raise_if_cancelled!
         http.request(request) do |response|
@@ -684,6 +762,22 @@ module Kward
       raise e
     end
 
+    def apply_codex_identity(request, luna:)
+      request["originator"] = "kward"
+      return unless luna
+
+      # TODO: Remove this Luna-specific Responses Lite workaround when Codex accepts Kward's own client identity.
+      request["originator"] = "codex_cli_rs"
+      request["User-Agent"] = "codex_cli_rs/0.144.1"
+      request["x-openai-internal-codex-responses-lite"] = "true"
+    end
+
+    def luna_request?(request_body)
+      JSON.parse(request_body)["model"] == "gpt-5.6-luna"
+    rescue JSON::ParserError
+      false
+    end
+
     def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil)
       ModelStreamParser.parse_codex_sse(body, on_reasoning_delta: on_reasoning_delta, on_reasoning_boundary: on_reasoning_boundary, on_assistant_delta: on_assistant_delta, show_raw_reasoning: codex_show_raw_reasoning?, usage_normalizer: method(:normalized_usage), request_error_class: RequestError)
     end
@@ -759,6 +853,10 @@ module Kward
 
     def credentials(provider: nil)
       provider = provider.to_s.empty? ? ModelInfo.provider_label(configured_provider) : ModelInfo.provider_label(provider)
+      if provider == "Local"
+        return [local_chat_url, local_api_key, provider, nil]
+      end
+
       if provider == "Copilot"
         return [copilot_chat_url, github_access_token, provider, nil]
       end
@@ -789,8 +887,14 @@ module Kward
       ModelInfo.reasoning_effort(config: @config, provider: provider)
     end
 
+    def authentication_required?(provider)
+      provider != "Local"
+    end
+
     def provider_logged_in?(provider)
       case provider
+      when "Local"
+        local_configured?
       when "Codex"
         openai_configured?
       when "OpenRouter"
@@ -812,6 +916,53 @@ module Kward
       false
     end
 
+    def local_configured?
+      configured_provider == "local" || !local_model.to_s.empty? || !config_value("local_base_url").to_s.empty? || !ENV["KWARD_LOCAL_BASE_URL"].to_s.empty?
+    end
+
+    def local_model
+      ENV["KWARD_LOCAL_MODEL"] || config_value("local_model")
+    end
+
+    def local_context_window
+      value = ENV["KWARD_LOCAL_CONTEXT_WINDOW"] || config_value("local_context_window")
+      positive_integer(value)
+    end
+
+    def local_api_key
+      ENV["KWARD_LOCAL_API_KEY"] || config_value("local_api_key")
+    end
+
+    def local_backend
+      presence(ENV["KWARD_LOCAL_BACKEND"].to_s.strip) || presence(config_value("local_backend").to_s.strip) || "ollama"
+    end
+
+    def local_base_url
+      configured = presence(ENV["KWARD_LOCAL_BASE_URL"].to_s.strip) || presence(config_value("local_base_url").to_s.strip)
+      return configured if configured
+
+      LOCAL_BASE_URLS.fetch(local_backend) { raise "Unknown local model backend: #{local_backend}" }
+    end
+
+    def local_chat_url
+      local_url("chat/completions")
+    end
+
+    def local_models_url
+      local_url("models")
+    end
+
+    def local_url(path)
+      base = URI.parse(local_base_url)
+      unless base.is_a?(URI::HTTP) && base.host && !base.host.empty? && base.user.nil? && base.password.nil? && base.query.nil? && base.fragment.nil?
+        raise "Invalid local model URL: #{local_base_url}"
+      end
+
+      URI("#{base.to_s.sub(%r{/+\z}, "")}/#{path}")
+    rescue URI::InvalidURIError
+      raise "Invalid local model URL: #{local_base_url}"
+    end
+
     def openrouter_api_key
       @openrouter_api_key || config_value("openrouter_api_key")
     end
@@ -842,11 +993,18 @@ module Kward
       @config["codex_show_raw_reasoning"] == true
     end
 
+    def stream_idle_timeout_seconds
+      value = @config["stream_idle_timeout_seconds"].to_i
+      value.positive? ? value : DEFAULT_STREAM_IDLE_TIMEOUT_SECONDS
+    end
+
     def load_config
       ConfigFiles.read_config(@config_path)
     end
 
     def redact(text, token)
+      return text.to_s if token.to_s.empty?
+
       text.to_s.gsub(token.to_s, "[REDACTED]")
     end
 

data/lib/kward/model/model_info.rb

@@ -128,6 +128,8 @@ module Kward
       return override_model if override_model
 
       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"
@@ -175,6 +177,8 @@ module Kward
 
     def reasoning_effort(config:, env: ENV, provider: nil)
       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"
@@ -191,6 +195,7 @@ module Kward
       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
@@ -201,6 +206,7 @@ module Kward
       when "openrouter" then "openrouter"
       when "copilot" then "copilot"
       when "anthropic", "claude" then "anthropic"
+      when "local" then "local"
       else "codex"
       end
     end
@@ -210,6 +216,7 @@ module Kward
       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
@@ -219,6 +226,7 @@ module Kward
       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
@@ -357,7 +365,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
 

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
@@ -126,7 +127,12 @@ module Kward
         store: false,
         include: []
       }
-      payload[:reasoning] = { effort: reasoning || reasoning_effort("Codex"), summary: "auto" } unless reasoning == false
+      unless reasoning == false
+        effort = reasoning || reasoning_effort("Codex")
+        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"
+      end
       payload
     end
 

data/lib/kward/model/stream_parser.rb

@@ -13,36 +13,68 @@ module Kward
   module ModelStreamParser
     module_function
 
-    def parse_openai_chat_sse(body, on_assistant_delta: nil, usage_normalizer: nil)
-      content = +""
-      tool_calls = []
-      usage = nil
+    def parse_openai_chat_sse(body, on_assistant_delta: nil, usage_normalizer: nil, provider_label: "OpenAI-compatible provider")
+      state = openai_chat_sse_state
       body.split(/\r?\n\r?\n/).each do |block|
-        data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
-        next if data.empty? || data == "[DONE]"
-
-        event = JSON.parse(data)
-        usage ||= usage_normalizer&.call(event["usage"])
-        choice = Array(event["choices"]).first || {}
-        delta = choice["delta"] || {}
-        if delta["content"]
-          text = delta["content"].to_s
-          content << text
-          on_assistant_delta&.call(text)
-        end
-        Array(delta["tool_calls"]).each do |tool_call|
-          merge_streaming_tool_call(tool_calls, tool_call)
+        process_openai_chat_sse_block(block, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer)
+      end
+      openai_chat_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
+    end
+
+    # Incrementally parses a Chat Completions SSE HTTP response body. Local
+    # OpenAI-compatible servers stream this shape, so emit assistant deltas as
+    # complete SSE blocks arrive rather than waiting for connection close.
+    def parse_openai_chat_sse_stream(response, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, provider_label: "OpenAI-compatible provider")
+      state = openai_chat_sse_state
+      buffer = +""
+
+      response.read_body do |chunk|
+        cancellation&.raise_if_cancelled!
+        buffer << chunk
+        while (index = buffer.index(/\r?\n\r?\n/))
+          delimiter = Regexp.last_match[0]
+          block = buffer[0...index]
+          buffer = buffer[(index + delimiter.length)..] || +""
+          process_openai_chat_sse_block(block, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer)
         end
-        message = choice["message"] || {}
-        content << message["content"].to_s if content.empty? && message["content"]
-        Array(message["tool_calls"]).each { |tool_call| merge_streaming_tool_call(tool_calls, tool_call) }
       end
-      result = { "role" => "assistant", "content" => content }
-      result["tool_calls"] = finalized_streaming_tool_calls(tool_calls) unless tool_calls.empty?
-      result["usage"] = usage if usage
-      result
+      cancellation&.raise_if_cancelled!
+      process_openai_chat_sse_block(buffer, state, on_assistant_delta: on_assistant_delta, usage_normalizer: usage_normalizer) unless buffer.empty?
+      openai_chat_sse_message(state)
     rescue JSON::ParserError => e
-      raise "Copilot returned invalid SSE JSON: #{e.message}"
+      raise "#{provider_label} returned invalid SSE JSON: #{e.message}"
+    end
+
+    def openai_chat_sse_state
+      { content: +"", tool_calls: [], usage: nil }
+    end
+
+    def process_openai_chat_sse_block(block, state, on_assistant_delta: nil, usage_normalizer: nil)
+      data = block.lines.filter_map { |line| line.start_with?("data:") ? line.delete_prefix("data:").strip : nil }.join("\n")
+      return if data.empty? || data == "[DONE]"
+
+      event = JSON.parse(data)
+      state[:usage] ||= usage_normalizer&.call(event["usage"])
+      choice = Array(event["choices"]).first || {}
+      delta = choice["delta"] || {}
+      if delta["content"]
+        text = delta["content"].to_s
+        state[:content] << text
+        on_assistant_delta&.call(text)
+      end
+      Array(delta["tool_calls"]).each { |tool_call| merge_streaming_tool_call(state[:tool_calls], tool_call) }
+      message = choice["message"] || {}
+      state[:content] << message["content"].to_s if state[:content].empty? && message["content"]
+      Array(message["tool_calls"]).each { |tool_call| merge_streaming_tool_call(state[:tool_calls], tool_call) }
+    end
+
+    def openai_chat_sse_message(state)
+      result = { "role" => "assistant", "content" => state[:content] }
+      result["tool_calls"] = finalized_streaming_tool_calls(state[:tool_calls]) unless state[:tool_calls].empty?
+      result["usage"] = state[:usage] if state[:usage]
+      result
     end
 
     def parse_codex_sse(body, on_reasoning_delta: nil, on_reasoning_boundary: nil, on_assistant_delta: nil, show_raw_reasoning: false, usage_normalizer: nil, request_error_class: nil)

data/lib/kward/openrouter_model_cache.rb

@@ -4,6 +4,7 @@ require "net/http"
 require "time"
 require "uri"
 require_relative "config_files"
+require_relative "http"
 require_relative "private_file"
 
 # Namespace for the Kward CLI agent runtime.
@@ -71,7 +72,7 @@ module Kward
     private
 
     def refresh_request
-      Net::HTTP::Get.new(MODELS_URL).tap do |request|
+      Http.apply_user_agent(Net::HTTP::Get.new(MODELS_URL)).tap do |request|
         request["Authorization"] = "Bearer #{@api_key}"
         request["Accept"] = "application/json"
       end

data/lib/kward/pan/index.html.erb

@@ -164,6 +164,7 @@
           <div class="title-row"><span class="live-dot"></span><h1 id="conversation-title">New session</h1></div>
           <div class="top-meta" id="session-meta">Secure LAN workspace</div>
         </div>
+        <button class="text-button" id="capture-skill" type="button">Capture skill</button>
         <button class="text-button" id="rename-session" type="button">Rename</button>
         <button class="text-button danger" id="delete-session" type="button">Delete</button>
       </header>
@@ -456,7 +457,56 @@
     document.getElementById('open-sessions').addEventListener('click', () => document.body.classList.add('sessions-open'));
     document.getElementById('close-sessions').addEventListener('click', closeSessions);
     document.getElementById('backdrop').addEventListener('click', closeSessions);
+    async function captureSkill() {
+      try {
+        const sourceResponse = await fetch('/skill-capture/sessions', { cache: 'no-store' });
+        const sourceData = await sourceResponse.json();
+        const candidates = sourceData.sessions || [];
+        if (!candidates.length) throw new Error('No saved sessions found.');
+        const choices = candidates.map((session, index) => `${index + 1}. ${session.name || session.firstMessage || 'Untitled session'}`).join('\n');
+        const answer = window.prompt(`Capture a personal skill from which saved session?\n\n${choices}`, '1');
+        if (answer === null) return;
+        const source = candidates[Number(answer) - 1];
+        if (!source) throw new Error('Choose a session number from the list.');
+        setStatus({ active: true, pending: 0 });
+        const draftResponse = await fetch('/skill-capture/draft', {
+          method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ sessionPath: source.path })
+        });
+        const draft = await draftResponse.json();
+        if (!draftResponse.ok || !draft.ok) throw new Error(draft.error || 'Could not create a skill draft.');
+        reviewSkillDraft(draft.content);
+      } catch (error) {
+        showError(error.message);
+      } finally {
+        setStatus({ active: false, pending: 0 });
+      }
+    }
+
+    function reviewSkillDraft(content) {
+      const overlay = document.createElement('div');
+      overlay.style.cssText = 'position:fixed;inset:0;z-index:50;display:grid;place-items:center;padding:1rem;background:#000b';
+      const panel = document.createElement('section');
+      panel.style.cssText = 'display:grid;gap:.8rem;width:min(58rem,100%);max-height:90dvh;padding:1rem;border:1px solid var(--line-bright);border-radius:12px;background:var(--panel)';
+      const heading = document.createElement('strong'); heading.textContent = 'Review captured skill';
+      const note = document.createElement('p'); note.style.margin = '0'; note.style.color = 'var(--muted)'; note.textContent = 'Edit the draft. Saving writes a personal skill but does not activate it.';
+      const editor = document.createElement('textarea'); editor.value = content; editor.style.cssText = 'min-height:55dvh;resize:vertical;padding:.75rem;border:1px solid var(--line);border-radius:8px;background:var(--bg);color:var(--ink);font-family:ui-monospace,monospace;font-size:.8rem';
+      const actions = document.createElement('div'); actions.style.cssText = 'display:flex;justify-content:flex-end;gap:.6rem';
+      const cancel = document.createElement('button'); cancel.className = 'text-button'; cancel.textContent = 'Cancel';
+      const save = document.createElement('button'); save.className = 'new-session'; save.style.margin = '0'; save.textContent = 'Save personal skill';
+      cancel.onclick = () => overlay.remove();
+      save.onclick = async () => {
+        const request = async overwrite => fetch('/skill-capture/save', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ content: editor.value, overwrite }) });
+        let response = await request(false); let result = await response.json();
+        if (response.status === 409 && window.confirm(`${result.error}\n\nOverwrite it?`)) { response = await request(true); result = await response.json(); }
+        if (!response.ok || !result.ok) { showError(result.error || 'Could not save the skill.'); return; }
+        overlay.remove();
+        window.alert(`Saved personal skill: ${result.path}`);
+      };
+      actions.append(cancel, save); panel.append(heading, note, editor, actions); overlay.append(panel); document.body.append(overlay); editor.focus();
+    }
+
     document.getElementById('new-session').addEventListener('click', () => changeSession('new'));
+    document.getElementById('capture-skill').addEventListener('click', captureSkill);
     document.getElementById('rename-session').addEventListener('click', () => {
       if (!activeSession) return;
       const name = window.prompt('Session name', activeSession.name || '');