kward 0.67.1 → 0.69.0

data/lib/kward/model/model_info.rb

@@ -1,13 +1,25 @@
 require_relative "../config_files"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Static and configured model metadata helpers.
   module ModelInfo
     DEFAULT_OPENAI_MODEL = "gpt-5.5"
     DEFAULT_OPENROUTER_MODEL = "openai/gpt-5.5"
     DEFAULT_COPILOT_MODEL = "gpt-5-mini"
+    DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6"
     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
+    ANTHROPIC_MODEL_CHOICES = %w[
+      claude-opus-4-8
+      claude-sonnet-4-6
+      claude-haiku-4-5
+      claude-opus-4-7
+      claude-opus-4-6
+      claude-opus-4-5
+      claude-sonnet-4-5
+    ].freeze
     COPILOT_MODEL_CHOICES = %w[
       gpt-5-mini
       gpt-5.3-codex
@@ -32,13 +44,38 @@ module Kward
       ["high", "High"],
       ["xhigh", "Extra High"]
     ].freeze
+    OPENAI_REASONING_EFFORT_CHOICES = [
+      ["none", "None"],
+      *REASONING_EFFORT_CHOICES
+    ].freeze
+    ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES = [
+      ["low", "Low"],
+      ["medium", "Medium"],
+      ["high", "High"],
+      ["xhigh", "Extra High"],
+      ["max", "Max"]
+    ].freeze
+    ANTHROPIC_STANDARD_REASONING_EFFORT_CHOICES = [
+      ["low", "Low"],
+      ["medium", "Medium"],
+      ["high", "High"],
+      ["max", "Max"]
+    ].freeze
+    ANTHROPIC_OPUS_4_5_REASONING_EFFORT_CHOICES = [
+      ["low", "Low"],
+      ["medium", "Medium"],
+      ["high", "High"]
+    ].freeze
 
     IMAGE_UNSUPPORTED_MODELS = [
       /(?:\A|\/)gpt-5\.3-codex-spark\z/
     ].freeze
 
