kward 0.66.0 → 0.67.0

data/lib/kward/model/client.rb

@@ -6,13 +6,14 @@ require_relative "../auth/openai_oauth"
 require_relative "../cancellation"
 require_relative "../config_files"
 require_relative "context_overflow"
-require_relative "../image_attachments"
 require_relative "model_info"
+require_relative "payloads"
 require_relative "../telemetry/logger"
 require_relative "stream_parser"
 
 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")
@@ -629,200 +630,6 @@ module Kward
       end
     end
 
-    def request_payload(provider, messages, tools, max_tokens: nil, model: nil, reasoning: nil)
-      parts = build_context_parts(provider, messages, tools, model: model)
-      payload = { model: parts[:model], messages: parts[:messages], tools: parts[:tools] }
-      payload[:reasoning] = { effort: reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
-      payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
-      payload
-    end
-
-    def validate_image_support!(provider, model, messages)
-      return if ModelInfo.supports_images?(provider, model)
-      return unless messages_include_images?(messages)
-
-      raise "Model '#{model}' does not support image inputs. Switch to a vision-capable model or remove the image attachment."
-    end
-
-    def messages_include_images?(messages)
-      messages.any? do |message|
-        content = message[:content] || message["content"]
-        content.is_a?(Array) && content.any? { |part| (part[:type] || part["type"]).to_s == "image" }
-      end
-    end
-
-    def chat_messages(messages)
-      messages.map do |message|
-        role = message[:role] || message["role"]
-        content = message[:content] || message["content"]
-        case role.to_s
-        when "compactionSummary"
-          { role: "assistant", content: message[:summary] || message["summary"] || content.to_s }
-        when "assistant"
-          api_message(message, role: "assistant", content: content.is_a?(Array) ? plain_content(content) : content, keys: ["tool_calls", :tool_calls, "name", :name])
-        when "toolResult"
-          api_message(message, role: "tool", content: plain_content(content).to_s, keys: ["tool_call_id", :tool_call_id, "toolCallId", :toolCallId, "name", :name, "toolName", :toolName])
-        when "tool"
-          api_message(message, role: "tool", content: plain_content(content).to_s, keys: ["tool_call_id", :tool_call_id, "name", :name])
-        when "user"
-          api_message(message, role: "user", content: content.is_a?(Array) ? chat_user_content(content) : content, keys: ["name", :name])
-        else
-          api_message(message, role: role, content: content, keys: ["name", :name])
-        end
-      end
-    end
-
-    def api_message(message, role:, content:, keys: [])
-      result = { role: role, content: content }
-      keys.each_slice(2) do |string_key, symbol_key|
-        value = message[string_key] || message[symbol_key]
-        next if value.nil?
-
-        target_key = case string_key.to_s
-                     when "toolCallId" then :tool_call_id
-                     when "toolName" then :name
-                     else string_key.to_sym
-                     end
-        result[target_key] = value
-      end
-      result
-    end
-
-    def chat_user_content(content)
-      content.filter_map do |part|
-        type = part[:type] || part["type"]
-        if type == "text"
-          { type: "text", text: part[:text] || part["text"] || "" }
-        elsif type == "image"
-          { type: "image_url", image_url: { url: ImageAttachments.data_url(part) } }
-        end
-      end
-    end
-
-    def codex_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
-      parts = build_context_parts("Codex", messages, tools, model: model)
-      payload = {
-        model: parts[:model],
-        instructions: parts[:instructions],
-        input: parts[:input],
-        tools: parts[:tools],
-        tool_choice: "auto",
-        parallel_tool_calls: false,
-        stream: true,
-        store: false,
-        include: []
-      }
-      payload[:reasoning] = { effort: reasoning_effort("Codex"), summary: "auto" } unless reasoning == false
-      payload
-    end
-
-    def build_context_parts(provider, messages, tools, model: nil)
-      if provider == "CopilotResponses"
-        instructions, input = codex_messages(messages)
-        {
-          provider: provider,
-          model: model_for("Copilot", override_model: model),
-          instructions: instructions.empty? ? "You are a helpful assistant." : instructions,
-          input: input,
-          tools: tools.map { |tool| codex_tool_schema(tool) }
-        }
-      elsif provider == "Codex"
-        instructions, input = codex_messages(messages)
-        {
-          provider: provider,
-          model: model_for(provider, override_model: model),
-          instructions: instructions.empty? ? "You are a helpful assistant." : instructions,
-          input: input,
-          tools: tools.map { |tool| codex_tool_schema(tool) }
-        }
-      else
-        {
-          provider: provider,
-          model: model_for(provider, override_model: model),
-          messages: chat_messages(messages),
-          tools: tools
-        }
-      end
-    end
-
-    def codex_messages(messages)
-      instructions = []
-      input = []
-
-      messages.each do |message|
-        role = message[:role] || message["role"]
-        content = message[:content] || message["content"] || ""
-        case role.to_s
-        when "system"
-          instructions << plain_content(content).to_s
-        when "tool", "toolResult"
-          input << {
-            type: "function_call_output",
-            call_id: message[:tool_call_id] || message["tool_call_id"] || message[:toolCallId] || message["toolCallId"] || message[:name] || message["name"] || message[:toolName] || message["toolName"] || "tool-call",
-            output: plain_content(content).to_s
-          }
-        when "assistant"
-          content = plain_content(content)
-          input << codex_message("assistant", content.to_s) unless content.to_s.empty?
-          (message[:tool_calls] || message["tool_calls"] || []).each do |tool_call|
-            function = tool_call[:function] || tool_call["function"] || {}
-            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"] || "{}"
-            }
-          end
-        when "compactionSummary"
-          summary = message[:summary] || message["summary"] || content
-          input << codex_message("assistant", summary.to_s) unless summary.to_s.empty?
-        else
-          input << codex_user_message(content)
-        end
-      end
-
-      [instructions.join("\n\n"), input]
-    end
-
-    def codex_user_message(content)
-      return codex_message("user", content.to_s) unless content.is_a?(Array)
-
-      parts = content.filter_map do |part|
-        type = part[:type] || part["type"]
-        if type == "text"
-          { type: "input_text", text: part[:text] || part["text"] || "" }
-        elsif type == "image"
-          { type: "input_image", image_url: ImageAttachments.data_url(part) }
-        end
-      end
-      { type: "message", role: "user", content: parts }
-    end
-
-    def codex_message(role, text)
-      type = role == "assistant" ? "output_text" : "input_text"
-      { type: "message", role: role, content: [{ type: type, text: text }] }
-    end
-
-    def plain_content(content)
-      return content unless content.is_a?(Array)
-
-      content.filter_map do |part|
-        type = part[:type] || part["type"]
-        part[:text] || part["text"] if type == "text"
-      end.join
-    end
-
-    def codex_tool_schema(tool)
-      function = tool[:function] || tool["function"] || {}
-      {
-        type: "function",
-        name: function[:name] || function["name"],
-        description: function[:description] || function["description"] || "",
-        parameters: function[:parameters] || function["parameters"] || {},
-        strict: false
-      }
-    end
-
     def model_for(provider, override_model: nil)
       ModelInfo.model_for(provider, config: @config, override_model: override_model || @model)
     end

