samagotchi 0.80.0 → 0.81.0

data/lib/samagotchi/guardrails/shell_lex.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "data_readers"
+
 module Samagotchi
   module Guardrails
     # A small shell lexer for the guardrails' text checks (ShellGitDirs
@@ -8,8 +10,9 @@ module Samagotchi
     # backticks (quoted or not) as one opaque SUBST marker inside a word. A
     # heredoc's body (<<EOF, <<'EOF', <<-EOF) is one word after its <<TAG
     # word and lexing goes on after the terminator line: HEREDOC when cat or
-    # tee read it as data, SUBST when an unquoted tag's body holds $(…) or
-    # backticks, else the body text itself (a script, as sh -c '…' gives).
+    # tee read it as data (when the command ends at a plain separator,
+    # outside any ( or { group), SUBST when an unquoted tag's body holds $(…)
+    # or backticks, else the body text itself (a script, as sh -c '…' gives).
     # An unterminated heredoc is no heredoc: the rest is lexed as commands.
     # It never runs anything, and it does its best on odd input (an
     # unbalanced quote).
@@ -18,12 +21,15 @@ module Samagotchi
       OPERATORS = ["&&", "||", ";;", "|&", ";", "|", "&", "\n", "(", ")"].freeze
       # What a $(…) or `…` becomes inside a word.
       SUBST = "\0SUBST"
-      # What a heredoc body that cat or tee read as data becomes.
-      HEREDOC = "\0HEREDOC"
-      # Commands that read a heredoc as data (when not piped on).
-      DATA_SINKS = %w[cat tee].freeze
+      # What a heredoc body that a data reader reads as data becomes (its
+      # command ends at a plain separator, outside any ( or { group).
+      HEREDOC = DataReaders::HEREDOC
+      # The operators that may follow a data heredoc's command; any other
+      # (|, |&, &, (, ), ;;) may hand its output on, and & also starts
+      # &>file.
+      DATA_ENDS = ["\n", ";", "&&", "||"].freeze
       # A word that is a redirection (>, >>, 2>&1, <).
-      REDIRECT = /\A\d*[<>]/
+      REDIRECT = DataReaders::REDIRECT
 
       # Words and operators ([:word, "x", specials] / [:op, "&&"]). A word's
       # specials are the characters the shell would act on in it, unquoted
@@ -57,6 +63,146 @@ module Samagotchi
         commands.reject { |c| c.is_a?(Array) && c.empty? }
       end
 