-    OPENAI_CONTEXT_WINDOWS = [
+    CODEX_CONTEXT_WINDOWS = [
       [/\Agpt-5\.5/, 400_000],
+      [/\Agpt-5\.4-mini/, 400_000],
+      [/\Agpt-5\.4/, 1_050_000],
+      [/\Agpt-5-mini/, 400_000],
       [/\Agpt-5-codex/, 400_000],
       [/\Agpt-5\.3-codex-spark/, 128_000],
       [/\Agpt-5\.3-codex/, 400_000],
@@ -51,6 +88,33 @@ module Kward
       [/\Agpt-4/, 128_000],
       [/\Agpt-3\.5-turbo/, 16_385]
     ].freeze
+    OPENAI_CONTEXT_WINDOWS = [
+      [/\Agpt-5\.5/, 1_050_000],
+      [/\Agpt-5\.4-mini/, 400_000],
+      [/\Agpt-5\.4/, 1_050_000],
+      [/\Agpt-5-mini/, 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
+    ANTHROPIC_CONTEXT_WINDOWS = [
+      [/\Aclaude-(?:fable|mythos)-5(?:\z|-)/, 1_000_000],
+      [/\Aclaude-opus-4-(?:6|7|8)(?:\z|-)/, 1_000_000],
+      [/\Aclaude-sonnet-4-6(?:\z|-)/, 1_000_000],
+      [/\Aclaude-(?:haiku|opus|sonnet)-4-5(?:\z|-)/, 200_000],
+      [/\Aclaude-(?:haiku|opus|sonnet)-4(?:\z|-)/, 200_000]
+    ].freeze
+    GEMINI_CONTEXT_WINDOWS = [
+      [/\Agemini-(?:2\.5-pro|3(?:\.1)?-pro|3(?:\.5)?-flash)/, 1_048_576]
+    ].freeze
 
     module_function
 
@@ -62,11 +126,28 @@ module Kward
         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)
+      when "Anthropic"
+        normalize_anthropic_model(env["ANTHROPIC_MODEL"] || ConfigFiles.config_value(config, "anthropic_model", "model") || DEFAULT_ANTHROPIC_MODEL)
       else
         env["OPENAI_MODEL"] || ConfigFiles.config_value(config, "openai_model", "model") || DEFAULT_OPENAI_MODEL
       end
     end
 
+    def normalize_anthropic_model(id)
+      text = id.to_s.strip
+      return DEFAULT_ANTHROPIC_MODEL if text.empty?
+      text = text.delete_prefix("anthropic/").delete_prefix("claude/")
+      {
+        "claude-sonnet-4.6" => "claude-sonnet-4-6",
+        "claude-sonnet-4.5" => "claude-sonnet-4-5",
+        "claude-opus-4.8" => "claude-opus-4-8",
+        "claude-opus-4.7" => "claude-opus-4-7",
+        "claude-opus-4.6" => "claude-opus-4-6",
+        "claude-opus-4.5" => "claude-opus-4-5",
+        "claude-haiku-4.5" => "claude-haiku-4-5"
+      }.fetch(text, text)
+    end
+
     def normalize_copilot_model(id)
       text = id.to_s.strip
       return DEFAULT_COPILOT_MODEL if text.empty?
@@ -92,6 +173,8 @@ module Kward
         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
+      when "Anthropic"
+        env["ANTHROPIC_REASONING_EFFORT"] || ConfigFiles.config_value(config, "anthropic_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
@@ -101,6 +184,7 @@ module Kward
       case provider.to_s.downcase
       when "openrouter" then "OpenRouter"
       when "copilot" then "Copilot"
+      when "anthropic", "claude" then "Anthropic"
       when "codex", "openai" then "Codex"
       else provider.to_s
       end
@@ -110,6 +194,7 @@ module Kward
       case provider.to_s.downcase
       when "openrouter" then "openrouter"
       when "copilot" then "copilot"
+      when "anthropic", "claude" then "anthropic"
       else "codex"
       end
     end
@@ -118,6 +203,7 @@ module Kward
       case provider.to_s.downcase
       when "openrouter" then "openrouter_model"
       when "copilot" then "copilot_model"
+      when "anthropic", "claude" then "anthropic_model"
       else "openai_model"
       end
     end
@@ -126,6 +212,7 @@ module Kward
       case provider.to_s.downcase
       when "openrouter" then "openrouter_reasoning_effort"
       when "copilot" then "copilot_reasoning_effort"
+      when "anthropic", "claude" then "anthropic_reasoning_effort"
       else "openai_reasoning_effort"
       end
     end
@@ -142,18 +229,87 @@ module Kward
     end
 
     def context_window(provider, id)
-      return nil unless provider == "Codex"
+      case provider
+      when "Codex"
+        pattern_context_window(CODEX_CONTEXT_WINDOWS, id)
+      when "OpenRouter"
+        openrouter_context_window(id)
+      when "Copilot"
+        copilot_context_window(id)
+      when "Anthropic"
+        anthropic_context_window(id)
+      end
+    end
 
-      match = OPENAI_CONTEXT_WINDOWS.find { |pattern, _window| id.to_s.match?(pattern) }
+    def pattern_context_window(patterns, id)
+      match = patterns.find { |pattern, _window| id.to_s.match?(pattern) }
       match&.last
     end
 
+    def openrouter_context_window(id)
+      text = id.to_s
+      return pattern_context_window(OPENAI_CONTEXT_WINDOWS, text.delete_prefix("openai/")) if text.start_with?("openai/")
+      return anthropic_context_window(text.delete_prefix("anthropic/")) if text.start_with?("anthropic/")
+      return pattern_context_window(GEMINI_CONTEXT_WINDOWS, text.delete_prefix("google/")) if text.start_with?("google/")
+
+      nil
+    end
+
+    def copilot_context_window(id)
+      text = id.to_s
+      pattern_context_window(OPENAI_CONTEXT_WINDOWS, text) ||
+        anthropic_context_window(normalize_anthropic_model(text)) ||
+        pattern_context_window(GEMINI_CONTEXT_WINDOWS, text)
+    end
+
+    def anthropic_context_window(id)
+      pattern_context_window(ANTHROPIC_CONTEXT_WINDOWS, normalize_anthropic_model(id))
+    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)/))
+      case provider
+      when "Codex", "OpenRouter"
+        true
+      when "Anthropic"
+        !reasoning_effort_choices(provider, id).empty?
+      when "Copilot"
+        id.to_s.match?(/\Agpt-5(?:\.|-|\z)/)
+      else
+        false
+      end
+    end
+
+    def reasoning_effort_choices(provider, id)
+      case provider
+      when "Codex", "OpenRouter"
+        openai_reasoning_effort_choices(id)
+      when "Anthropic"
+        anthropic_reasoning_effort_choices(id)
+      when "Copilot"
+        id.to_s.match?(/\Agpt-5(?:\.|-|\z)/) ? openai_reasoning_effort_choices(id) : []
+      else
+        []
+      end
+    end
+
+    def openai_reasoning_effort_choices(id)
+      text = id.to_s.delete_prefix("openai/")
+      return REASONING_EFFORT_CHOICES if text.match?(/\Agpt-5\.[23]-codex/)
+
+      OPENAI_REASONING_EFFORT_CHOICES
+    end
+
+    def anthropic_reasoning_effort_choices(id)
+      text = normalize_anthropic_model(id)
+      return ANTHROPIC_HIGH_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:fable|mythos)-5(?:\z|-)|\Aclaude-opus-4-(?:7|8)(?:\z|-)/)
+      return ANTHROPIC_STANDARD_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-(?:opus-4-6|sonnet-4-6)(?:\z|-)/)
+      return ANTHROPIC_OPUS_4_5_REASONING_EFFORT_CHOICES if text.match?(/\Aclaude-opus-4-5(?:\z|-)/)
+
+      []
     end
 
     def normalize(model, current_provider: nil, current_model: nil, current_reasoning_effort: nil)

