samagotchi 0.10.1 → 0.12.0

data/lib/samagotchi/llm/chat_loop.rb

@@ -9,13 +9,16 @@ require_relative "openai_chat"
 require_relative "native_tool_normalizer"
 require_relative "../kernel_loop"
 require_relative "../answer_display"
+require_relative "../context_status"
 require_relative "../context_window"
 require_relative "../context_note"
 require_relative "../tool_runner"
+require_relative "../tool_response"
 require_relative "../tool_declarations"
 require_relative "../vision_context"
 require_relative "../log"
 require_relative "../empty_answer_retry"
+require_relative "../steer"
 require_relative "../turn_note"
 require_relative "../thinking"
 
@@ -74,10 +77,8 @@ module Samagotchi
         end
       end
 
-      # The kernel's tools; the built-ins for a kernel without a registry.
-      def tools
-        @kernel.respond_to?(:tools) ? @kernel.tools : Tools::Builtins.default
-      end
+      # The kernel's tools.
+      def tools = @kernel.tools
 
       # engine-format conversation -> OpenAI wire messages. Model turns are
       # thought-stripped and carry their tool_calls; tool responses go as tool
@@ -130,20 +131,15 @@ module Samagotchi
 
       TOOL_IMAGES_TEXT = "[images from tool results]"
 
-      # The turn's VisionContext (the Engine sets it on the kernel), or nil.
-      def vision
-        @kernel.respond_to?(:vision) ? @kernel.vision : nil
-      end
+      # The turn's VisionContext (the Engine sets the kernel's
+      # turn_settings), or nil.
+      def vision = @kernel.turn_settings.vision
 
-      # The turn's request parameters (the Engine sets them on the kernel).
-      def sampling
-        @kernel.respond_to?(:sampling) ? @kernel.sampling || {} : {}
-      end
+      # The turn's request parameters (the kernel's turn_settings).
+      def sampling = @kernel.turn_settings.sampling || {}
 
-      # The turn's thinking level (the Engine sets it on the kernel).
-      def thinking
-        (@kernel.respond_to?(:thinking) && @kernel.thinking) || Thinking::DEFAULT
-      end
+      # The turn's thinking level (the kernel's turn_settings).
+      def thinking = @kernel.turn_settings.thinking || Thinking::DEFAULT
 
       # The request fields the thinking level adds (Thinking.chat_fields);
       # none for a model whose host refused them (#thinking_refused!).
@@ -168,9 +164,7 @@ module Samagotchi
         deep_compact(options)
       end
 
-      def strip_model_thought(text)
-        @kernel.respond_to?(:strip_model_thought) ? @kernel.strip_model_thought(text) : text
-      end
+      def strip_model_thought(text) = @kernel.strip_model_thought(text)
 
       def tool_runner
         @tool_runner ||= ToolRunner.new(@kernel)
@@ -181,25 +175,15 @@ module Samagotchi
       # llama.cpp answers /props), then the host's model list, config, env
       # and the default. A remote provider has no /props to probe.
       def context_window(model)
-        remote = @adapter.respond_to?(:remote?) && @adapter.remote?
-        client = @kernel.client if !remote && @kernel.respond_to?(:client)
+        client = @adapter.remote? ? nil : @kernel.client
         ContextWindow.resolve(client: client, model: model, adapter: @adapter)
       rescue StandardError
         nil
       end
 
-      # The status line's context value for +used_tokens+ of +window_tokens+
-      # (KernelLoop#context_display), or nil.
-      def context_display(used_tokens:, window_tokens:)
-        return nil unless @kernel.respond_to?(:context_display)
-
-        @kernel.context_display(used_tokens: used_tokens, window_tokens: window_tokens)
-      end
-
       # A hook failing must not break the turn (as in ToolRunner).
       def fire_hook(name, event)
-        hooks = @kernel.hooks if @kernel.respond_to?(:hooks)
-        hooks&.fire(name, event)
+        @kernel.hooks&.fire(name, event)
       rescue StandardError
         nil
       end