+      # Whether an ( or { group is still open at token +at+: a pipe after
+      # the group's ) or } takes what the group prints. The counters never go
+      # below 0 (a case pattern's "x)" closes nothing); ((…)) arithmetic and
+      # <(…) / >(…) count as open parens (the conservative reading).
+      def self.in_group?(tokens, at)
+        parens = 0
+        braces = 0
+        tokens[0...at].each do |kind, value|
+          if kind == :op
+            parens += 1 if value == "("
+            parens -= 1 if value == ")" && parens.positive?
+          elsif value == "{"
+            braces += 1
+          elsif value == "}" && braces.positive?
+            braces -= 1
+          end
+        end
+        parens.positive? || braces.positive?
+      end
+
+      # +text+ as code: the lines of each heredoc body its command only reads
+      # as data (DataReaders) cut out, the <<TAG word and the terminator line
+      # kept as written. This is what a rule's command: reads. A text the
+      # lexer isn't sure of (unterminated) comes back as it was, and so does
+      # one it can't read: the safe default.
+      def self.code_text(text)
+        lexer = Lexer.new(text)
+        tokens = lexer.tokens
+        return text if lexer.unterminated?
+
+        bodies = lexer.heredoc_spans.map { |doc| doc[:span] }
+        cuts = []
+        each_command(tokens) do |indices|
+          words = indices.map { |i| tokens[i][1] }
+          indices.each_with_index do |i, position|
+            kind, value, = tokens[i]
+            next unless kind == :word
+
+            span = lexer.spans[i]
+            cut = if bodies.include?(span)
+                    body_cut(text, span, words) if value == HEREDOC
+                  elsif value == SUBST
+                    substitution_cut(text, tokens, i, span, words, position)
+                  end
+            cuts << cut if cut
+          end
+        end
+        cuts.sort_by { |span, _| -span.begin }.each_with_object(+text) do |(span, replacement), out|
+          out[span] = replacement
+        end
+      rescue ArgumentError, EncodingError
+        text
+      end
+
+      # The token indices of each simple command, its operators left out.
+      def self.each_command(tokens)
+        current = []
+        tokens.each_with_index do |(kind, _value, *_rest), i|
+          if kind == :op
+            yield current unless current.empty?
+            current = []
+          else
+            current << i
+          end
+        end
+        yield current unless current.empty?
+      end
+      private_class_method :each_command
+
+      # [span, what it becomes] for a data heredoc's body at +span+ (its
+      # command's +words+), or nil when the body stays in the code text: a
+      # cat or tee writing a file may be run later (D1).
+      def self.body_cut(text, span, words)
+        return nil unless cut_body?(words)
+
+        [span, terminator_line(text[span])]
+      end
+      private_class_method :body_cut
+
+      # Whether a body a data reader reads leaves the code text: a cat or tee
+      # sending it to a file keeps it (D1); a body any other command reads as
+      # data is one the lexer's data_sink? approved.
+      def self.cut_body?(words)
+        verb = DataReaders.command_word(words)
+        return true unless DataReaders::SINKS.include?(File.basename(verb.to_s))
+
+        !DataReaders.writes_file?(words)
+      end
+      private_class_method :cut_body?
+
+      # [span, what it becomes] for the body of a "$(cat <<'EOF' … EOF)" given
+      # as a message (-m, --body, …) of a data reader (D2), or nil: eval,
+      # bash -c, a command piped on and a body that runs stay.
+      def self.substitution_cut(text, tokens, index, span, words, position)
+        return nil unless data_end?(tokens, index)
+        return nil if in_group?(tokens, index)
+        return nil unless DataReaders.message_arg?(words, position)
+
+        raw = text[span]
+        dollar = raw.start_with?("\"$(") ? 1 : 0
+        return nil unless raw[dollar, 2] == "$("
+
+        inner = raw[(dollar + 2)..]
+        inner_lexer = Lexer.new(inner)
+        first = inner_lexer.tokens.first(5)
+        return nil unless message_heredoc?(first)
+
+        inner_span = inner_lexer.spans[2]
+        return nil unless inner_span
+
+        start = span.begin + dollar + 2
+        cut = ((start + inner_span.begin)...(start + inner_span.end))
+        [cut, terminator_line(text[cut])]
+      end
+      private_class_method :substitution_cut
+
+      # Whether the command holding token +index+ ends at nil or a plain
+      # separator (not piped on: what it prints is not run).
+      def self.data_end?(tokens, index)
+        next_op = (tokens[(index + 1)..] || []).find { |token| token[0] == :op }
+        next_op.nil? || DATA_ENDS.include?(next_op[1])
+      end
+      private_class_method :data_end?
+
+      # Whether the tokens inside a $(…) are cat <<TAG and a data body, and
+      # the substitution closes right after.
+      def self.message_heredoc?(first)
+        first.size == 5 && first[0][0..1] == [:word, "cat"] &&
+          first[1][0] == :word && first[1][1].start_with?("<<") &&
+          first[2][0..1] == [:word, HEREDOC] && first[3] == [:op, "\n"] && first[4] == [:op, ")"]
+      end
+      private_class_method :message_heredoc?
+
+      # +raw+ (a body and its terminator line) as its terminator line alone.
+      def self.terminator_line(raw)
+        line = raw.rindex("\n")
+        line ? raw[(line + 1)..] : raw
+      end
+      private_class_method :terminator_line
+
       # A hand-written shell lexer: quotes, backslashes, comments, $(…) and
       # backticks (an opaque marker inside the word), redirections kept in
       # their word (2>&1 doesn't split on &), operators.
@@ -357,32 +503,24 @@ module Samagotchi
           body
         end
 
-        # Whether the command the heredoc at token +at+ is in is cat or tee
-        # and not piped into another command.
+        # Whether the command the heredoc at token +at+ is in reads it as data
+        # (DataReaders.data_reader?: cat, tee, git commit -F -, gh …), ends at
+        # a plain separator (DATA_ENDS: not piped on, backgrounded or handed to
+        # a process substitution) and sits outside any ( or { group (whose
+        # output a pipe after the group's ) or } would take).
         def data_sink?(at)
           start = at
           start -= 1 while start.positive? && @tokens[start - 1][0] == :word
