samagotchi 0.63.0 → 0.65.0

data/lib/samagotchi/idle_client.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
 require "json"
-require_relative "llm/openai_chat"
-require_relative "thinking"
+require_relative "llm/adapters"
 require_relative "log"
 
 module Samagotchi
   # Standalone summarizer for the idle session-recap feature.
   #
   # Asks an OpenAI-compatible /chat/completions endpoint (the local llama.cpp,
-  # or a recap host's) through its own OpenAIChat: one plain request, no
+  # or a recap host's) through its own adapter (LLM::Adapters.build, by the
+  # target's api; OpenAIChat today): one plain request, no
   # tools, no retries, its own timeout. It is NEVER wired into the Engine's
   # kernel/backend, so it shares no engine concurrency. The Engine's idle
   # detector only snapshots session.messages and calls #summarize; this object
@@ -38,6 +38,11 @@ module Samagotchi
     DEFAULT_TIMEOUT_SECONDS = 30.0
     # Up to 10 sentences (recap.sentences) need ~350 tokens with thinking off.
     MAX_TOKENS = 512
+    # The least max_tokens a side request gets when its model refused
+    # thinking off and the adapter asks for a little thinking instead (an
+    # always-thinking model on a Messages host): the thinking counts in the
+    # limit, so 512 could all go to it and leave no answer.
+    THINKING_MAX_TOKENS = 4096
 
     # @param base_url [String] the OpenAI API base, e.g. http://host:8081/v1
     # @param api_key_env [String, nil] the variable holding the host's key
@@ -46,19 +51,26 @@ module Samagotchi
     #   summarize thread can't outlive the recap attempt by minutes.
     # @param purpose [String] what the requests are for, in the HTTP log
     #   lines and error messages ("recap", "broadcast")
-    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap")
+    # @param api [Symbol] the wire to talk (LLM::Adapters; IdleTarget#api)
+    # @param auth [Symbol, nil] the header the key goes in (IdleTarget#auth)
+    # @param dialect [String, nil] a Messages host's dialect (IdleTarget#dialect)
+    def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap",
+                   api: :openai, auth: nil, dialect: nil)
       @model = model
       # A recap is best-effort: one short attempt, no retries. The idle job
-      # tries again after the next activity, never on its own.
-      @chat = LLM::OpenAIChat.new(base_url: base_url.to_s, host_name: purpose, api_key_env: api_key_env,
-                                  stream: false, retries: false, timeout: timeout, env: env, purpose: purpose)
+      # tries again after the next activity, never on its own. Only the
+      # Messages adapter takes a dialect.
+      @chat = LLM::Adapters.build(api: api, base_url: base_url.to_s, host_name: purpose, api_key_env: api_key_env,
+                                  auth: auth, stream: false, retries: false, timeout: timeout, env: env, purpose: purpose,
+                                  **(dialect ? { dialect: dialect } : {}))
     end
 
     # A client for +target+ (an IdleTarget: a recap's, ctx.ask_model's, a
-    # broadcast's triage model).
+    # broadcast's triage model), on its api's adapter.
     # @return [IdleClient]
     def self.for(target, **)
-      new(model: target.model, base_url: target.base_url, api_key_env: target.api_key_env, **)
+      new(model: target.model, base_url: target.base_url, api_key_env: target.api_key_env, api: target.api,
+          auth: target.auth, dialect: target.dialect, **)
     end
 
     THINK_RE = /<\|think\|.*?\|think\|>/m
@@ -86,11 +98,13 @@ module Samagotchi
     # when there is nothing to summarize. Any failure raises SummarizeError
     # (the caller isolates it).
     # @return [Summary, nil]
-    def summarize(prompt)
+    # +session_id+: the session it is about, sent as the turns send it
+    # (Session-Id, a dialect's affinity header), nil for none.
+    def summarize(prompt, session_id: nil)
       messages = prompt.is_a?(Array) ? prompt : [{ role: "user", content: prompt.to_s.strip }]
       return nil if messages.all? { |m| m[:content].to_s.strip.empty? }
 
-      response = generate(messages)
+      response = generate(messages, session_id: session_id)
       cleaned = response.text.to_s.strip
       cleaned.empty? ? nil : Summary.new(text: cleaned, model: response.model)
     rescue SummarizeError
@@ -106,14 +120,15 @@ module Samagotchi
     # @param kind [String] what it is for, in the usage log line
     # @param options [Hash] more request body fields (logprobs: true,
     #   top_logprobs: 5)