@@ -218,9 +202,7 @@ module Samagotchi
           message[:tool_call_id] = entry[:tool_call_id] if entry[:tool_call_id]
           message[:images] = entry[:images] if entry[:images].is_a?(Array) && !entry[:images].empty?
           message[:thinking] = entry[:thinking] if entry[:thinking].is_a?(String) && !entry[:thinking].empty?
-          message[:tool_params] = entry[:tool_params] if entry[:tool_params]
-          message[:tool_labels] = entry[:tool_labels] if entry[:tool_labels]
-          message[:tool_diffs] = entry[:tool_diffs] if entry[:tool_diffs]
+          ToolResponse::SAVED_KEYS.each { |key| message[key] = entry[key] if entry[key] }
           message[TurnNote::RETRY_NUDGE] = true if TurnNote.retry_nudge?(entry)
           message[AnswerDisplay::KEY] = entry[AnswerDisplay::KEY] if entry[AnswerDisplay::KEY]
           ContextNote::KEYS.each { |key| message[key] = entry[key] if entry.key?(key) }
@@ -304,7 +286,7 @@ module Samagotchi
         text.encoding == Encoding::UTF_8 && !text.valid_encoding? ? text.scrub("?") : text
       end
 
-      # One turn's state: the conversation, the stream sink, usage and tool
+      # One turn's state: the conversation, the stream sink and tool
       # activity.
       class Run
         def initialize(loop, conversation, on_stream_event, cancel_controller, model_name, pending_input)
@@ -314,14 +296,9 @@ module Samagotchi
           @cancel_controller = cancel_controller
           @model_name = model_name
           @pending_input = pending_input
-          @usage = UsageCollector.new
           @tool_activity = []
-          # What an estimate counts as the prompt when the server reports no
-          # usage: the text, and each image's estimate (not its base64).
-          @prompt_text = conversation.sum("") { |entry| entry[:content].to_s }
-          @image_tokens = ImagePlan.estimated_tokens(conversation)
-          @empty_retries = 0
-          @empty_retry_limit = EmptyAnswerRetry.limit
+          @empty_retry = EmptyAnswerRetry.new
+          @context = ContextStatus.new(conversation: conversation)
         end
 
         EMPTY_ANSWER = "(the model returned an empty answer)"
@@ -346,10 +323,15 @@ module Samagotchi
 
             last_text = @loop.strip_model_thought(response.text)
             if response.tool_calls.empty?
+              # Only whitespace is no answer either (as in the native loop).
+              empty = last_text.strip.empty?
               # Kept before a merge too: the model answers the merged line
               # knowing what it just said.
-              @conversation << with_thinking({ role: "model", content: last_text }, response) unless last_text.empty?
-              retry_empty = last_text.empty? && retry_empty_answer?(iteration, response)
+              @conversation << with_thinking({ role: "model", content: last_text }, response) unless empty
+              retry_empty = empty &&
+                            @empty_retry.retry_empty?(iteration: iteration, cancelled: @cancel_controller&.cancelled?,
+                                                      finish_reason: response.finish_reason,
+                                                      used_tokens: response.usage&.total_tokens, window_tokens: @window&.tokens)
               # An empty answer that will be retried is no answer site: a
               # plugin's steer joins the retry instead of being dropped, and
               # queued input (a user's line, a steer) goes in place of the nudge.
@@ -358,7 +340,7 @@ module Samagotchi
 
               # Shown, not saved: an empty answer (content "" + stop, seen from
               # a remote host) would otherwise end the turn with nothing.
-              last_text = EMPTY_ANSWER if last_text.empty?
+              last_text = EMPTY_ANSWER if empty
               exhausted = false
               break
             end
@@ -376,29 +358,12 @@ module Samagotchi
 
         private
 
