samagotchi 0.82.0 → 0.84.0

data/lib/samagotchi/testing/host.rb

@@ -2,6 +2,7 @@
 
 require_relative "../cancellation_controller"
 require_relative "../plugin/context"
+require_relative "../session_metrics/cost"
 require_relative "recorder"
 
 module Samagotchi
@@ -48,9 +49,33 @@ module Samagotchi
           toolkit: -> { recorder[:toolkit] },
           declared_tools: -> { recorder[:declared_tools] || tool_names.call },
           use_toolkit: ->(name) { recorder.use_toolkit(name, toolkits.call) },
-          cancel_controller: ->(handler: false) { recorder[:cancelled] ? stopped : nil }
+          cancel_controller: ->(handler: false) { recorder[:cancelled] ? stopped : nil },
+          cost: -> { cost(recorder[:cost]) }
         )
       end
+
+      # The parts a test may give bundle.set(cost: {...}).
+      COST_PARTS = %i[reported estimated side known].freeze
+
+      # The SessionMetrics::Cost ctx.cost returns for the recorder's +cost+
+      # value (Recorder::DEFAULTS).
+      # @return [SessionMetrics::Cost]
+      def cost(value)
+        value = value.call while value.respond_to?(:call)
+        case value
+        when nil then SessionMetrics::Cost.zero
+        when SessionMetrics::Cost then value
+        when Numeric then SessionMetrics::Cost.zero.with(reported: value.to_f)
+        when Hash
+          unknown = value.keys.map(&:to_sym) - COST_PARTS
+          raise ArgumentError, "unknown cost parts: #{unknown.join(", ")}" unless unknown.empty?
+
+          parts = value.transform_keys(&:to_sym)
+          SessionMetrics::Cost.new(reported: parts.fetch(:reported, 0).to_f, estimated: parts.fetch(:estimated, 0).to_f,
+                                   side: parts.fetch(:side, 0).to_f, known: parts.fetch(:known, true))
+        else raise ArgumentError, "cost: a number, a Hash or a callable, not #{value.inspect}"
+        end
+      end
     end
 
     # The hook runtime (Hooks::Runtime: event[:notify] and the other

data/lib/samagotchi/testing/recorder.rb

@@ -32,7 +32,10 @@ module Samagotchi
       DEFAULTS = {
         session_id: "test-session", cwd: nil, messages: [], messages_partial: false, model_name: "test:model",
         model_key: "model", toolkit: "full", declared_tools: nil, frontend: :worker, scratch: false, setup: nil,
-        prompt_files: [], cancelled: false, state_dir: nil, running: true, toolkit_staged: true
+        prompt_files: [], cancelled: false, state_dir: nil, running: true, toolkit_staged: true,
+        # ctx.cost: nil (zero), a Float (reported USD), a Hash of the parts
+        # (reported:, estimated:, side:, known:) or a callable giving one.
+        cost: nil
       }.freeze
 
       attr_reader :notices, :cards, :steers, :stops, :questions, :model_requests, :toolkit_uses, :answers,

data/lib/samagotchi/tools/delegate_cursor.rb

@@ -14,8 +14,9 @@ module Samagotchi
     # of the child's turn the last follow-up went to (Delegate.follow_up),
     # whose own reply a wait takes (ReplyWait's turn:); nil once that turn
     # was reported, or when unknown (a new child, an older worker).
-    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn) do
-      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil) = super
+    #   +report_claim+: a report reserved until the parent's turn is settled.
+    DelegateCursor = Data.define(:reply_file, :last_turn, :question_id, :messages, :turn, :report_claim) do
+      def initialize(reply_file: nil, last_turn: nil, question_id: nil, messages: nil, turn: nil, report_claim: nil) = super
 
       def self.empty = new
 
@@ -33,6 +34,13 @@ module Samagotchi
       end
 
       def to_json_hash = to_h.transform_keys(&:to_s).compact
+
+      def self.from_json_hash(data)
+        return empty unless data.is_a?(Hash)
+
+        new(reply_file: data["reply_file"], last_turn: data["last_turn"], question_id: data["question_id"],
+            messages: data["messages"], turn: data["turn"], report_claim: data["report_claim"])
+      end
     end
 
     # The parent's cursors, one per child, in <parent dir>/delegates.json, so
@@ -68,6 +76,40 @@ module Samagotchi
         end
       end
 