+    # @param session_id [String, nil] the session it is about (#summarize)
     # @return [Summary] the answer ("" when the model said nothing)
     # @raise [SummarizeError] any failure but a cancel; its #cause is an
     #   LLM::BadRequest when the host refused the request (+options+ it
     #   doesn't take, say)
     # @raise [LLM::RequestCancelled] +cancel_controller+ was cancelled
-    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {})
+    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {}, session_id: nil)
       response = generate(messages, max_tokens: max_tokens, cancel_controller: cancel_controller, whole_sentences: false,
-                                    kind: kind, options: options)
+                                    kind: kind, options: options, session_id: session_id)
       Summary.new(text: response.text.to_s.strip, model: response.model, top_logprobs: response.top_logprobs)
     rescue SummarizeError, LLM::RequestCancelled
       raise
@@ -130,17 +145,15 @@ module Samagotchi
     # the reply has neither content nor reasoning_content. Cut off by
     # +max_tokens+, the text keeps its finished sentences (+whole_sentences+)
     # or all of it, with "…".
-    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap", options: {})
+    def generate(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, whole_sentences: true, kind: "recap", options: {},
+                 session_id: nil)
       response = begin
-        request(messages, max_tokens, cancel_controller, options)
+        request(messages, max_tokens, cancel_controller, options, session_id)
       rescue LLM::BadRequest => e
-        raise unless e.reasoning_refused? && !@thinking_refused
+        raise unless e.reasoning_refused? && next_thinking_step
 
-        # The host won't turn thinking off (gpt-oss): ask again without the
-        # fields, and leave them out from now on.
-        @thinking_refused = true
-        Log.info(:recap, "thinking_refused", model: @model, detail: e.detail)
-        request(messages, max_tokens, cancel_controller, options)
+        Log.info(:recap, "thinking_refused", model: @model, step: @thinking_step, detail: e.detail)
+        retry
       end
       log_usage(response, kind)
       content = response.text
@@ -173,16 +186,40 @@ module Samagotchi
                                         cached: fields[:cached_tokens], cache_write: fields[:cache_write_tokens])
     end
 
-    def request(messages, max_tokens, cancel_controller, options = {})
+    # After a host refused this step's thinking fields: the next step, kept
+    # from now on (true), or false when none is left.
+    # 1. The host won't turn thinking off (gpt-oss, an always-thinking
+    #    model): the adapter's fields for that (none on the OpenAI API, low
+    #    effort on Messages).
+    # 2. Those refused too (a Messages model that takes no thinking fields
+    #    at all): none.
+    def next_thinking_step
+      step = @thinking_step.to_i
+      return false if step >= 2 || (step == 1 && @chat.thinking_off_refused_fields.empty?)
+
+      @thinking_step = step + 1
+      true
+    end
+
+    def request(messages, max_tokens, cancel_controller, options, session_id)
+      fields = thinking_fields
+      max_tokens = [max_tokens, THINKING_MAX_TOKENS].max if @thinking_step == 1 && !fields.empty?
       @chat.chat(messages: messages, model: @model, tools: [], cancel_controller: cancel_controller,
-                 options: { max_tokens: max_tokens, **thinking_fields, **options })
+                 options: { max_tokens: max_tokens, **fields, **options }, session_id: session_id)
     end
 
     # A recap or side answer is short and tool-less: thinking off, whatever
     # the model's level (a reasoning model otherwise spends the budget
-    # thinking and the recap stops mid-sentence). None once the host refused them.
+    # thinking and the recap stops mid-sentence). Once the host refused
+    # that, the adapter's fields for a model that always thinks (with a
+    # limit of at least THINKING_MAX_TOKENS when there are any), then none
+    # (#next_thinking_step).
     def thinking_fields
-      @thinking_refused ? {} : Thinking.chat_fields(:off)
+      case @thinking_step.to_i
+      when 0 then @chat.thinking_fields(:off)
+      when 1 then @chat.thinking_off_refused_fields
+      else {}
+      end
     end
   end
 end

data/lib/samagotchi/idle_recap.rb

@@ -287,10 +287,13 @@ module Samagotchi
                    sentences: RecapPrompt::DEFAULT_SENTENCES,
                    client: nil,
                    store: nil,