-        # A retry is left, and the answer wasn't cut short by a full context
-        # (a length stop while thinking is retried: a thinking loop cut by
-        # the provider's output cap, not a full window).
-        def retry_empty_answer?(iteration, response)
-          return false if @empty_retries >= @empty_retry_limit || @cancel_controller&.cancelled?
-
-          if response.finish_reason.to_s == "length" &&
-             EmptyAnswerRetry.context_full?(response.usage&.total_tokens, @window&.tokens)
-            Log.info(:turn, "empty_answer_not_retried", iteration: iteration, why: "context full")
-            return false
-          end
-          true
-        end
-
         # The hidden nudge before the next generation (EmptyAnswerRetry),
         # which runs at the retry temperature. Returns true.
         def nudge_empty_answer(iteration, response)
-          @empty_retries += 1
-          @retry_generation = true
-          emit(type: :empty_answer_retry, iteration: iteration, attempt: @empty_retries, of: @empty_retry_limit,
-               finish_reason: response.finish_reason, thinking_chars: response.reasoning.to_s.length)
-          @conversation << TurnNote.empty_retry
-          true
+          @empty_retry.nudge!(@conversation, TurnNote.empty_retry,
+                              emit: method(:emit), iteration: iteration, finish_reason: response.finish_reason,
+                              thinking_chars: response.reasoning.to_s.length)
         end
 
         # A generation a plugin cut (stop_generation) is an empty answer made
@@ -410,19 +375,15 @@ module Samagotchi
         def after_cut(iteration, response)
           return canceled(iteration, @cancel_controller.reason) if @cancel_controller.cancelled?
 
-          if @empty_retries < @empty_retry_limit
+          if @empty_retry.left?
             return :retry if inject_pending_input(iteration)
 
-            @empty_retries += 1
-            @retry_generation = true
-            emit(type: :empty_answer_retry, iteration: iteration, attempt: @empty_retries, of: @empty_retry_limit,
-                 finish_reason: response.finish_reason, thinking_chars: response.reasoning.to_s.length,
-                 stopped_by: response.cut[:by])
-            @conversation << TurnNote.cut_retry(response.cut[:by], response.cut[:reason])
+            @empty_retry.nudge!(@conversation, TurnNote.cut_retry(response.cut[:by], response.cut[:reason]),
+                                emit: method(:emit), iteration: iteration, finish_reason: response.finish_reason,
+                                thinking_chars: response.reasoning.to_s.length, stopped_by: response.cut[:by])
             return :retry
           end
-          index = @conversation.rindex { |entry| TurnNote.retry_nudge?(entry) }
-          @conversation.delete_at(index) if index
+          @empty_retry.drop_nudge!(@conversation)
           @cancel_controller.cancel!(:hook, response.cut)
           canceled(iteration, :hook)
         end
@@ -440,8 +401,8 @@ module Samagotchi
         # text] when it was cancelled.
         def generate(iteration)
           window = @window = @loop.context_window(@model_name)
-          retry_generation = @retry_generation
-          @retry_generation = false
+          observe_context(iteration, window)
+          retry_generation = @empty_retry.take_sampling!
           emit(type: :generation_started, iteration: iteration, context_window_tokens: window&.tokens,
                context_window_source: window&.source)
           @loop.fire_hook(:before_generation, { type: :before_generation, iteration: iteration })
@@ -517,13 +478,49 @@ module Samagotchi
             !error.context_overflow? && !@loop.thinking_fields(@model_name).empty?
         end
 