data/lib/kward/model/model_info.rb

@@ -107,25 +107,25 @@ module Kward
     end
 
     def provider_config_value(provider)
-      case provider.to_s
-      when "OpenRouter" then "openrouter"
-      when "Copilot" then "copilot"
+      case provider.to_s.downcase
+      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"
+      case provider.to_s.downcase
+      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"
+      case provider.to_s.downcase
+      when "openrouter" then "openrouter_reasoning_effort"
+      when "copilot" then "copilot_reasoning_effort"
       else "openai_reasoning_effort"
       end
     end
@@ -166,7 +166,6 @@ module Kward
         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),

data/lib/kward/model/payloads.rb

@@ -0,0 +1,203 @@
+require_relative "../image_attachments"
+require_relative "model_info"
+
+module Kward
+  module ModelPayloads
+    private
+
+    def request_payload(provider, messages, tools, max_tokens: nil, model: nil, reasoning: nil)
+      parts = build_context_parts(provider, messages, tools, model: model)
+      payload = { model: parts[:model], messages: parts[:messages], tools: parts[:tools] }
+      payload[:reasoning] = { effort: reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
+      payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
+      payload
+    end
+
+    def validate_image_support!(provider, model, messages)
+      return if ModelInfo.supports_images?(provider, model)
+      return unless messages_include_images?(messages)
+
+      raise "Model '#{model}' does not support image inputs. Switch to a vision-capable model or remove the image attachment."
+    end
+
+    def messages_include_images?(messages)
+      messages.any? do |message|
+        content = message[:content] || message["content"]
+        content.is_a?(Array) && content.any? { |part| (part[:type] || part["type"]).to_s == "image" }
+      end
+    end
+
+    def chat_messages(messages)
+      messages.map do |message|
+        role = message[:role] || message["role"]
+        content = message[:content] || message["content"]
+        case role.to_s
+        when "compactionSummary"
+          { role: "assistant", content: message[:summary] || message["summary"] || content.to_s }
+        when "assistant"
+          api_message(message, role: "assistant", content: content.is_a?(Array) ? plain_content(content) : content, keys: ["tool_calls", :tool_calls, "name", :name])
+        when "toolResult"
+          api_message(message, role: "tool", content: plain_content(content).to_s, keys: ["tool_call_id", :tool_call_id, "toolCallId", :toolCallId, "name", :name, "toolName", :toolName])
+        when "tool"
+          api_message(message, role: "tool", content: plain_content(content).to_s, keys: ["tool_call_id", :tool_call_id, "name", :name])
+        when "user"
+          api_message(message, role: "user", content: content.is_a?(Array) ? chat_user_content(content) : content, keys: ["name", :name])
+        else
+          api_message(message, role: role, content: content, keys: ["name", :name])
+        end
+      end
+    end
+
+    def api_message(message, role:, content:, keys: [])
+      result = { role: role, content: content }
+      keys.each_slice(2) do |string_key, symbol_key|
+        value = message[string_key] || message[symbol_key]
+        next if value.nil?
+
+        target_key = case string_key.to_s
+                     when "toolCallId" then :tool_call_id
+                     when "toolName" then :name
+                     else string_key.to_sym
+                     end
+        result[target_key] = value
+      end
+      result
+    end
+
+    def chat_user_content(content)
+      content.filter_map do |part|
+        type = part[:type] || part["type"]
+        if type == "text"
+          { type: "text", text: part[:text] || part["text"] || "" }
+        elsif type == "image"
+          { type: "image_url", image_url: { url: ImageAttachments.data_url(part) } }
+        end
+      end
+    end
+
+    def codex_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
+      parts = build_context_parts("Codex", messages, tools, model: model)
+      payload = {
+        model: parts[:model],
+        instructions: parts[:instructions],
+        input: parts[:input],
+        tools: parts[:tools],
+        tool_choice: "auto",
+        parallel_tool_calls: false,
+        stream: true,
+        store: false,
+        include: []
+      }
+      payload[:reasoning] = { effort: reasoning_effort("Codex"), summary: "auto" } unless reasoning == false
+      payload
+    end
+
+    def build_context_parts(provider, messages, tools, model: nil)
+      if provider == "CopilotResponses"
+        instructions, input = codex_messages(messages)
+        {
+          provider: provider,
+          model: model_for("Copilot", override_model: model),
+          instructions: instructions.empty? ? "You are a helpful assistant." : instructions,
+          input: input,
+          tools: tools.map { |tool| codex_tool_schema(tool) }
+        }
+      elsif provider == "Codex"
+        instructions, input = codex_messages(messages)
+        {
+          provider: provider,
+          model: model_for(provider, override_model: model),
+          instructions: instructions.empty? ? "You are a helpful assistant." : instructions,
+          input: input,
+          tools: tools.map { |tool| codex_tool_schema(tool) }
+        }
+      else
+        {
+          provider: provider,
+          model: model_for(provider, override_model: model),
+          messages: chat_messages(messages),
+          tools: tools
+        }
+      end
+    end
+
+    def codex_messages(messages)
+      instructions = []
+      input = []
+
+      messages.each do |message|
+        role = message[:role] || message["role"]
+        content = message[:content] || message["content"] || ""
+        case role.to_s
+        when "system"
+          instructions << plain_content(content).to_s
+        when "tool", "toolResult"
+          input << {
+            type: "function_call_output",
+            call_id: message[:tool_call_id] || message["tool_call_id"] || message[:toolCallId] || message["toolCallId"] || message[:name] || message["name"] || message[:toolName] || message["toolName"] || "tool-call",
+            output: plain_content(content).to_s
+          }
+        when "assistant"
+          content = plain_content(content)
+          input << codex_message("assistant", content.to_s) unless content.to_s.empty?
+          (message[:tool_calls] || message["tool_calls"] || []).each do |tool_call|
+            function = tool_call[:function] || tool_call["function"] || {}
+            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"] || "{}"
+            }
+          end
+        when "compactionSummary"
+          summary = message[:summary] || message["summary"] || content
+          input << codex_message("assistant", summary.to_s) unless summary.to_s.empty?
+        else
+          input << codex_user_message(content)
+        end
+      end
+
+      [instructions.join("\n\n"), input]
+    end
+
+    def codex_user_message(content)
+      return codex_message("user", content.to_s) unless content.is_a?(Array)
+
+      parts = content.filter_map do |part|
+        type = part[:type] || part["type"]
+        if type == "text"
+          { type: "input_text", text: part[:text] || part["text"] || "" }
+        elsif type == "image"
+          { type: "input_image", image_url: ImageAttachments.data_url(part) }
+        end
+      end
+      { type: "message", role: "user", content: parts }
+    end
+
+    def codex_message(role, text)
+      type = role == "assistant" ? "output_text" : "input_text"
+      { type: "message", role: role, content: [{ type: type, text: text }] }
+    end
+
+    def plain_content(content)
+      return content unless content.is_a?(Array)
+
+      content.filter_map do |part|
+        type = part[:type] || part["type"]
+        part[:text] || part["text"] if type == "text"
+      end.join
+    end
+
+    def codex_tool_schema(tool)
+      function = tool[:function] || tool["function"] || {}
+      {
+        type: "function",
+        name: function[:name] || function["name"],
+        description: function[:description] || function["description"] || "",
+        parameters: function[:parameters] || function["parameters"] || {},
+        strict: false
+      }
+    end
+
+  end
+end