+                   session_id: -> {},
                    clock: -> { Process.clock_gettime(Process::CLOCK_MONOTONIC) })
       raise ArgumentError, "IdleRecap requires an engine" unless engine
 
       @engine = engine
+      # The recapped session's id, sent with the request (IdleClient#summarize).
+      @session_id = session_id
       @target = target || lambda {
         IdleTarget.new(base_url: base_url, api_key_env: api_key_env, model: model, label: model)
       }
@@ -534,7 +537,7 @@ module Samagotchi
     def client_for(asked)
       return @client_override if @client_override
 
-      key = [asked.base_url, asked.api_key_env, asked.model]
+      key = asked
       unless @client && @client_key == key
         @client = IdleClient.for(asked, timeout: @timeout)
         @client_key = key
@@ -544,7 +547,7 @@ module Samagotchi
 
     def spawn_summarize(client, prompt)
       Thread.new do
-        client.summarize(prompt)
+        client.summarize(prompt, session_id: @session_id.call)
       rescue StandardError => e
         # No recap this time (the next idle window tries again); say why.
         Log.exception(:recap, "summarize_failed", e)

data/lib/samagotchi/idle_target.rb

@@ -2,13 +2,28 @@
 
 module Samagotchi
   # Where a side request goes (a recap, a plugin's ctx.ask_model, a
-  # broadcast's triage): a model on a host's OpenAI API, asked through its
+  # broadcast's triage): a model on a host's chat API, asked through its
   # own IdleClient (IdleClient.for), apart from the session's turns.
-  # @!attribute base_url [String] the host's OpenAI API base
+  # @!attribute base_url [String] the host's API base (HostEntry#api_base_url)
   # @!attribute api_key_env [String, nil] the variable holding its key
   # @!attribute model [String] the model id sent to the server
   # @!attribute label [String] the model as configured, for logs
-  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label) do
+  # @!attribute api [Symbol] the wire the side client talks (LLM::Adapters):
+  #   a chat host's api, else :openai (a raw host's server, or a bare url)
+  # @!attribute auth [Symbol, nil] the header its key goes in (the host's
+  #   auth:, LLM::ApiKey::SCHEMES); nil: the api's own default
+  # @!attribute dialect [String, nil] an api: anthropic host's dialect:
+  #   (LLM::Dialect), so a side request gets its auth and fields
+  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label, :api, :auth, :dialect) do
+    def initialize(api: :openai, auth: nil, dialect: nil, **) = super
+
+    # The api a side request to +entry+ talks: a chat host's own, else the
+    # OpenAI API (a raw host's llama.cpp serves /v1 too).
+    def self.api_of(entry) = entry.chat? ? entry.api : :openai
+
+    # The dialect a side request to +entry+ talks (only a chat host has one).
+    def self.dialect_of(entry) = entry.chat? ? entry.dialect : nil
+
     # A configured side model can't be resolved.
     # @!attribute reason [Symbol] :host_ref_unknown (no such host),
     #   :model_host_mismatch (the model names another host than host_ref)
@@ -32,8 +47,9 @@ module Samagotchi
     # @return [IdleTarget]
     def self.of_model(host_registry, name)
       resolved = host_registry.resolve(name)
-      new(base_url: resolved.openai_base_url, api_key_env: resolved.entry.api_key_env, model: resolved.bare_model,
-          label: name.to_s.strip)
+      entry = resolved.entry
+      new(base_url: entry.api_base_url, api_key_env: entry.api_key_env, model: resolved.bare_model,
+          label: name.to_s.strip, api: api_of(entry), auth: entry.auth, dialect: dialect_of(entry))
     end
 
     # A side model's settings (recap.*, broadcast.triage_*) as a target:
@@ -55,12 +71,18 @@ module Samagotchi
 
       host_ref ||= parsed.host_name if parsed && base_url.nil?
       api_key_env = nil
+      api = :openai
+      auth = nil
+      dialect = nil
       if host_ref
         entry = host_registry.find_entry(host_ref)
         raise self::Unresolved.new(:host_ref_unknown, model: model, host_ref: host_ref) unless entry
 
-        base_url = entry.openai_base_url
+        base_url = entry.api_base_url
         api_key_env = entry.api_key_env
+        api = api_of(entry)
+        auth = entry.auth
+        dialect = dialect_of(entry)
         named = parsed&.host_conflict || parsed&.host_name
         if named && named != entry.name
           raise self::Unresolved.new(:model_host_mismatch, model: model, host_ref: host_ref, named: named)
