kward 0.66.0

data/lib/kward/model/context_overflow.rb

@@ -0,0 +1,55 @@
+module Kward
+  module ContextOverflow
+    OVERFLOW_PATTERNS = [
+      /prompt is too long/i,
+      /request_too_large/i,
+      /input is too long for requested model/i,
+      /exceeds the context window/i,
+      /exceeds (?:the )?(?:model'?s )?maximum context length of [\d,]+ tokens?/i,
+      /input token count.*exceeds the maximum/i,
+      /maximum prompt length is \d+/i,
+      /reduce the length of the messages/i,
+      /maximum context length is \d+ tokens/i,
+      /exceeds (?:the )?maximum allowed input length of [\d,]+ tokens?/i,
+      /input \(\d+ tokens\) is longer than the model'?s context length \(\d+ tokens\)/i,
+      /exceeds the limit of \d+/i,
+      /exceeds the available context size/i,
+      /greater than the context length/i,
+      /context window exceeds limit/i,
+      /exceeded model token limit/i,
+      /too large for model with \d+ maximum context length/i,
+      /model_context_window_exceeded/i,
+      /prompt too long; exceeded (?:max )?context length/i,
+      /context[_ ]length[_ ]exceeded/i,
+      /too many tokens/i,
+      /token limit exceeded/i
+    ].freeze
+
+    NON_OVERFLOW_PATTERNS = [
+      /^(Throttling error|Service unavailable):/i,
+      /rate limit/i,
+      /too many requests/i
+    ].freeze
+
+    module_function
+
+    def error?(error)
+      text = error_text(error)
+      return false if text.empty?
+      return false if NON_OVERFLOW_PATTERNS.any? { |pattern| text.match?(pattern) }
+      return true if request_too_large?(error)
+
+      OVERFLOW_PATTERNS.any? { |pattern| text.match?(pattern) }
+    end
+
+    def error_text(error)
+      parts = [error.message]
+      parts << error.body if error.respond_to?(:body)
+      parts.compact.join("\n")
+    end
+
+    def request_too_large?(error)
+      error.respond_to?(:code) && error.code.to_i == 413
+    end
+  end
+end

data/lib/kward/model/context_usage.rb

@@ -0,0 +1,104 @@
+require "json"
+require_relative "../message_access"
+
+module Kward
+  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
+      return nil if contains_image?(context_parts)
+
+      parts = stringify_keys(context_parts || {})
+      return nil unless contains_session_content?(parts)
+
+      payload = prompt_payload(parts)
+      return nil if payload.empty?
+
+      tokens = @token_counter.count(JSON.generate(payload), model: model)
+      {
+        tokens: tokens,
+        contextWindow: context_window,
+        percent: ((tokens.to_f / context_window.to_i) * 100).round(2),
+        estimated: true
+      }
+    rescue LoadError
+      nil
+    end
+
+    private
+
+    def prompt_payload(parts)
+      payload = {}
+      if parts.key?("instructions")
+        payload[:instructions] = parts["instructions"]
+      elsif parts.key?("messages")
+        payload[:messages] = parts["messages"]
+      end
+      payload[:input] = parts["input"] if parts.key?("input")
+      payload[:tools] = parts["tools"] if parts.key?("tools")
+      payload.compact
+    end
+
+    def contains_session_content?(parts)
+      input = parts["input"]
+      return !input.empty? if input.is_a?(Array)
+      return !input.to_s.empty? if parts.key?("input")
+
+      messages = parts["messages"]
+      return messages.any? { |message| MessageAccess.role(message) != "system" } if messages.is_a?(Array)
+
+      false
+    end
+
+    def contains_image?(value)
+      case value
+      when Hash
+        type = value[:type] || value["type"]
+        return true if ["image", "input_image", "image_url"].include?(type.to_s)
+        return true if value.key?(:image_url) || value.key?("image_url")
+
+        value.any? { |_key, item| contains_image?(item) }
+      when Array
+        value.any? { |item| contains_image?(item) }
+      else
+        false
+      end
+    end
+
+    def stringify_keys(value)
+      return value unless value.is_a?(Hash)
+
+      value.each_with_object({}) { |(key, item), result| result[key.to_s] = item }
+    end
+  end
+
+  class TiktokenTokenCounter
+    def count(text, model:)
+      encoding(model).encode(text.to_s).length
+    end
+
+    private
+
+    def encoding(model)
+      require "tiktoken_ruby"
+
+      Tiktoken.encoding_for_model(model.to_s)
+    rescue StandardError
+      Tiktoken.get_encoding(encoding_name_for_model(model))
+    end
+
+    def encoding_name_for_model(model)
+      id = model.to_s
+      return "o200k_base" if id.start_with?("gpt-5", "gpt-4.1", "gpt-4o", "o3", "o4")
+      return "cl100k_base" if id.start_with?("gpt-4", "gpt-3.5")
+
+      "o200k_base"
+    end
+  end
+end

data/lib/kward/model/model_info.rb

@@ -0,0 +1,188 @@
+require_relative "../config_files"
+
+module Kward
+  module ModelInfo
+    DEFAULT_OPENAI_MODEL = "gpt-5.5"
+    DEFAULT_OPENROUTER_MODEL = "openai/gpt-5.5"
+    DEFAULT_COPILOT_MODEL = "gpt-5-mini"
+    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}" }.freeze
+    COPILOT_MODEL_CHOICES = %w[
+      gpt-5-mini
+      gpt-5.3-codex
+      gpt-5.4
+      gpt-5.4-mini
+      gpt-5.5
+      claude-haiku-4.5
+      claude-opus-4.5
+      claude-opus-4.7
+      claude-opus-4.8
+      claude-sonnet-4.5
+      claude-sonnet-4.6
+      gemini-2.5-pro
+      gemini-3-flash-preview
+      gemini-3.1-pro-preview
+      gemini-3.5-flash
+      oswe-vscode-prime
+    ].freeze
+    REASONING_EFFORT_CHOICES = [
+      ["low", "Low"],
+      ["medium", "Medium"],
+      ["high", "High"],
+      ["xhigh", "Extra High"]
+    ].freeze
+
+    IMAGE_UNSUPPORTED_MODELS = [
+      /(?:\A|\/)gpt-5\.3-codex-spark\z/
+    ].freeze
+
+    OPENAI_CONTEXT_WINDOWS = [
+      [/\Agpt-5\.5/, 400_000],
+      [/\Agpt-5-codex/, 400_000],
+      [/\Agpt-5\.3-codex-spark/, 128_000],
+      [/\Agpt-5\.3-codex/, 400_000],
+      [/\Agpt-5\.2-codex/, 400_000],
+      [/\Agpt-5/, 400_000],
+      [/\Agpt-4\.1/, 1_047_576],
+      [/\Agpt-4o/, 128_000],
+      [/\Ao3/, 200_000],
+      [/\Ao4/, 200_000],
+      [/\Agpt-4/, 128_000],
+      [/\Agpt-3\.5-turbo/, 16_385]
+    ].freeze
+
+    module_function
+
+    def model_for(provider, config:, override_model: nil, env: ENV)
+      return override_model if override_model
+
+      case provider
+      when "OpenRouter"
+        env["OPENROUTER_MODEL"] || ConfigFiles.config_value(config, "openrouter_model", "model") || DEFAULT_OPENROUTER_MODEL
+      when "Copilot"
+        normalize_copilot_model(env["COPILOT_MODEL"] || ConfigFiles.config_value(config, "copilot_model", "model") || DEFAULT_COPILOT_MODEL)
+      else
+        env["OPENAI_MODEL"] || ConfigFiles.config_value(config, "openai_model", "model") || DEFAULT_OPENAI_MODEL
+      end
+    end
+
+    def normalize_copilot_model(id)
+      text = id.to_s.strip
+      return DEFAULT_COPILOT_MODEL if text.empty?
+      text = text.delete_prefix("copilot/")
+
+      {
+        "claude-haiku-4-5" => "claude-haiku-4.5",
+        "claude-opus-4-5" => "claude-opus-4.5",
+        "claude-opus-4-6" => "claude-opus-4.6",
+        "claude-opus-4-6-fast" => "claude-opus-4.6-fast",
+        "claude-opus-4-7" => "claude-opus-4.7",
+        "claude-opus-4-8" => "claude-opus-4.8",
+        "claude-sonnet-4-5" => "claude-sonnet-4.5",
+        "claude-sonnet-4-6" => "claude-sonnet-4.6",
+        "gemini-3.1-pro" => "gemini-3.1-pro-preview",
+        "gemini-3-flash" => "gemini-3-flash-preview"
+      }.fetch(text, text)
+    end
+
+    def reasoning_effort(config:, env: ENV, provider: nil)
+      case provider.to_s
+      when "OpenRouter"
+        env["OPENROUTER_REASONING_EFFORT"] || ConfigFiles.config_value(config, "openrouter_reasoning_effort", "reasoning_effort", "thinking_level") || DEFAULT_REASONING_EFFORT
+      when "Copilot"
+        env["COPILOT_REASONING_EFFORT"] || ConfigFiles.config_value(config, "copilot_reasoning_effort", "reasoning_effort", "thinking_level") || DEFAULT_REASONING_EFFORT
+      else
+        env["OPENAI_REASONING_EFFORT"] || ConfigFiles.config_value(config, "openai_reasoning_effort", "reasoning_effort", "thinking_level") || DEFAULT_REASONING_EFFORT
+      end
+    end
+
+    def provider_label(provider)
+      case provider.to_s.downcase
+      when "openrouter" then "OpenRouter"
+      when "copilot" then "Copilot"
+      when "codex", "openai" then "Codex"
+      else provider.to_s
+      end
+    end
+
+    def provider_config_value(provider)
+      case provider.to_s
+      when "OpenRouter" then "openrouter"
+      when "Copilot" then "copilot"
+      else "codex"
+      end
+    end
+
+    def config_key_for_provider(provider)
+      case provider.to_s
+      when "OpenRouter" then "openrouter_model"
+      when "Copilot" then "copilot_model"
+      else "openai_model"
+      end
+    end
+
+    def reasoning_config_key_for_provider(provider)
+      case provider.to_s
+      when "OpenRouter" then "openrouter_reasoning_effort"
+      when "Copilot" then "copilot_reasoning_effort"
+      else "openai_reasoning_effort"
+      end
+    end
+
+    def config_provider_for_provider(provider)
+      provider_config_value(provider)
+    end
+
+    def config_values_for_selection(provider, model)
+      {
+        config_key_for_provider(provider) => model,
+        "provider" => config_provider_for_provider(provider)
+      }
+    end
+
+    def context_window(provider, id)
+      return nil unless provider == "Codex"
+
+      match = OPENAI_CONTEXT_WINDOWS.find { |pattern, _window| id.to_s.match?(pattern) }
+      match&.last
+    end
+
+    def supports_images?(_provider, id)
+      IMAGE_UNSUPPORTED_MODELS.none? { |pattern| id.to_s.match?(pattern) }
+    end
+
+    def reasoning_supported?(provider, id)
+      provider == "Codex" || provider == "OpenRouter" || (provider == "Copilot" && id.to_s.match?(/\Agpt-5(?:\.|-|\z)/))
+    end
+
+    def normalize(model, current_provider: nil, current_model: nil, current_reasoning_effort: nil)
+      model = stringify_keys(model || {})
+      provider = model["provider"]
+      id = model["id"] || model["model"]
+      reasoning = boolean_value(model["reasoning"], default: reasoning_supported?(provider, id))
+      reasoning_effort = model["reasoningEffort"] || model["reasoning_effort"] || (current_reasoning_effort if reasoning)
+      {
+        provider: provider,
+        id: id,
+        name: model["name"] || id,
+        model: model["model"] || id,
+        reasoning: reasoning,
+        reasoningEffort: reasoning_effort,
+        contextWindow: model["contextWindow"] || model["context_window"] || context_window(provider, id),
+        current: boolean_value(model["current"], default: provider == current_provider && id == current_model)
+      }.compact
+    end
+
+    def boolean_value(value, default: false)
+      return default if value.nil?
+      return value if value == true || value == false
+
+      value.to_s == "true"
+    end
+
+    def stringify_keys(value)
+      value.each_with_object({}) { |(key, item), result| result[key.to_s] = item }
+    end
+  end
+end