-        # The status line's value from the server's counts for this request
-        # (prompt + answer); without them the last value stays.
+        # Before a request, as the native loop: estimate how full the window
+        # is (the server's last count plus what the turn appended since),
+        # emit :context_status on a bucket change, and put the model's own
+        # line on the tail on a rise that asks it for a change. The estimate
+        # counts the conversation's text and tool calls, not the tool
+        # schemas (the server's count does).
+        def observe_context(iteration, window)
+          return unless window
+
+          @request_image_tokens = ImagePlan.estimated_tokens(@conversation)
+          event = @context.observe(prompt_chars, iteration_index: iteration - 1, window: window,
+                                                 image_tokens: @request_image_tokens)
+          emit(type: :context_status, iteration: iteration, **event) if event
+          if (line = @context.take_guidance)
+            @conversation << line
+          end
+          @request_chars = prompt_chars
+        end
+
+        # The conversation's text as the request carries it: contents (a
+        # parts list's text parts) and the tool calls' names and arguments.
+        def prompt_chars
+          @conversation.sum do |entry|
+            content = entry[:content]
+            chars = if content.is_a?(Array)
+                      content.sum { |part| part.is_a?(Hash) ? (part[:text] || part["text"]).to_s.length : 0 }
+                    else
+                      content.to_s.length
+                    end
+            chars + Array(entry[:tool_calls]).sum { |call| call[:name].to_s.length + call[:arguments].to_json.length }
+          end
+        end
+
+        # The server's counts for this request (prompt + answer): the status
+        # line's value, and where the next estimate starts. Without them the
+        # estimate stays.
         def record_context_status(usage, window)
-          return unless usage.source == :server && window
+          return unless usage.source == :server
 
-          display = @loop.context_display(used_tokens: usage.total_tokens, window_tokens: window.tokens)
-          @context_status = display if display
+          counts = @context.capture({ "usage" => { "prompt_tokens" => usage.prompt_tokens,
+                                                   "completion_tokens" => usage.completion_tokens } })
+          @context.generation_done(counts, prompt_chars: @request_chars.to_i, image_tokens: @request_image_tokens.to_i,
+                                           window: window)
         end
 
         # The model's answer at debug level, as the native loop dumps its
@@ -539,44 +536,22 @@ module Samagotchi
                                         served_model: response.model, tool_calls: calls.empty? ? nil : calls.join(","))
         end
 
+        # Each call's result goes on the conversation as it finishes, paired
+        # with its call (ToolResponse.single: the capped output).
         def dispatch(tool_calls, iteration, cap)
-          emit(type: :tool_dispatch_started, iteration: iteration, call_count: tool_calls.length)
-          tool_calls.each_with_index do |tool_call, index|
-            call = NativeToolNormalizer.normalize(tool_call)
-            run = @loop.tool_runner.run(call, iteration: iteration, call_index: index + 1, call_count: tool_calls.length,
-                                              on_stream_event: @on_stream_event, max_tool_output_chars: cap)
-            @tool_activity << run[:activity] if run[:activity]
-            # The chat loop feeds the model the capped output (native feeds
-            # the full one; D-P2-6).
-            entry = { role: "tool_response", content: run[:capped_output], tool_call_id: tool_call.id }
-            entry[:images] = run[:images] if run[:images]&.any?
-            # A plugin tool's params line, for the web's reload; never sent.
-            entry[:tool_params] = run[:shown_params] if run[:shown_params]
-            entry[:tool_labels] = run[:shown_label] if run[:shown_label]
-            # What an edit/write changed, for the web's reload; never sent.
-            entry[:tool_diffs] = run[:diff] if run[:diff]
-            @conversation << entry
+          calls = tool_calls.map { |tool_call| NativeToolNormalizer.normalize(tool_call) }
+          runs = ToolResponse.run_batch(@loop.tool_runner, calls, iteration: iteration, emit: method(:emit),
+                                                                  on_stream_event: @on_stream_event, cap: cap) do |run, index|
+            @conversation << ToolResponse.single(run, tool_call_id: tool_calls[index].id)
           end
-          emit(type: :tool_dispatch_completed, iteration: iteration, call_count: tool_calls.length)
+          @tool_activity.concat(ToolResponse.activities(runs))
         end
 
-        # Queued steering joins the conversation as one user message, a
-        # plugin's steers each as its own after it (Steer). Returns true when
-        # there was any. After a cancel it stays queued, so it runs as the
-        # next turn instead of dying with this one. +answer+ is the answer the
-        # merge follows, for the UIs; given, the drain is told it is the
-        # after-answer site (plugin steers are dropped there).
+        # Queued input at an iteration boundary (Steer.inject!). Returns true
+        # when there was any.
         def inject_pending_input(iteration, answer: nil)