-          verb = command_word(@tokens[start...at])
-          next_op = @tokens[at..].find { |t| t[0] == :op }
-          DATA_SINKS.include?(File.basename(verb.to_s)) && !["|", "|&"].include?(next_op&.dig(1))
+          following = @tokens[at..] || []
+          next_op = following.index { |t| t[0] == :op }
+          ends = next_op.nil? || DATA_ENDS.include?(following[next_op][1])
+          words = @tokens[start...at].map { |t| t[1] }
+          words += @tokens[at...(next_op ? at + next_op : @tokens.size)].map { |t| t[1] }
+          DataReaders.data_reader?(words) && ends && !in_group?(at)
         end
 
-        # The command word among the words before a heredoc's: the NAME=
-        # words and the redirections dropped, and with a redirection written
-        # with a space (> /tmp/x) its target word too.
-        def command_word(words)
-          i = 0
-          while i < words.size
-            word = words[i][1]
-            if word.match?(REDIRECT)
-              i += 1 if word.match?(/\A\d*[<>]{1,2}\z/)
-            elsif !word.match?(/\A[A-Za-z_]\w*=/)
-              return word
-            end
-            i += 1
-          end
-          nil
-        end
+        # Whether an ( or { group is still open at token +at+.
+        def in_group?(at) = ShellLex.in_group?(@tokens, at)
       end
     end
   end

data/lib/samagotchi/guardrails/targets.rb

@@ -8,6 +8,7 @@ require_relative "../log"
 require_relative "model_size"
 require_relative "outside"
 require_relative "shell_git_dirs"
+require_relative "shell_lex"
 require_relative "read_only_shell"
 require_relative "shell_paths"
 require_relative "rm_targets"
@@ -246,6 +247,19 @@ module Samagotchi
 
       def shell? = SHELL_TOOLS.include?(@tool)
 
+      # What a rule's command: reads: the shell command with the body of each
+      # heredoc its command only reads as data left out (ShellLex.code_text);
+      # a plugin tool's own command as given (its text may not be shell).
+      # Approvals, the approval question and hooks keep #command.
+      def rule_command
+        return @rule_command if defined?(@rule_command)
+
+        @rule_command = if @command.nil? then nil
+                        elsif shell? then ShellLex.code_text(@command)
+                        else @command
+                        end
+      end
+
       # The repository's name: its main checkout's folder (the folder
       # holding the common .git dir; a bare repo's name less .git), else
       # the repo root's folder; nil outside a repo.

data/lib/samagotchi/host_config.rb

@@ -23,11 +23,6 @@ module Samagotchi
                            :first_token_timeout, :vision, :sampling, :thinking, :reasoning_history, :remote,
                            :window_tokens, :steer_cut_after, :llm_context_strategy, :llm_context_apply, :llm_context_budget_tokens,
                            :models) do
-    # An api: anthropic host without url/host talks to Anthropic's own API.
-    ANTHROPIC_URL = "https://api.anthropic.com"
-    # auth: as written => the LLM::ApiKey scheme.
-    AUTH_SCHEMES = { "bearer" => :bearer, "x-api-key" => :x_api_key }.freeze
-
     # Every field but name may be left out: nil, models {}.
     def initialize(**fields)
       super(**members.to_h { |m| [m, nil] }, models: {}, **fields)
@@ -77,8 +72,8 @@ module Samagotchi
       end
 
       auth = value.call(:auth).to_s.strip.downcase
-      fields[:auth] = AUTH_SCHEMES[auth] unless auth.empty?
-      return invalid(name, "auth must be one of #{AUTH_SCHEMES.keys.join(", ")}") if !auth.empty? && fields[:auth].nil?
+      fields[:auth] = HostConfig::AUTH_SCHEMES[auth] unless auth.empty?
+      return invalid(name, "auth must be one of #{HostConfig::AUTH_SCHEMES.keys.join(", ")}") if !auth.empty? && fields[:auth].nil?
 
       if fields[:auth] && fields[:api_key_env].nil?
         ConfigFile.warn_once "Warning: #{where}: auth has no effect without api_key_env (no key is sent)"