data/lib/kward/prompt_interface/banner.rb

@@ -0,0 +1,77 @@
+require_relative "../ansi"
+require_relative "../resources/avatar_kward_logo"
+require_relative "../resources/pixel_logo"
+
+module Kward
+  class PromptInterface
+    class Banner
+      LOGO_WIDTH = 32
+      LOGO_PIXEL_HEIGHT = 32
+      MIN_LOGO_HEIGHT = 4
+      LOGO_PIXELS = Kward::Resources::AvatarKwardLogo::PIXELS
+      MESSAGE = "State your business.".freeze
+
+      def initialize(message:, pixels:, screen_height:, minimum_composer_rows: 3)
+        @message = message.to_s
+        @pixels = pixels
+        @screen_height = screen_height
+        @minimum_composer_rows = minimum_composer_rows
+        @logo_cache = {}
+      end
+
+      def rows(width)
+        return [] unless visible?(width)
+
+        rows = []
+        rows.concat(centered_image_rows(width)) if image_visible?(width)
+        rows << align_plain_row(@message, width) unless @message.empty?
+        rows << ""
+        rows
+      end
+
+      def logo_rows(width)
+        logo_width, logo_height = logo_dimensions(width)
+        return [] unless @pixels && max_logo_height >= MIN_LOGO_HEIGHT
+
+        key = [logo_width, logo_height]
+        @logo_cache[key] ||= Kward::PixelLogo.half_block_rows_from_pixels(@pixels, width: logo_width, pixel_height: logo_height)
+      end
+
+      private
+
+      def visible?(width)
+        !@message.empty? || image_visible?(width)
+      end
+
+      def image_visible?(width)
+        !logo_rows(width).empty?
+      end
+
+      def centered_image_rows(width)
+        logo_width, = logo_dimensions(width)
+        padding = [[(width - logo_width) / 2, 0].max, width - 1].min
+        logo_rows(width).map { |row| (" " * padding) + row }
+      end
+
+      def logo_dimensions(width)
+        logo_width = [LOGO_WIDTH, [width - 2, 1].max].min
+        logo_height = [LOGO_PIXEL_HEIGHT, max_logo_height * 2].min
+        [logo_width, logo_height]
+      end
+
+      def max_logo_height
+        message_rows = @message.empty? ? 0 : 1
+        blank_after_banner = 1
+        transcript_row = 1
+        reserved_rows = message_rows + blank_after_banner + @minimum_composer_rows + transcript_row
+        [@screen_height.call - reserved_rows, 0].max
+      end
+
+      def align_plain_row(text, width)
+        plain_length = ANSI.strip(text).length
+        padding = [width - plain_length, 0].max / 2
+        (" " * padding) + text.to_s
+      end
+    end
+  end
+end