@@ -72,7 +94,8 @@ module Samagotchi
       end
       raise self::Unresolved.new(:incomplete, model: model, host_ref: host_ref) if blank(base_url).nil? || blank(model).nil?
 
-      new(base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.strip)
+      new(base_url: base_url.to_s.strip, api_key_env: api_key_env, model: model.to_s.strip, label: label.strip, api: api, auth: auth,
+          dialect: dialect)
     end
 
     # Whether the settings fix a host (+base_url+, +host_ref+, or a model

data/lib/samagotchi/interrupted_turn.rb

@@ -9,9 +9,13 @@ module Samagotchi
   #
   # id: the turn's id (nil when unknown); started_at / at: iso8601, when the
   # turn began and when this checkpoint was taken; iteration: the loop
-  # boundaries it had passed (Integer).
-  InterruptedTurn = Data.define(:id, :started_at, :at, :iteration) do
-    def initialize(id: nil, started_at: nil, at: nil, iteration: nil) = super
+  # boundaries it had passed (Integer); enqueued_id: the input the turn
+  # runs (its ack's id, LastTurn#enqueued_id once it ends; a Continue turn
+  # carries its offer turn's), so any process that loads the session can
+  # tell which turn is running (ReplyWait.own_turn); nil when it ran none,
+  # or a worker from before it wrote one.
+  InterruptedTurn = Data.define(:id, :started_at, :at, :iteration, :enqueued_id) do
+    def initialize(id: nil, started_at: nil, at: nil, iteration: nil, enqueued_id: nil) = super
 
     # A saved record (string or symbol keys), an InterruptedTurn as it is;
     # nil for anything else.

data/lib/samagotchi/last_turn.rb

@@ -12,9 +12,12 @@ module Samagotchi
   # children's reports) or "context" (one an attached context source's
   # change started); exhausted/limit: the turn ran out of iterations at
   # limit. The rest are its stop facts (LastTurn::STOP_FACTS), only what is
-  # known. A field may be nil (unset; left out of the file).
+  # known. enqueued_id: the input's id when the turn ran one (a POST /turn
+  # ack's, an input file's), so a wait for a queued message (`chi send
+  # --queue --wait`, ReplyWait's turn:) tells its own turn's end from
+  # another's. A field may be nil (unset; left out of the file).
   LastTurn = Data.define(:outcome, :ended_at, :seconds, :origin, :exhausted, :limit,
-                         :error_kind, :retryable, :kept_steps, :cancel_reason, :stopped_by) do
+                         :error_kind, :retryable, :kept_steps, :cancel_reason, :stopped_by, :enqueued_id) do
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, **fields)
     end

data/lib/samagotchi/llm/adapters.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "openai_chat"
+require_relative "anthropic_messages"
+
+module Samagotchi
+  module LLM
+    # Which chat adapter talks a host's api: the one place that names the
+    # adapter classes. A host whose api is a key of BY_API runs the chat loop
+    # (HostRegistry::HostEntry#chat?); any other api (nil, raw) the
+    # raw-prompt loop.
+    module Adapters
+      BY_API = { openai: OpenAIChat, anthropic: AnthropicMessages }.freeze
+
+      # true when +api+ (a Symbol or String) has a chat adapter.
+      def self.chat_api?(api) = !api.nil? && BY_API.key?(api.to_sym)
+
+      # A host entry's adapter (its api, API base, name, key and remoteness).
+      # @param entry [HostRegistry::HostEntry]
+      # @param options [Hash] more adapter options (models_ttl:, first_token_timeout:, ...)
+      # @raise [ArgumentError] the entry's api has no chat adapter
+      def self.for(entry, **)
+        adapter_class(entry.api).for(entry, **)
+      end
+
+      # An adapter by api, for a side request that has a url rather than a
+      # host entry (IdleClient: a recap, ctx.ask_model, a broadcast's triage).
+      # @param api [Symbol, String] a key of BY_API
+      # @param options [Hash] more adapter options (stream:, retries:, timeout:, ...)
+      # @raise [ArgumentError] +api+ has no chat adapter
+      def self.build(api:, base_url:, host_name:, api_key_env: nil, **)
+        adapter_class(api).new(base_url: base_url, host_name: host_name, api_key_env: api_key_env, **)
+      end
+
+      def self.adapter_class(api)
+        BY_API.fetch(api&.to_sym) { raise ArgumentError, "no chat adapter for api #{api.inspect}" }
+      end
+      private_class_method :adapter_class
+    end
+  end
+end