-          return false unless @pending_input
-          return false if @cancel_controller&.cancelled?
-
-          merge = Steer.merge(Steer.drain(@pending_input, at_answer: !answer.nil?))
-          return false if merge.empty?
-
-          @conversation.concat(merge.messages)
-          emit(type: :pending_input_merged, iteration: iteration, **merge.event_fields,
-               answer: answer.to_s.empty? ? nil : answer)
-          true
+          Steer.inject!(@conversation, @pending_input, iteration: iteration, emit: method(:emit),
+                                                       cancel_controller: @cancel_controller, answer: answer)
         end
 
         # The text streamed before the cancel stays, marked [interrupted],
@@ -587,23 +562,18 @@ module Samagotchi
           @conversation << { role: "model", content: "#{visible}\n[interrupted]", interrupted: true } unless visible.empty?
           conversation = @loop.plain(@conversation)
           conversation.last[:interrupted] = true unless visible.empty?
-          ModelResult.new(text: "", provider: :chat, conversation: conversation, canceled: true,
-                          cancellation_reason: reason, tool_activity: @tool_activity, usage: usage,
-                          context_status: @context_status)
+          ModelResult.new(text: "", conversation: conversation, canceled: true,
+                          cancellation_reason: reason, tool_activity: @tool_activity,
+                          context_status: @context.display)
         end
 
         def result(text, exhausted:)
-          ModelResult.new(text: text, provider: :chat, conversation: @loop.plain(@conversation), exhausted: exhausted,
-                          tool_activity: @tool_activity, usage: usage, empty_answer: text == EMPTY_ANSWER,
-                          context_status: @context_status)
-        end
-
-        def usage
-          @usage.usage(prompt_text: @prompt_text, extra_prompt_tokens: @image_tokens)
+          ModelResult.new(text: text, conversation: @loop.plain(@conversation), exhausted: exhausted,
+                          tool_activity: @tool_activity, empty_answer: text == EMPTY_ANSWER,
+                          context_status: @context.display)
         end
 
         def emit(event)
-          @usage.observe(event)
           @on_stream_event&.call(event)
         rescue StandardError
           nil

data/lib/samagotchi/llm/model_result.rb

@@ -3,29 +3,20 @@
 module Samagotchi
   module LLM
     # Normalized result returned by every ModelBackend downstream of the agentic
-    # loop. The loop lives INSIDE the backend (Option A), so raw provider tool
-    # calls are never surfaced — `tool_calls` is always `nil` downstream.
-    #
-    # It deliberately mirrors the read surface Engine#run_turn and the renderers
-    # (TerminalUI / Bridge) currently consume off KernelLoop::Result, so wiring
-    # the seam in does not require changes to those consumers:
-    #   .conversation, .canceled?, .cancellation_reason, .output, .exhausted?
-    # plus the native loop's .tool_activity, .context_status and
-    # .pending_tool_calls, which the interactive renderer needs.
+    # loop (the loop lives inside the backend). What Engine#run_turn and the
+    # renderers (TerminalUI / Bridge) read: .output (= .text, and .to_s, which
+    # is how the :turn_completed `result:` reaches JSON), .conversation,
+    # .canceled?, .cancellation_reason, .exhausted?, .resumable?,
+    # .empty_answer?, plus the native loop's .tool_activity, .context_status
+    # and .pending_tool_calls, which the interactive renderer needs.
     class ModelResult
-      attr_reader :text, :tool_calls, :provider, :usage, :metadata,
-                  :conversation, :canceled, :cancellation_reason, :exhausted,
+      attr_reader :text, :conversation, :canceled, :cancellation_reason, :exhausted,
                   :tool_activity, :context_status, :pending_tool_calls
 