data/lib/kward/model/payloads.rb

@@ -1,14 +1,28 @@
+require "json"
 require_relative "../image_attachments"
+require_relative "../message_access"
 require_relative "model_info"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Converts Kward conversation/tool data into provider-specific request shapes.
+  #
+  # This module is mixed into `Client` because it needs provider configuration
+  # helpers such as `model_for` and `reasoning_effort`. Keep pure transcript and
+  # schema transformations here; keep network transport, credentials, retries,
+  # and telemetry in `Client`.
+  #
+  # Kward stores one internal transcript shape, then projects it into either
+  # Chat Completions-style messages or Responses/Codex input items. Preserve both
+  # symbol and string key handling through `MessageAccess` so restored sessions,
+  # tests, and RPC-normalized messages keep working.
   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[:reasoning] = { effort: reasoning || reasoning_effort("OpenRouter") } if provider == "OpenRouter" && reasoning != false
       payload[:max_tokens] = max_tokens.to_i if max_tokens.to_i.positive?
       payload
     end
@@ -22,18 +36,18 @@ module Kward
 
     def messages_include_images?(messages)
       messages.any? do |message|
-        content = message[:content] || message["content"]
+        content = MessageAccess.content(message)
         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"]
+        role = MessageAccess.role(message)
+        content = MessageAccess.content(message)
         case role.to_s
         when "compactionSummary"
-          { role: "assistant", content: message[:summary] || message["summary"] || content.to_s }
+          { role: "assistant", content: MessageAccess.summary(message) || 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"
@@ -51,7 +65,7 @@ module Kward
     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]
+        value = MessageAccess.value(message, string_key) || MessageAccess.value(message, symbol_key)
         next if value.nil?
 
         target_key = case string_key.to_s
@@ -75,6 +89,27 @@ module Kward
       end
     end
 
+    def anthropic_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
+      parts = build_context_parts("Anthropic", messages, tools, model: model)
+      system = [{ type: "text", text: "You are Claude Code, Anthropic's official CLI for Claude." }]
+      system << { type: "text", text: parts[:system] } unless parts[:system].to_s.empty?
+      payload = {
+        model: parts[:model],
+        system: system,
+        messages: parts[:messages],
+        max_tokens: max_tokens.to_i.positive? ? max_tokens.to_i : 16_384,
+        stream: true
+      }
+      payload[:tools] = parts[:tools] unless parts[:tools].empty?
+      if reasoning != false
+        payload[:thinking] = { type: "adaptive", display: "summarized" }
+        payload[:output_config] = { effort: reasoning || reasoning_effort("Anthropic") }
+      else
+        payload[:thinking] = { type: "disabled" }
+      end
+      payload
+    end
+
     def codex_payload(messages, tools, max_tokens: nil, model: nil, reasoning: nil)
       parts = build_context_parts("Codex", messages, tools, model: model)
       payload = {
@@ -88,12 +123,27 @@ module Kward
         store: false,
         include: []
       }