+      # Reserve a report only if the cursor read to build it is still current.
+      # @return [DelegateCursor, nil] the reserved cursor, or nil if another path moved it
+      def claim_report(parent_id, child_id, expected:, claim:, state_dir:)
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          cursor = get_from(all, child_id)
+          next nil unless cursor == expected
+
+          claimed = cursor.with(report_claim: claim)
+          all[child_id] = claimed.to_json_hash
+          write(parent_id, all, state_dir: state_dir)
+          claimed
+        end
+      end
+
+      # A new owner can retry reports left reserved by a worker that exited
+      # before committing or releasing its turn. No cursor file means no
+      # claims: the lock would create the session dir and its lock file, so
+      # an empty session would no longer count as empty.
+      def clear_report_claims(parent_id, state_dir:)
+        return unless File.exist?(path(parent_id, state_dir: state_dir))
+
+        locked(parent_id, state_dir: state_dir) do
+          all = read(parent_id, state_dir: state_dir)
+          changed = false
+          all.each_value do |data|
+            next unless data.is_a?(Hash)
+
+            changed = true if data.delete("report_claim")
+          end
+          write(parent_id, all, state_dir: state_dir) if changed
+        end
+      end
+
       # Add the cursors of +entries+ (child id → cursor fields, as #read
       # gives them) that the parent has none for; one it has is kept.
       # @return [Array<String>] the child ids added
@@ -94,11 +136,7 @@ module Samagotchi
       end
 
       def get_from(all, child_id)
-        data = all[child_id]
-        return DelegateCursor.empty unless data.is_a?(Hash)
-
-        DelegateCursor.new(reply_file: data["reply_file"], last_turn: data["last_turn"],
-                           question_id: data["question_id"], messages: data["messages"], turn: data["turn"])
+        DelegateCursor.from_json_hash(all[child_id])
       end
 
       def path(parent_id, state_dir:)

data/lib/samagotchi/tools/delegate_wait.rb

@@ -24,6 +24,7 @@ module Samagotchi
     # the wait's first look (a fast failure) still ends it. The cursors are
     # on disk (DelegateCursors), so a respawned worker doesn't repeat a reply.
     module DelegateWait
+      Advance = Data.define(:cursor, :already_reported)
       TIMEOUT_DEFAULT = 600
       POLL_INTERVAL = 0.5
       # Seconds with no worker before the child counts as gone: as long as
@@ -66,6 +67,11 @@ module Samagotchi
         reports = reports_mode(peers)
         others = relay && others_for(peers.session_id, child_id, relay, sd)
         cursor = DelegateCursors.get(peers.session_id, child_id, state_dir: sd)
+        report_claim = cursor.report_claim
+        if report_claim
+          cursor = DelegateCursor.from_json_hash(report_claim["cursor"]).with(report_claim: report_claim)
+        end
+
         baseline = cursor.baseline
         left = timeout.to_i
         outcomes = relayed_outcomes.delete(key) || []
@@ -78,7 +84,13 @@ module Samagotchi
           left -= monotonic - started
           unless wait.status == :waiting_for_answer && DelegateRelay.relayable?(relay, wait.question)
             outcomes.concat(relayed_outcomes.delete(key) || [])
-            advance(peers.session_id, child_id, wait, state_dir: sd)
+            movement = advance(peers.session_id, child_id, wait, state_dir: sd)
+            if movement&.already_reported
+              file = movement.cursor.report_claim&.fetch("file", nil) || wait.file
+              return already_reported_result(child_id, file, state_dir: sd)
+            end
+            return already_reported_result(child_id, report_claim["file"], state_dir: sd) if report_claim && wait.status == :timeout
+
             text = with_outcomes(finish(wait, child_id, timeout: timeout, reports: reports), outcomes)
             return RefText.wrap(text, reply_path(child_id, wait, state_dir: sd))
           end
@@ -159,15 +171,37 @@ module Samagotchi
       # was reported; a question keeps it. Nothing moves on a timeout or a
       # cancel.
       # @param wait [ReplyWait::Result]
-      # @return [DelegateCursor, nil] the new cursor
+      # @return [Advance, nil] the cursor and whether another path reported it
       def advance(parent_id, child_id, wait, state_dir:)
         return nil unless REPORTED.include?(wait.status) && wait.session
 
-        DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |cursor|
-          cursor = cursor.with(reply_file: wait.file) if wait.status == :done
-          cursor = cursor.with(turn: nil) unless wait.status == :waiting_for_answer
-          cursor.with_baseline(ReplyWait.baseline_of(wait.session))
+        already_reported = false
+        cursor = DelegateCursors.update(parent_id, child_id, state_dir: state_dir) do |current|
+          if (current.report_claim && current.report_claim["file"] == wait.file) ||
+             (wait.status == :done && current.reply_file == wait.file)
+            already_reported = true
+            next current
+          end
+
+          current = current.with(reply_file: wait.file) if wait.status == :done
+          current = current.with(turn: nil) unless wait.status == :waiting_for_answer
+          current.with_baseline(ReplyWait.baseline_of(wait.session))
         end