-      def initialize(text:, tool_calls: nil, provider: nil, usage: nil, metadata: nil,
-                     conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
+      def initialize(text:, conversation: nil, canceled: false, cancellation_reason: nil, exhausted: false,
                      tool_activity: [], context_status: nil, pending_tool_calls: false, empty_answer: false)
         @empty_answer = empty_answer
         @text = text
-        @tool_calls = tool_calls
-        @provider = provider
-        @usage = usage
-        @metadata = metadata
         @conversation = conversation
         @canceled = canceled
         @cancellation_reason = cancellation_reason
@@ -44,10 +35,13 @@ module Samagotchi
         !!canceled
       end
 
-      # The turn ended with nothing visible: the text shown is a placeholder,
-      # the conversation holds no reply.
+      # The turn ended with nothing visible: no text, or the chat loop's
+      # placeholder (empty_answer:). A cancelled turn or one that can be
+      # continued is not an empty answer.
       def empty_answer?
-        !!@empty_answer
+        return false if canceled? || resumable?
+
+        !!@empty_answer || text.to_s.strip.empty?
       end
 
       def exhausted?

data/lib/samagotchi/llm/native_backend.rb

@@ -2,12 +2,11 @@
 
 require_relative "backend"
 require_relative "model_result"
-require_relative "usage"
 
 module Samagotchi
   module LLM
     # The raw-prompt loop as a backend: KernelLoop#run (llama.cpp /completion,
-    # Gemma/Qwen prompt formats) with its result wrapped in a ModelResult, so
+    # Gemma/Qwen prompt formats), which returns a ModelResult itself, so
     # Engine and the TUI call every backend the same way.
     class NativeBackend < ModelBackend
       def initialize(kernel:)
@@ -18,32 +17,15 @@ module Samagotchi
 
       def complete(messages:, max_iterations: 100, on_stream_event: nil, cancel_controller: nil,
                    model_name: nil, max_tool_output_chars: nil, pending_input: nil)
-        usage = UsageCollector.new
-        kernel_result = @kernel.run(
+        @kernel.run(
           messages,
           max_iterations: max_iterations,
-          on_stream_event: lambda { |event|
-            usage.observe(event)
-            on_stream_event&.call(event)
-          },
+          on_stream_event: ->(event) { on_stream_event&.call(event) },
           cancel_controller: cancel_controller,
           model_name: model_name,
           max_tool_output_chars: max_tool_output_chars,
           pending_input: pending_input
         )
-        ModelResult.new(
-          text: kernel_result.output.to_s,
-          tool_calls: nil,
-          provider: :native,
-          usage: usage.usage(prompt_text: Array(messages).sum("") { |message| message[:content].to_s }),
-          conversation: kernel_result.conversation,
-          canceled: kernel_result.canceled?,
-          cancellation_reason: kernel_result.cancellation_reason,
-          exhausted: kernel_result.exhausted,
-          tool_activity: kernel_result.tool_activity,
-          context_status: kernel_result.context_status,
-          pending_tool_calls: kernel_result.pending_tool_calls
-        )
       end
     end
   end

data/lib/samagotchi/llm/openai_chat.rb

@@ -56,7 +56,7 @@ module Samagotchi
       # @param entry [HostRegistry::HostEntry]
       def self.for(entry, **options)
         new(base_url: entry.openai_base_url, host_name: entry.name, api_key_env: entry.api_key_env,
-            remote: entry.respond_to?(:remote?) && entry.remote?, **options)
+            remote: entry.remote?, **options)
       end
 
       # Tool arguments as a Hash; "" is {}, invalid JSON stays a String.

data/lib/samagotchi/llm/turn_settings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../thinking"
+
+module Samagotchi
+  module LLM
+    # A turn's settings on the kernel, read by both loops (KernelLoop,
+    # ChatLoop) and ToolRunner: the turn's VisionContext (nil sends no
+    # images, placeholders instead), its request parameters
+    # (SamplingSettings.for; empty sends none), its thinking level
+    # (Thinking.resolve) and the bare model id the turn runs on (every
+    # debug dump is tagged with it). The Engine sets them once per turn,
+    # in Engine#generate, after the model's host is synced.
+    TurnSettings = Data.define(:vision, :sampling, :thinking, :model_name) do
+      # No vision, no sampling, the default thinking, no model name.
+      def self.none = new(vision: nil, sampling: {}.freeze, thinking: Thinking::DEFAULT, model_name: nil)
+    end
+  end
+end

data/lib/samagotchi/llm/usage.rb

@@ -4,8 +4,8 @@ require_relative "../token_usage"
 
 module Samagotchi
   module LLM
-    # A turn's token counts, never nil: what the server reported (:server),
-    # else a chars/4 estimate (:estimate), else zeros (:none).
+    # A response's token counts, never nil: what the server reported
+    # (:server), else zeros (:none).
     Usage = Data.define(:prompt_tokens, :completion_tokens, :source) do
       # @return [Usage, nil] nil when the payload carries no counts
       def self.from_payload(payload)
@@ -16,64 +16,9 @@ module Samagotchi
             source: :server)
       end
 