@@ -121,7 +116,7 @@ module Samagotchi
       host = value.call(:host)
       port = value.call(:port)
       url = value.call(:url).to_s.strip
-      url = ANTHROPIC_URL if url.empty? && api == :anthropic && host.to_s.strip.empty? && port.to_s.strip.empty?
+      url = HostConfig::ANTHROPIC_URL if url.empty? && api == :anthropic && host.to_s.strip.empty? && port.to_s.strip.empty?
       scheme = "http"
       unless url.empty?
         return invalid(name, "give url or host/port, not both") unless host.to_s.strip.empty? && port.to_s.strip.empty?
@@ -178,4 +173,9 @@ module Samagotchi
     end
     private_class_method :invalid
   end
+
+  # An api: anthropic host without url/host talks to Anthropic's own API.
+  HostConfig::ANTHROPIC_URL = "https://api.anthropic.com"
+  # auth: as written => the LLM::ApiKey scheme.
+  HostConfig::AUTH_SCHEMES = { "bearer" => :bearer, "x-api-key" => :x_api_key }.freeze
 end

data/lib/samagotchi/idle_client.rb

@@ -3,6 +3,7 @@
 require "json"
 require_relative "llm/adapters"
 require_relative "log"
+require_relative "side_usage"
 
 module Samagotchi
   # Standalone summarizer for the idle session-recap feature.
@@ -54,9 +55,12 @@ module Samagotchi
     # @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)
+    # @param price [ModelPrice, nil] the model's price on its host
+    #   (IdleTarget#price), on each SideUsage the on_usage callbacks get
     def initialize(model:, base_url: nil, api_key_env: nil, timeout: DEFAULT_TIMEOUT_SECONDS, env: ENV, purpose: "recap",
-                   api: :openai, auth: nil, dialect: nil)
+                   api: :openai, auth: nil, dialect: nil, price: nil)
       @model = model
+      @price = price
       # A recap is best-effort: one short attempt, no retries. The idle job
       # tries again after the next activity, never on its own. Only the
       # Messages adapter takes a dialect.
@@ -70,7 +74,7 @@ module Samagotchi
     # @return [IdleClient]
     def self.for(target, **)
       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, **)
+          auth: target.auth, dialect: target.dialect, price: target.price, **)
     end
 
     THINK_RE = /<\|think\|.*?\|think\|>/m
@@ -100,11 +104,13 @@ module Samagotchi
     # @return [Summary, nil]
     # +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)
+    # +on_usage+: called with the request's SideUsage (kind "recap") once a
+    # reply came back, see #ask.
+    def summarize(prompt, session_id: nil, on_usage: 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, session_id: session_id)
+      response = generate(messages, session_id: session_id, on_usage: on_usage)
       cleaned = response.text.to_s.strip
       cleaned.empty? ? nil : Summary.new(text: cleaned, model: response.model)
     rescue SummarizeError
@@ -121,14 +127,18 @@ module Samagotchi
     # @param options [Hash] more request body fields (logprobs: true,
     #   top_logprobs: 5)
     # @param session_id [String, nil] the session it is about (#summarize)
+    # @param on_usage [#call, nil] called with the request's SideUsage
+    #   (+kind+, the counts, the reported cost, the client's price) once a
+    #   reply came back, a billed one with no usable text too; never for a
+    #   request that got no reply. Its errors are logged, never raised.
     # @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: {}, session_id: nil)
+    def ask(messages, max_tokens: MAX_TOKENS, cancel_controller: nil, kind: "ask", options: {}, session_id: nil, on_usage: nil)
       response = generate(messages, max_tokens: max_tokens, cancel_controller: cancel_controller, whole_sentences: false,
-                                    kind: kind, options: options, session_id: session_id)
+                                    kind: kind, options: options, session_id: session_id, on_usage: on_usage)
       Summary.new(text: response.text.to_s.strip, model: response.model, top_logprobs: response.top_logprobs)
     rescue SummarizeError, LLM::RequestCancelled
       raise
@@ -146,7 +156,7 @@ module Samagotchi
     # +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: {},
