kward 0.67.0 → 0.68.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 = [
-      [/\Agpt-5\.5/, 400_000],
+      [/\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],
@@ -51,6 +88,16 @@ module Kward
       [/\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 +109,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 +156,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 +167,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 +177,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 +186,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 +195,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 +212,87 @@ module Kward
     end
 
     def context_window(provider, id)
-      return nil unless provider == "Codex"
+      case provider
+      when "Codex"
+        pattern_context_window(OPENAI_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,26 +171,129 @@ 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",
+        "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|
+          MessageAccess.tool_calls(message).each do |tool_call|
             function = tool_call[:function] || tool_call["function"] || {}
             input << {
               type: "function_call",
@@ -150,7 +303,7 @@ module Kward
             }
           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)

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
 

data/lib/kward/model/stream_parser.rb

@@ -1,6 +1,15 @@
 require "json"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Parses streaming provider responses into Kward assistant messages.
+  #
+  # `ModelStreamParser` is intentionally provider-shape focused and side-effect
+  # light: it accumulates assistant text, reasoning summaries, tool calls, and
+  # normalized usage from SSE events. Network IO, retries, credentials, and
+  # telemetry stay in `Client`; frontend rendering stays in CLI/RPC event
+  # handlers. Keep parser methods deterministic and easy to unit test with raw
+  # response bodies.
   module ModelStreamParser
     module_function
 
@@ -46,6 +55,11 @@ module Kward
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
     end
 
+    # Incrementally parses a Codex/Responses SSE HTTP response body.
+    #
+    # Deltas are yielded as soon as complete SSE blocks arrive so interactive
+    # frontends can render streamed assistant and reasoning text without waiting
+    # for the provider to close the response.
     def parse_codex_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, request_error_class: nil)
       state = codex_sse_state
       buffer = +""
@@ -67,6 +81,121 @@ module Kward
       raise "Codex OAuth returned invalid SSE JSON: #{e.message}"
     end
 
+    def parse_anthropic_sse_stream(response, on_reasoning_delta: nil, on_assistant_delta: nil, cancellation: nil, usage_normalizer: nil, request_error_class: nil)
+      state = anthropic_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_anthropic_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_anthropic_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?
+      anthropic_sse_message(state)
+    rescue JSON::ParserError => e
+      raise "Anthropic returned invalid SSE JSON: #{e.message}"
+    end
+
+    def anthropic_sse_state
+      { content: +"", reasoning_summary: +"", blocks: {}, tool_calls: [], usage: nil }
+    end
+
+    def process_anthropic_sse_block(block, state, on_reasoning_delta: nil, on_assistant_delta: nil, usage_normalizer: nil, request_error_class: nil)
+      event_name = nil
+      data = block.lines.filter_map do |line|
+        event_name = line.delete_prefix("event:").strip if line.start_with?("event:")
+        line.start_with?("data:") ? line.delete_prefix("data:").strip : nil
+      end.join("\n")
+      return if data.empty? || data == "[DONE]"
+      raise anthropic_sse_error(data, request_error_class: request_error_class) if event_name == "error"
+
+      event = JSON.parse(data)
+      case event["type"]
+      when "message_start"
+        state[:usage] ||= usage_normalizer&.call(event.dig("message", "usage"))
+      when "content_block_start"
+        block_data = event["content_block"] || {}
+        state[:blocks][event["index"].to_i] = block_data.merge("partial_json" => "")
+        if block_data["type"] == "text"
+          text = block_data["text"].to_s
+          state[:content] << text
+          on_assistant_delta&.call(text) unless text.empty?
+        elsif block_data["type"] == "thinking"
+          text = block_data["thinking"].to_s
+          state[:reasoning_summary] << text
+          on_reasoning_delta&.call(text) unless text.empty?
+        end
+      when "content_block_delta"
+        current = state[:blocks][event["index"].to_i] ||= { "partial_json" => "" }
+        delta = event["delta"] || {}
+        case delta["type"]
+        when "text_delta"
+          text = delta["text"].to_s
+          state[:content] << text
+          on_assistant_delta&.call(text)
+        when "thinking_delta"
+          text = delta["thinking"].to_s
+          state[:reasoning_summary] << text
+          on_reasoning_delta&.call(text)
+        when "input_json_delta"
+          current["partial_json"] = current["partial_json"].to_s + delta["partial_json"].to_s
+        end
+      when "content_block_stop"
+        block_data = state[:blocks][event["index"].to_i]
+        tool_call = anthropic_tool_call(block_data)
+        state[:tool_calls] << tool_call if tool_call
+      when "message_delta"
+        state[:usage] = usage_normalizer&.call(event["usage"]) || state[:usage]
+      end
+    end
+
+    def anthropic_sse_error(data, request_error_class: nil)
+      if request_error_class
+        request_error_class.new(provider: "Anthropic", code: 400, body: data)
+      else
+        data
+      end
+    end
+
+    def anthropic_tool_call(block_data)
+      return nil unless block_data.is_a?(Hash) && block_data["type"] == "tool_use"
+
+      name = from_claude_code_tool_name(block_data["name"])
+      arguments = block_data["partial_json"].to_s
+      arguments = JSON.dump(block_data["input"] || {}) if arguments.empty?
+      arguments = "{}" if arguments.empty?
+      {
+        "id" => block_data["id"] || "call_#{name}",
+        "type" => "function",
+        "function" => { "name" => name, "arguments" => arguments }
+      }
+    end
+
+    def anthropic_sse_message(state)
+      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 from_claude_code_tool_name(name)
+      case name.to_s
+      when "Read" then "read_file"
+      when "Write" then "write_file"
+      when "Edit" then "edit_file"
+      when "Bash" then "run_shell_command"
+      when "WebSearch" then "web_search"
+      when "AskUserQuestion" then "ask_user_question"
+      else name.to_s
+      end
+    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" => "" } }

data/lib/kward/pan/server.rb

@@ -15,7 +15,9 @@ require_relative "../tools/tool_call"
 require_relative "../tools/registry"
 require_relative "../workspace"
 
+# Namespace for the Kward CLI agent runtime.
 module Kward
+  # Minimal local HTTP server for the experimental Pan web UI.
   class PanServer
     DEFAULT_HOST = "0.0.0.0"
     DEFAULT_PORT = 8765
@@ -269,7 +271,7 @@ module Kward
     end
 
     def pan_config(config)
-      values = config["pan_mode"] || config["panMode"]
+      values = config["pan_mode"]
       values.is_a?(Hash) ? values : {}
     end