+        Advance.new(cursor: cursor, already_reported: already_reported)
+      end
+
+      def already_reported_result(child_id, file, state_dir:)
+        path = if file.to_s.empty?
+                 nil
+               else
+                 File.join(ReplyWait.reply_dir(child_id, state_dir: state_dir), file)
+               end
+        text = if path
+                 "session: #{child_id}\nstatus: reported\nThe reply was already reported to this session (file: #{File.basename(file)})."
+               else
+                 "session: #{child_id}\nstatus: reported\nThe child's latest status was already reported to this session."
+               end
+        RefText.wrap(text, path)
       end
 
       # The tool result for how the wait ended.

data/lib/samagotchi/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Samagotchi
-  VERSION = "0.82.0"
+  VERSION = "0.84.0"
   # Sent as the User-Agent of every HTTP request chi makes.
   USER_AGENT = "chi/#{VERSION}"
 end

data/lib/samagotchi/web/app.rb

@@ -649,6 +649,15 @@ module Samagotchi
         thinking, error = request_thinking(body["thinking"])
         return error if error
 
+        # bundle_settings: the session's own bundle settings (chi --set:
+        # {bundle => {key => scalar}}), checked against the installed
+        # bundles the same way.
+        begin
+          bundle_settings = BundleSessionSettings.from_request(body["bundle_settings"])
+        rescue BundleSessionSettings::Error => e
+          return error_response(400, "invalid_bundle_settings", e.message)
+        end
+
         folder = dir ? { working_directory: dir } : {}
         # model: the model the session starts on (the start page's picker,
         # spelled as GET /api/models lists it); blank means the default.
@@ -659,7 +668,7 @@ module Samagotchi
         # until that turn is saved.
         preview = idle ? body["preview"].to_s.strip : ""
         folder[:title] = preview unless preview.empty?
-        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking)
+        setup = SessionSetup.new(llm_context: llm_context, thinking: thinking, bundle_settings: bundle_settings)
         folder[:setup] = setup unless setup.empty?
         begin
           session = @manager.spawn_session(prompt: idle ? nil : prompt.to_s, state_dir: @state_dir, **folder)
@@ -679,7 +688,7 @@ module Samagotchi
       # POST /api/sessions with continues: <id, prefix or last:id>: the next
       # link of that session's chain (SessionManager.continue_session), in its
       # folder and with its own setup (SessionSetup: llm_context, thinking
-      # and reasoning_history levels), so dir, llm_context and thinking are
+      # and reasoning_history levels, bundle settings), so dir, llm_context, thinking and bundle_settings are
       # refused beside it (a create takes no reasoning_history). It runs on
       # model (or model_name) when given, else on the previous link's: one
       # whose host is gone falls back to the default, and the 201's
@@ -694,9 +703,9 @@ module Samagotchi
         unless given.is_a?(String) && !given.strip.empty?
           return error_response(400, "invalid_continues", "continues is a session id")
         end
-        if (fields = %w[dir llm_context thinking].select { |key| body.key?(key) }).any?
+        if (fields = %w[dir llm_context thinking bundle_settings].select { |key| body.key?(key) }).any?
           return error_response(400, "invalid_continues",
-                                "continues takes the previous session's folder, llm_context and thinking; " \
+                                "continues takes the previous session's folder, llm_context, thinking and bundle_settings; " \
                                 "leave out #{fields.join(", ")}")
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: samagotchi
 version: !ruby/object:Gem::Version
-  version: 0.82.0
+  version: 0.84.0
 platform: ruby
 authors:
 - Dmitry Dedov
@@ -180,6 +180,7 @@ files:
 - lib/samagotchi/broadcast_command.rb
 - lib/samagotchi/bundle_command.rb
 - lib/samagotchi/bundle_needs.rb
+- lib/samagotchi/bundle_session_settings.rb
 - lib/samagotchi/bundles/agents-md/manifest.yml
 - lib/samagotchi/bundles/agents-md/plugin.rb
 - lib/samagotchi/bundles/btw/manifest.yml
@@ -200,6 +201,8 @@ files:
 - lib/samagotchi/bundles/coordinator/plugin.rb
 - lib/samagotchi/bundles/coordinator/skill_coordinator.md
 - lib/samagotchi/bundles/core/manifest.yml
+- lib/samagotchi/bundles/cost-cap/manifest.yml
+- lib/samagotchi/bundles/cost-cap/plugin.rb
 - lib/samagotchi/bundles/dev/manifest.yml
 - lib/samagotchi/bundles/github-pr/manifest.yml
 - lib/samagotchi/bundles/github-pr/plugin.rb
@@ -469,6 +472,7 @@ files:
 - lib/samagotchi/session_inbox.rb
 - lib/samagotchi/session_manager.rb
 - lib/samagotchi/session_metrics.rb
+- lib/samagotchi/session_metrics/cost.rb
 - lib/samagotchi/session_metrics/model_segment.rb
 - lib/samagotchi/session_metrics/side_totals.rb
 - lib/samagotchi/session_metrics/totals.rb