-                 session_id: nil)
+                 session_id: nil, on_usage: nil)
       response = begin
         request(messages, max_tokens, cancel_controller, options, session_id)
       rescue LLM::BadRequest => e
@@ -156,6 +166,7 @@ module Samagotchi
         retry
       end
       log_usage(response, kind)
+      report_usage(on_usage, response, kind)
       content = response.text
       reasoning = response.reasoning
       raise SummarizeError, "server returned no parseable assistant content" if content.empty? && reasoning.empty?
@@ -176,14 +187,33 @@ module Samagotchi
       raise SummarizeError, "server returned no parseable assistant content (#{e.message})"
     end
 
-    # The request's prompt-cache counts (a side request on the session's
-    # host can evict the session's cached prompt there).
+    # The request's token counts and reported cost (a broadcast's triage
+    # has no session to count them in). The cache counts show whether the
+    # host reused a cached prefix. A side request evicts a session's cached
+    # prompt only on a llama.cpp with no host-memory cache (--cache-ram 0)
+    # or an old single-slot build, or when pinned to the session's slot,
+    # which chi never does; paid hosts and current llama.cpp aren't
+    # affected (docs/internals/prompt-caching.md).
     def log_usage(response, kind)
-      fields = response.usage&.cache_fields || {}
+      usage = response.usage
+      fields = usage&.cache_fields || {}
       return if fields.empty?
 
       Log.info(:recap, "request_usage", kind: kind, model: @model, prompt: fields[:prompt_tokens],
-                                        cached: fields[:cached_tokens], cache_write: fields[:cache_write_tokens])
+                                        cached: fields[:cached_tokens], cache_write: fields[:cache_write_tokens],
+                                        # A cost as written: Log rounds Floats to 3 places.
+                                        completion: usage.completion_tokens, cost: usage.cost&.to_s)
+    end
+
+    # The request's SideUsage to +on_usage+ (a session counts it in its side
+    # line); a reply without counts is one request with zero tokens.
+    # Counting never fails the side answer: a callback's error is logged.
+    def report_usage(on_usage, response, kind)
+      return unless on_usage
+
+      on_usage.call(SideUsage.from_usage(response.usage, kind: kind, model: @model, price: @price))
+    rescue StandardError => e
+      Log.warn(:recap, "usage_callback_failed", kind: kind, model: @model, error: "#{e.class}: #{e.message}")
     end
 
     # After a host refused this step's thinking fields: the next step, kept

data/lib/samagotchi/idle_recap.rb

@@ -288,12 +288,17 @@ module Samagotchi
                    client: nil,
                    store: nil,
                    session_id: -> {},
+                   on_usage: nil,
                    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
+      # Called with each recap request's SideUsage (IdleClient#summarize),
+      # a dropped recap's too: it was billed (RecapSetup: the Engine's
+      # side line).
+      @on_usage = on_usage
       @target = target || lambda {
         IdleTarget.new(base_url: base_url, api_key_env: api_key_env, model: model, label: model)
       }
@@ -547,7 +552,7 @@ module Samagotchi
 
     def spawn_summarize(client, prompt)
       Thread.new do
-        client.summarize(prompt, session_id: @session_id.call)
+        client.summarize(prompt, session_id: @session_id.call, on_usage: @on_usage)
       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

@@ -14,8 +14,14 @@ module Samagotchi
   #   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
+  # @!attribute price [ModelPrice, nil] the host's models: price for the
+  #   id asked for (as EffectiveModel#price), what a side request's cost is
+  #   estimated from; nil for none, and for a bare base_url target
+  IdleTarget = Data.define(:base_url, :api_key_env, :model, :label, :api, :auth, :dialect, :price) do
+    def initialize(api: :openai, auth: nil, dialect: nil, price: nil, **) = super
+
+    # +entry+'s models: price for +id+ (the id asked for, case-insensitively).
+    def self.price_of(entry, id) = entry.models&.dig(id.to_s.strip.downcase)&.price
 
     # 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).
@@ -49,7 +55,8 @@ module Samagotchi
       resolved = host_registry.resolve(name)
       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))
+          label: name.to_s.strip, api: api_of(entry), auth: entry.auth, dialect: dialect_of(entry),
+          price: price_of(entry, resolved.bare_model))
     end
 
     # A side model's settings (recap.*, broadcast.triage_*) as a target:
@@ -74,6 +81,7 @@ module Samagotchi
       api = :openai
       auth = nil
       dialect = nil
+      entry = 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
@@ -95,7 +103,7 @@ module Samagotchi
       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, api: api, auth: auth,
-          dialect: dialect)
+          dialect: dialect, price: entry && price_of(entry, model))
     end
 
     # Whether the settings fix a host (+base_url+, +host_ref+, or a model

data/lib/samagotchi/llm/usage.rb

@@ -8,7 +8,11 @@ module Samagotchi
     # (:server), else zeros (:none). +cached_tokens+ is the prompt the server
     # reused from its cache, +cache_write_tokens+ what it wrote to it
     # (OpenRouter reports those for Anthropic models); 0 when not reported.
-    Usage = Data.define(:prompt_tokens, :completion_tokens, :source, :cached_tokens, :cache_write_tokens) do
+    # +reasoning_tokens+ is the completion's reasoning part (0 when not
+    # reported), +cost+ the provider's reported cost in USD (OpenRouter's
+    # usage.cost; nil when not reported, a reported 0 stays 0).
+    Usage = Data.define(:prompt_tokens, :completion_tokens, :source, :cached_tokens, :cache_write_tokens,
+                        :reasoning_tokens, :cost) do
       # @return [Usage, nil] nil when the payload carries no counts
       def self.from_payload(payload)
         counts = TokenUsage.from_payload(payload)
@@ -16,12 +20,14 @@ module Samagotchi
 
         new(prompt_tokens: counts.prompt_tokens.to_i, completion_tokens: counts.completion_tokens.to_i,
             source: :server, cached_tokens: counts.cached_tokens.to_i,
-            cache_write_tokens: counts.cache_write_tokens.to_i)
+            cache_write_tokens: counts.cache_write_tokens.to_i, reasoning_tokens: counts.reasoning_tokens.to_i,
+            cost: counts.cost)
       end
 
       def self.none = new(prompt_tokens: 0, completion_tokens: 0, source: :none)
 
-      def initialize(prompt_tokens:, completion_tokens:, source:, cached_tokens: 0, cache_write_tokens: 0)
+      def initialize(prompt_tokens:, completion_tokens:, source:, cached_tokens: 0, cache_write_tokens: 0,
+                     reasoning_tokens: 0, cost: nil)
         super
       end
 

data/lib/samagotchi/model_price.rb

@@ -34,6 +34,22 @@ module Samagotchi
     end
     private_class_method :warn_once
 
+    # The cost rule, one place for a turn's generation (SessionMetrics) and
+    # a side request (SessionMetrics::SideTotals): a reported cost wins; a
+    # reported 0, or none, with a price is estimated from the price (a
+    # gateway that doesn't bill per call reports 0). The reported cost
+    # itself is summed apart, a 0 included.
+    # @param price [ModelPrice, nil]
+    # @param reported_cost [Numeric, nil] the provider's cost (usage.cost)
+    # @return [Float, nil] the estimate, nil when none applies (no price, or
+    #   a positive reported cost), so a sum without one stays as it was
+    def self.estimate(price, reported_cost:, prompt_tokens:, cached_tokens:, cache_write_tokens:, completion_tokens:)
+      return nil unless price && (reported_cost.nil? || reported_cost.zero?)
+
+      price.cost(prompt_tokens: prompt_tokens, cached_tokens: cached_tokens, cache_write_tokens: cache_write_tokens,
+                 completion_tokens: completion_tokens)
+    end
+
     # USD for one generation, OpenAI usage semantics: +prompt_tokens+ holds
     # the cached reads and the cache writes (OpenRouter keeps that for
     # Anthropic models), and reasoning is inside +completion_tokens+.

data/lib/samagotchi/plugin/context.rb

@@ -5,6 +5,7 @@ require_relative "../log"
 require_relative "../paths"
 require_relative "../guardrails/context"
 require_relative "../idle_client"
+require_relative "service"
 require_relative "side_question"
 
 module Samagotchi
@@ -76,7 +77,7 @@ module Samagotchi
     # handler started) they act on the session now, through the Host.
     class Context
       # Thread.current key: {Context => the event its handler runs for}.