data/lib/samagotchi/llm/anthropic_assembly.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require_relative "openai_chat"
+require_relative "usage"
+
+module Samagotchi
+  module LLM
+    # A Messages response put together as ChatResponse, from a whole body
+    # (.from_message) or a stream's events (#add, by content-block index):
+    # the content blocks
+    # in order (kept as received, string keys: ChatResponse#provider_content,
+    # which ChatLoop saves and sends back), the text and reasoning they
+    # carry, the tool calls, the usage and the stop reason in the chat
+    # loop's terms.
+    #
+    # Usage: Messages counts input_tokens without the cache, so the prompt
+    # is input + cache reads + cache writes, in the OpenAI shape the rest of
+    # chi reads (TokenUsage: prompt_tokens_details.cached_tokens /
+    # cache_write_tokens). Every field is optional (Splash sends no cache
+    # writes), and a later value wins per field.
+    class AnthropicAssembly
+      # stop_reason → ChatResponse#finish_reason (the chat loop's words);
+      # pause_turn and anything else pass as they are.
+      FINISH_REASONS = {
+        "end_turn" => "stop", "stop_sequence" => "stop", "max_tokens" => "length",
+        "model_context_window_exceeded" => "length", "tool_use" => "tool_calls", "refusal" => "refusal"
+      }.freeze
+      USAGE_KEYS = %w[input_tokens output_tokens cache_read_input_tokens cache_creation_input_tokens].freeze
+      # Blocks whose text is the answer or the reasoning.
+      THINKING = "thinking"
+      TEXT = "text"
+
+      def self.finish_reason(stop_reason) = stop_reason && FINISH_REASONS.fetch(stop_reason.to_s, stop_reason.to_s)
+
+      # A non-streamed body (a `message` object).
+      def self.from_message(body) = new.tap { |assembly| assembly.add_message(body) }
+
+      def initialize
+        @blocks = []
+        # A streamed block by its index, and a tool_use's input JSON so far.
+        @by_index = {}
+        @json = {}
+        @usage = {}
+        @stop_reason = nil
+        @stop_details = nil
+        @model = nil
+      end
+
+      # A whole message: its model, usage, stop reason and blocks.
+      def add_message(message)
+        return unless message.is_a?(Hash)
+
+        @model = served(message["model"]) || @model
+        merge_usage(message["usage"])
+        @stop_reason = message["stop_reason"] if message["stop_reason"]
+        @stop_details = message["stop_details"] if message["stop_details"].is_a?(Hash)
+        Array(message["content"]).each { |block| @blocks << block.dup if block.is_a?(Hash) }
+      end
+
+      # One streamed event: message_start (served model, usage),
+      # content_block_start (text / thinking / redacted_thinking / tool_use),
+      # content_block_delta (text_delta, thinking_delta, signature_delta,
+      # input_json_delta), content_block_stop, message_delta (stop reason,
+      # stop_details, usage); ping, message_stop and anything else change nothing.
+      # @return [Array(String, String)] the event's text and reasoning
+      def add(event)
+        case event["type"]
+        when "message_start" then start_message(event["message"])
+        when "content_block_start" then start_block(event["index"], event["content_block"])
+        when "content_block_delta" then add_delta(@by_index[event["index"]], event["index"], event["delta"])
+        when "message_delta"
+          if event["delta"].is_a?(Hash)
+            @stop_reason = event.dig("delta", "stop_reason") || @stop_reason
+            @stop_details = event.dig("delta", "stop_details") if event.dig("delta", "stop_details").is_a?(Hash)
+          end
+          merge_usage(event["usage"])
+          ["", ""]
+        else ["", ""]
+        end
+      end
+
+      # Whether a streamed +event+ shows something (a block started, a delta):
+      # what the first-token limit waits for.
+      def self.shows?(event) = %w[content_block_start content_block_delta].include?(event["type"])
+
+      # Whether a streamed +event+ carries part of a tool call.
+      def self.tool_call_delta?(event)
+        case event["type"]
+        when "content_block_start" then event.dig("content_block", "type") == "tool_use"
+        when "content_block_delta" then event.dig("delta", "type") == "input_json_delta"
+        else false
+        end
+      end
+
+      # +event+ as on_delta passes it on: one that carries usage gets the
+      # usage so far in the OpenAI shape as its `usage` (SessionMetrics,
+      # ContextStatus and ctx.js read that).
+      def with_usage(event)
+        return event unless %w[message_start message_delta].include?(event["type"]) && (payload = usage_payload)
+
+        event.merge("usage" => payload)
+      end
+
+      # The usage so far as an OpenAI-shaped `usage` object, nil when the
+      # server sent no counts.
+      def usage_payload
+        return nil if @usage.empty?
+
+        read = @usage["cache_read_input_tokens"].to_i
+        write = @usage["cache_creation_input_tokens"].to_i
+        { "prompt_tokens" => @usage["input_tokens"].to_i + read + write, "completion_tokens" => @usage["output_tokens"].to_i,
+          "prompt_tokens_details" => { "cached_tokens" => read, "cache_write_tokens" => write } }
+      end
+
+      def response
+        blocks = content
+        ChatResponse.new(text: joined(blocks, TEXT, "text"), reasoning: joined(blocks, THINKING, "thinking"),
+                         tool_calls: tool_calls, usage: usage, finish_reason: self.class.finish_reason(@stop_reason),
+                         model: @model, provider_content: blocks, stop_details: @stop_details)
+      end
+
+      private
+
+      def usage
+        payload = usage_payload
+        (payload && Usage.from_payload({ "usage" => payload })) || Usage.none
+      end
+
+      def start_message(message)
+        return ["", ""] unless message.is_a?(Hash)
+
+        @model = served(message["model"]) || @model
+        merge_usage(message["usage"])
+        ["", ""]
+      end
+
+      def start_block(index, block)
+        return ["", ""] unless block.is_a?(Hash)
+
+        block = block.dup
+        @blocks << block
+        @by_index[index] = block
+        case block["type"]
+        when TEXT then [block["text"].to_s, ""]
+        when THINKING then ["", block["thinking"].to_s]
+        else ["", ""]
+        end
+      end
+
+      def add_delta(block, index, delta)
+        return ["", ""] unless block && delta.is_a?(Hash)
+
+        case delta["type"]
+        when "text_delta"
+          block["text"] = block["text"].to_s + delta["text"].to_s
+          [delta["text"].to_s, ""]
+        when "thinking_delta"
+          block["thinking"] = block["thinking"].to_s + delta["thinking"].to_s
+          ["", delta["thinking"].to_s]
+        when "signature_delta"
+          block["signature"] = block["signature"].to_s + delta["signature"].to_s
+          ["", ""]
+        when "input_json_delta"
+          (@json[index] ||= +"") << delta["partial_json"].to_s
+          block["input"] = @json[index]
+          ["", ""]
+        else ["", ""]
+        end
+      end
+
+      def merge_usage(usage)
+        return unless usage.is_a?(Hash)
+
+        USAGE_KEYS.each { |key| @usage[key] = usage[key] if usage[key].is_a?(Integer) }
+      end
+
+      # The blocks to keep and send back: an empty or blank text block is
+      # no text (Splash opens one after a thinking cut by max_tokens, and
+      # Messages refuses one sent back), a tool_use's input is an object,
+      # and a thinking block has a signature, "" when it came without one
+      # (a sent-back thinking block needs the key; Splash sends "", a
+      # provider may send none).
+      def content
+        @blocks.filter_map do |block|
+          type = block["type"].to_s
+          next if type == TEXT && block["text"].to_s.strip.empty?
+          next block.merge("signature" => "") if type == THINKING && !block.key?("signature")
+          next block unless type == "tool_use"
+
+          input = OpenAIChat.parse_arguments(block["input"])
+          block.merge("input" => input.is_a?(Hash) ? input : {})
+        end
+      end
+
+      def joined(blocks, type, key)
+        blocks.select { |block| block["type"] == type }.map { |block| block[key].to_s }.join
+      end
+
+      # The calls with their arguments as OpenAIChat.parse_arguments reads
+      # them: invalid JSON stays a String, so the tool reports it.
+      def tool_calls
+        @blocks.select { |block| block["type"] == "tool_use" }.map do |block|
+          ToolCall.new(id: block["id"], name: block["name"].to_s, arguments: OpenAIChat.parse_arguments(block["input"]))
+        end
+      end
+
+      def served(model) = model.is_a?(String) && !model.strip.empty? ? model : nil
+    end
+  end
+end