data/lib/kward/model/retry_message.rb

@@ -0,0 +1,11 @@
+module Kward
+  module RetryMessage
+    module_function
+
+    def format(event)
+      provider = event.provider.to_s.empty? ? "model" : event.provider
+      payload = event.request_bytes ? " with #{event.request_bytes} byte payload" : ""
+      "Retrying #{provider} request after transient failure (attempt #{event.attempt}/#{event.max_attempts}) in #{event.delay_seconds}s#{payload}: #{event.error}"
+    end
+  end
+end

data/lib/kward/model/stream_parser.rb

@@ -0,0 +1,205 @@
+require "json"
+
+module Kward
+  module ModelStreamParser
+    module_function
+
+    def parse_openai_chat_sse(body, on_assistant_delta: nil, usage_normalizer: nil)
+      content = +""
+      tool_calls = []
+      usage = nil
+      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)
+        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
+    rescue JSON::ParserError => e
+      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
+      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
+      codex_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
+    end
+
+    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
+      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_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
+      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?
+      codex_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
+    end
+
+    def merge_streaming_tool_call(tool_calls, delta)
+      index = (delta["index"] || tool_calls.length).to_i
+      tool_calls[index] ||= { "id" => nil, "type" => "function", "function" => { "name" => "", "arguments" => "" } }
+      current = tool_calls[index]
+      current["id"] = delta["id"] if delta["id"]
+      current["type"] = delta["type"] if delta["type"]
+      function = delta["function"] || {}
+      current["function"]["name"] << function["name"].to_s if function["name"]
+      current["function"]["arguments"] << function["arguments"].to_s if function["arguments"]
+    end
+
+    def finalized_streaming_tool_calls(tool_calls)
+      tool_calls.compact.each_with_index.map do |tool_call, index|
+        tool_call["id"] ||= "call_#{index}"
+        tool_call["type"] ||= "function"
+        tool_call["function"] ||= { "name" => "", "arguments" => "{}" }
+        tool_call["function"]["arguments"] = "{}" if tool_call["function"]["arguments"].to_s.empty?
+        tool_call
+      end
+    end
+
+    def codex_sse_state
+      { content: +"", reasoning_summary: +"", tool_calls: [], final_output: [], usage: nil }
+    end
+
+    def process_codex_sse_block(block, state, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: 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)
+      case event["type"]
+      when "response.output_text.delta"
+        delta = event["delta"].to_s
+        state[:content] << delta
+        on_assistant_delta&.call(delta)
+      when "response.reasoning_summary_text.delta"
+        delta = event["delta"].to_s
+        state[:reasoning_summary] << delta
+        on_reasoning_delta&.call(delta)
+      when "response.output_item.done"
+        item = event["item"]
+        state[:final_output] << item if item.is_a?(Hash)
+        tool_call = codex_tool_call(item)
+        state[:tool_calls] << tool_call if tool_call
+      when "response.completed"
+        response = event["response"]
+        state[:usage] ||= usage_normalizer&.call(response["usage"]) if response.is_a?(Hash)
+        state[:usage] ||= usage_normalizer&.call(event["usage"])
+        if state[:content].empty? && response.is_a?(Hash) && response["output"].is_a?(Array)
+          state[:final_output] = response["output"]
+          text = text_from_codex_items(state[:final_output])
+          state[:content] << text
+          on_assistant_delta&.call(text) unless text.empty?
+          if state[:reasoning_summary].empty?
+            state[:reasoning_summary] << reasoning_summary_from_codex_items(state[:final_output])
+          end
+        end
+      when "response.failed", "response.incomplete"
+        raise codex_sse_error(event, request_error_class: request_error_class)
+      end
+    end
+
+    def codex_sse_error(event, request_error_class: nil)
+      response = event["response"]
+      error = event["error"] || (response["error"] if response.is_a?(Hash)) || {}
+      message = if error.is_a?(Hash)
+                  [error["code"], error["message"]].compact.join(": ")
+                else
+                  error.to_s
+                end
+      message = event["type"].to_s if message.empty?
+      code = error.is_a?(Hash) && error["code"].to_s == "server_error" ? 500 : 400
+      if request_error_class
+        request_error_class.new(provider: "Codex", code: code, body: "#{event["type"]}: #{message}")
+      else
+        "#{event["type"]}: #{message}"
+      end
+    end
+
+    def codex_sse_message(state)
+      if state[:tool_calls].empty?
+        state[:final_output].each do |item|
+          tool_call = codex_tool_call(item)
+          state[:tool_calls] << tool_call if tool_call
+        end
+      end
+
+      message = { "role" => "assistant", "content" => state[:content] }
+      message["reasoning_summary"] = state[:reasoning_summary] unless state[:reasoning_summary].empty?
+      message["tool_calls"] = state[:tool_calls] unless state[:tool_calls].empty?
+      message["usage"] = state[:usage] if state[:usage]
+      message
+    end
+
+    def codex_tool_call(item)
+      return nil unless item.is_a?(Hash) && ["function_call", "custom_tool_call"].include?(item["type"])
+
+      name = item["name"].to_s
+      return nil if name.empty?
+
+      arguments = item["arguments"] || item["input"] || "{}"
+      arguments = JSON.dump(arguments) unless arguments.is_a?(String)
+      {
+        "id" => (item["call_id"] || item["id"] || "call_#{name}"),
+        "type" => "function",
+        "function" => { "name" => name, "arguments" => arguments }
+      }
+    end
+
+    def text_from_codex_items(items)
+      items.flat_map do |item|
+        next [] unless item.is_a?(Hash)
+
+        if ["output_text", "text"].include?(item["type"])
+          item["text"].to_s
+        elsif item["type"] == "message" && item["content"].is_a?(Array)
+          item["content"].filter_map { |part| part["text"] if part.is_a?(Hash) && ["output_text", "text"].include?(part["type"]) }
+        else
+          []
+        end
+      end.join
+    end
+
+    def reasoning_summary_from_codex_items(items)
+      items.flat_map do |item|
+        next [] unless item.is_a?(Hash)
+
+        if item["type"] == "reasoning" && item["summary"].is_a?(Array)
+          item["summary"].filter_map { |part| part["text"] if part.is_a?(Hash) }
+        else
+          []
+        end
+      end.join
+    end
+  end
+end