-      CURRENT_EVENTS = :samagotchi_plugin_current_events
+      CURRENT_EVENTS = Service::CURRENT_EVENTS
       # Debug-log records tagged plugins, with bundle=<bundle> (tags are a
       # closed list, LogLine::TAGS).
       class Logger
@@ -294,7 +295,7 @@ module Samagotchi
         request = SideQuestion.request(messages: messages, prompt: prompt, system: system)
         limit = max_tokens.nil? ? ASK_MAX_TOKENS : Integer(max_tokens)
         @host.ask_model.call(request, timeout: Float(timeout), max_tokens: limit, cancel_controller: cancel,
-                                      model: model&.strip).to_s
+                                      model: model&.strip, source: @bundle).to_s
       rescue IdleClient::SummarizeError => e
         raise ModelError, e.message
       rescue LLM::RequestCancelled
@@ -318,7 +319,7 @@ module Samagotchi
       # @return [Http]
       def http
         @http ||= Http.new(bundle: @bundle, transport: @http_transport,
-                           cancel_lookup: -> { @host.cancel_controller&.call(handler: in_handler?) })
+                           cancel_lookup: -> { http_cancel_controller })
       end
 
       # This session's attached context: attach a URL or a command, list
@@ -387,6 +388,12 @@ module Samagotchi
       # Whether this plugin's handler runs on this thread (#with_event).
       def in_handler? = !!Thread.current[CURRENT_EVENTS]&.key?(self)
 
+      # The controller a ctx.http call without cancel: stops with: nil inside
+      # a service's start block, even on the turn's thread.
+      def http_cancel_controller
+        Service.starting? ? nil : @host.cancel_controller&.call(handler: in_handler?)
+      end
+
       # The event[:x] helper of the event this plugin's handler runs for on
       # this thread, or nil (not in a handler).
       def event_helper(name)

data/lib/samagotchi/plugin/service.rb

@@ -15,6 +15,16 @@ module Samagotchi
       # again.
       class Stopped < StandardError; end
 
+      # The thread-local Context#with_event keeps its handler events in;
+      # the start block runs with it cleared.
+      CURRENT_EVENTS = :samagotchi_plugin_current_events
+      # Thread.current key: true while a start block runs (the turn's own
+      # thread too: a ctx.http call there isn't the turn's).
+      STARTING = :samagotchi_plugin_service_starting
+
+      # Whether a service's start block runs on this thread.
+      def self.starting? = !!Thread.current[STARTING]
+
       # @return [String] "<bundle>:<name>"
       attr_reader :name
 
@@ -37,7 +47,7 @@ module Samagotchi
           return @value if @state == :running
 
           begin
-            @value = @start.call(self)
+            @value = start_outside_handler
             @state = :running
             Log.info(:plugins, "service_started", service: @name)
             @value
@@ -81,6 +91,19 @@ module Samagotchi
 
       private
 
+      # The start block is the service's, not the handler's whose first
+      # #value started it: no event helper or ctx.http turn cancel inside.
+      def start_outside_handler
+        events = Thread.current[CURRENT_EVENTS]
+        starting = Thread.current[STARTING]
+        Thread.current[CURRENT_EVENTS] = nil
+        Thread.current[STARTING] = true
+        @start.call(self)
+      ensure
+        Thread.current[CURRENT_EVENTS] = events
+        Thread.current[STARTING] = starting
+      end
+
       def run_on_stop
         callbacks = @on_stop.reverse
         @on_stop = []

data/lib/samagotchi/recap_setup.rb

@@ -66,7 +66,8 @@ module Samagotchi
         timeout: recap_number_setting(kwarg_config, :timeout, "recap.timeout", IdleRecap::DEFAULT_TIMEOUT_SECONDS, :float),
         sentences: recap_sentences(string_config(kwarg_config, :sentences) || registry_string("recap.sentences")),
         store: RecapStore.new(session_id_lookup: -> { session_id.call }, state_dir_lookup: -> { state_dir.call }),
-        session_id: -> { session_id.call }
+        session_id: -> { session_id.call },
+        on_usage: ->(usage) { engine.note_side_usage(usage) }
       )
     end