-      # +extra_prompt_tokens+: what the prompt holds besides text (images).
-      def self.estimate(prompt_text:, completion_text:, extra_prompt_tokens: 0)
-        new(prompt_tokens: TokenUsage.estimate(prompt_text.to_s) + extra_prompt_tokens.to_i,
-            completion_tokens: TokenUsage.estimate(completion_text.to_s),
-            source: :estimate)
-      end
-
       def self.none = new(prompt_tokens: 0, completion_tokens: 0, source: :none)
 
       def total_tokens = prompt_tokens + completion_tokens
     end
-
-    # Builds a turn's Usage from its stream events, the way SessionMetrics
-    # counts them: server counts are cumulative per request, so each
-    # generation keeps its highest; the prompt grows across a turn's
-    # generations, so the last generation's prompt counts, and completions
-    # add up. Without server counts, the streamed text is estimated.
-    class UsageCollector
-      def initialize
-        @generations = []
-      end
-
-      def observe(event)
-        case event[:type]
-        when :generation_started
-          @generations << { prompt: 0, completion: 0, server: false, text: +"" }
-        when :generation_chunk
-          @generations << { prompt: 0, completion: 0, server: false, text: +"" } if @generations.empty?
-          record(@generations.last, event)
-        end
-      end
-
-      # @param prompt_text [String, nil] what an estimate counts as the prompt
-      # @param extra_prompt_tokens [Integer] estimated non-text prompt tokens
-      def usage(prompt_text: nil, extra_prompt_tokens: 0)
-        server = @generations.select { |generation| generation[:server] }
-        unless server.empty?
-          return Usage.new(prompt_tokens: server.last[:prompt], completion_tokens: server.sum { |g| g[:completion] },
-                           source: :server)
-        end
-
-        text = @generations.sum("") { |generation| generation[:text] }
-        return Usage.none if text.empty?
-
-        Usage.estimate(prompt_text: prompt_text, completion_text: text, extra_prompt_tokens: extra_prompt_tokens)
-      end
-
-      private
-
-      def record(generation, event)
-        counts = Usage.from_payload(event[:payload])
-        if counts
-          generation[:server] = true
-          generation[:prompt] = [generation[:prompt], counts.prompt_tokens].max
-          generation[:completion] = [generation[:completion], counts.completion_tokens].max
-        end
-        generation[:text] << event[:content].to_s
-      end
-    end
   end
 end

data/lib/samagotchi/memory_bundle/installer.rb

@@ -365,7 +365,7 @@ module Samagotchi
             version: manifest.version,
             source_path: @source,
             hooks: hooks_for_provenance,
-            trust_level: manifest.respond_to?(:trust_level) ? manifest.trust_level : nil,
+            trust_level: manifest.trust_level,
             source_commit: source_commit,
             hooks_files: hooks_files_for_provenance,
             guardrails_files: guardrail_files_for_provenance,