-      payload[:reasoning] = { effort: reasoning_effort("Codex"), summary: "auto" } unless reasoning == false
+      payload[:reasoning] = { effort: reasoning || reasoning_effort("Codex"), summary: "auto" } unless reasoning == false
       payload
     end
 
+    # Builds provider-neutral context parts before final JSON serialization.
+    #
+    # Codex and Copilot Responses use `instructions` plus typed `input` items;
+    # OpenRouter and Copilot chat use OpenAI-compatible `messages`. Callers should
+    # prefer this method when showing context usage or debugging provider payloads
+    # so every frontend sees the same conversion rules.
     def build_context_parts(provider, messages, tools, model: nil)
-      if provider == "CopilotResponses"
+      if provider == "Anthropic"
+        system, anthropic_messages = anthropic_messages(messages)
+        {
+          provider: provider,
+          model: model_for(provider, override_model: model),
+          system: system,
+          messages: anthropic_messages,
+          tools: tools.map { |tool| anthropic_tool_schema(tool) }
+        }
+      elsif provider == "CopilotResponses"
         instructions, input = codex_messages(messages)
         {
           provider: provider,
@@ -121,36 +171,145 @@ module Kward
       end
     end
 
+    def anthropic_messages(messages)
+      system = []
+      output = []
+      messages.each do |message|
+        role = MessageAccess.role(message)
+        content = MessageAccess.content(message) || ""
+        case role.to_s
+        when "system"
+          system << plain_content(content).to_s
+        when "assistant"
+          blocks = []
+          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"] || "{}"
+            blocks << {
+              type: "tool_use",
+              id: normalize_anthropic_tool_call_id(tool_call[:id] || tool_call["id"] || "call_#{name}"),
+              name: claude_code_tool_name(name),
+              input: parse_tool_arguments(arguments)
+            }
+          end
+          output << { role: "assistant", content: blocks } unless blocks.empty?
+        when "tool", "toolResult"
+          output << {
+            role: "user",
+            content: [{
+              type: "tool_result",
+              tool_use_id: normalize_anthropic_tool_call_id(MessageAccess.tool_call_id(message) || MessageAccess.tool_name(message) || "tool-call"),
+              content: plain_content(content).to_s
+            }]
+          }
+        when "compactionSummary"
+          summary = MessageAccess.summary(message) || content
+          output << { role: "assistant", content: [{ type: "text", text: summary.to_s }] } unless summary.to_s.empty?
+        else
+          output << { role: "user", content: anthropic_user_content(content) }
+        end
+      end
+      [system.join("\n\n"), output]
+    end
+
+    def anthropic_user_content(content)
+      return content.to_s unless content.is_a?(Array)
+
+      content.filter_map do |part|
+        type = part[:type] || part["type"]
+        if type == "text"
+          { type: "text", text: part[:text] || part["text"] || "" }
+        elsif type == "image"
+          mime_type, data = ImageAttachments.data_url(part).split(",", 2)
+          media_type = mime_type.to_s[/data:([^;]+)/, 1] || "image/png"
+          { type: "image", source: { type: "base64", media_type: media_type, data: data.to_s } }
+        end
+      end
+    end
+
+    CLAUDE_CODE_TOOL_NAMES = %w[Read Write Edit Bash Grep Glob AskUserQuestion EnterPlanMode ExitPlanMode KillShell NotebookEdit Skill Task TaskOutput TodoWrite WebFetch WebSearch].freeze
+
+    def claude_code_tool_name(name)
+      mapped = {
+        "read_file" => "Read",
+        "write_file" => "Write",
+        "edit_file" => "Edit",
+        "run_shell_command" => "Bash",
+        "web_search" => "WebSearch",
+        "fetch_content" => "WebFetch",
+        "ask_user_question" => "AskUserQuestion"
+      }[name.to_s]
+      return mapped if mapped
+
+      lookup = CLAUDE_CODE_TOOL_NAMES.find { |tool_name| tool_name.downcase == name.to_s.downcase }
+      lookup || name.to_s
+    end
+
+    def normalize_anthropic_tool_call_id(id)
+      id.to_s.gsub(/[^a-zA-Z0-9_-]/, "_")[0, 64]
+    end
+
+    def parse_tool_arguments(arguments)
+      return arguments if arguments.is_a?(Hash)
+
+      JSON.parse(arguments.to_s.empty? ? "{}" : arguments.to_s)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def anthropic_tool_schema(tool)
+      function = tool[:function] || tool["function"] || {}
+      schema = function[:parameters] || function["parameters"] || {}
+      {
+        name: claude_code_tool_name(function[:name] || function["name"]),
+        description: function[:description] || function["description"] || "",
+        input_schema: {
+          type: "object",
+          properties: schema[:properties] || schema["properties"] || {},
+          required: schema[:required] || schema["required"] || []
+        },
+        eager_input_streaming: true
+      }
+    end
+
     def codex_messages(messages)
       instructions = []
       input = []
 
       messages.each do |message|
-        role = message[:role] || message["role"]
-        content = message[:content] || message["content"] || ""
+        role = MessageAccess.role(message)
+        content = MessageAccess.content(message) || ""
         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",
+            call_id: MessageAccess.tool_call_id(message) || MessageAccess.tool_name(message) || "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"] || "{}"
-            }
+          response_items = codex_replay_response_items(message)
+          if response_items.empty?
+            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"] || {}
+              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
+          else
+            input.concat(response_items)
           end
         when "compactionSummary"
-          summary = message[:summary] || message["summary"] || content
+          summary = MessageAccess.summary(message) || content
           input << codex_message("assistant", summary.to_s) unless summary.to_s.empty?
         else
           input << codex_user_message(content)
@@ -179,6 +338,79 @@ module Kward
       { type: "message", role: role, content: [{ type: type, text: text }] }
     end
 
+    def codex_replay_response_items(message)
+      items = MessageAccess.response_items(message)
+      return [] if items.empty?
+
+      items.filter_map { |item| codex_replay_response_item(item) }
+    end
+
+    def codex_replay_response_item(item)
+      return nil unless item.is_a?(Hash)
+
+      case item[:type] || item["type"]
+      when "reasoning"
+        codex_replay_reasoning_item(item)
+      when "message"
+        codex_replay_message_item(item)
+      when "function_call", "custom_tool_call"
+        codex_replay_tool_call_item(item)
+      end
+    end
+
+    def codex_replay_reasoning_item(item)
+      result = { type: "reasoning" }
+      summary = item[:summary] || item["summary"]
+      content = item[:content] || item["content"]
+      encrypted_content = item[:encrypted_content] || item["encrypted_content"]
+      result[:summary] = summary if summary.is_a?(Array)
+      result[:content] = content if content.is_a?(Array)
+      result[:encrypted_content] = encrypted_content if encrypted_content
+      result
+    end
+
+    def codex_replay_message_item(item)
+      content = item[:content] || item["content"]
+      return nil unless content.is_a?(Array)
+
+      result = { type: "message", role: item[:role] || item["role"] || "assistant", content: codex_replay_message_content(content) }
+      phase = item[:phase] || item["phase"]
+      result[:phase] = phase if phase
+      result
+    end
+
+    def codex_replay_message_content(content)
+      content.filter_map do |part|
+        next unless part.is_a?(Hash)
+
+        type = part[:type] || part["type"]
+        next unless ["output_text", "text", "refusal"].include?(type)
+
+        replay_part = { type: type }
+        text = part[:text] || part["text"]
+        refusal = part[:refusal] || part["refusal"]
+        replay_part[:text] = text.to_s if text || type != "refusal"
+        replay_part[:refusal] = refusal.to_s if refusal
+        annotations = part[:annotations] || part["annotations"]
+        replay_part[:annotations] = annotations if annotations.is_a?(Array)
+        replay_part
+      end
+    end
+
+    def codex_replay_tool_call_item(item)
+      type = item[:type] || item["type"]
+      result = { type: type }
+      call_id = item[:call_id] || item["call_id"]
+      name = item[:name] || item["name"]
+      arguments = item[:arguments] || item["arguments"]
+      input = item[:input] || item["input"]
+      result[:call_id] = call_id if call_id
+      result[:name] = name if name
+      result[:arguments] = arguments if arguments
+      result[:input] = input if input
+      result
+    end
+
     def plain_content(content)
       return content unless content.is_a?(Array)
 

data/lib/kward/model/retry_message.rb

@@ -1,4 +1,6 @@
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Formats retry status messages for model-provider requests.
   module RetryMessage
     module_function