samagotchi 0.68.0 → 0.70.0

data/lib/samagotchi/tools/tool_index.rb

@@ -2,6 +2,9 @@
 
 require "json"
 require_relative "args"
+require_relative "builtin_calls"
+require_relative "registry"
+require_relative "../log"
 require_relative "../token_usage"
 require_relative "../tool_declarations"
 require_relative "../plugin/tool_spec"
@@ -9,24 +12,31 @@ require_relative "../plugin/tool_spec"
 module Samagotchi
   module Tools
     # The tools a session knows but doesn't declare one by one, and the two
-    # declared tools that reach them (docs/plugins.md, "Publishing tools to
-    # the index"): find_tools, a keyword search that answers each
-    # match's inputSchema, and call_tool, which calls one as <group>/<tool>.
+    # tools that reach them (docs/plugins.md, "Publishing tools to the
+    # index"): find_tools, a keyword search that answers each match's
+    # inputSchema, and call_tool, which calls one as <group>/<tool>.
     # A source (the mcp bundle, chi.tool_source) publishes its groups (an
-    # MCP server each) and runs the calls; the index searches them, looks a
-    # call's tool up and checks it. The two tools are declared once, after
-    # the plugins load, and only when a source registered: nothing a source
-    # publishes later changes the request's tools, so the prompt cache keeps.
+    # MCP server each) and runs the calls; the index's own group, chi, is
+    # the built-ins the session's toolkit leaves out but doesn't remove
+    # (Registry#reachable_names), and a call_tool of one runs as that
+    # built-in (#unwrap, before the guardrail gate). The index searches the
+    # groups, looks a call's tool up and checks it.
+    #
+    # The two tools are registered once, after the plugins load, and
+    # declared per toolkit (Registry#declared?): when a source registered
+    # then, or the toolkit leaves a built-in reachable. The search tool's
+    # description has the source groups' lines as they were at load and a
+    # chi line per toolkit (#refresh!): nothing a source publishes later
+    # changes the request's tools, so the prompt cache keeps.
     #
     # They are registry entries of source SOURCE, not "core": a plugin
     # tool's paths (guardrail targets, the row's label and preview, native
-    # flat schemas, every toolkit declaring them) are the ones call_tool has
-    # always had. MCP is the only source so far, so the texts speak of MCP
-    # servers.
+    # flat schemas) are the ones call_tool has always had.
     class ToolIndex
       SOURCE = "index"
       FIND_NAME = "find_tools"
-      CALL_NAME = "call_tool"
+      # What an unwrapped call carries as via: too.
+      CALL_NAME = BuiltinCalls::VIA
       # Matches a search answers, and names a miss suggests.
       FIND_RESULTS = 5
       CLOSEST = 3
@@ -34,15 +44,20 @@ module Samagotchi
       # times one in its description.
       NAME_WEIGHT = 3
       PREVIEW_CHARS = 60
+      # The index's own group: chi's built-ins a toolkit leaves out.
+      CHI_GROUP = "chi"
+      CHI_SUMMARY = "chi's own tools not declared in this session"
+      # Group names a source can't publish: the index's own groups'.
+      RESERVED_GROUPS = [CHI_GROUP].freeze
 
       FIND_PARAMS = {
         query: { type: "string", required: true,
                  description: "keywords for what the tool does (\"screenshot page\"); empty lists every tool's name" },
-        server: { type: "string", description: "search only this server" }
+        group: { type: "string", description: "search only this group" }
       }.freeze
-      CALL_DESCRIPTION = "Call an MCP server's tool that #{FIND_NAME} found.".freeze
+      CALL_DESCRIPTION = "Call a tool #{FIND_NAME} found.".freeze
       CALL_PARAMS = {
-        tool: { type: "string", required: true, description: "the tool as <server>/<tool>" },
+        tool: { type: "string", required: true, description: "the tool as <group>/<tool>" },
         args: { type: "object", description: "the arguments, per the inputSchema #{FIND_NAME} gave" }
       }.freeze
 
@@ -50,15 +65,17 @@ module Samagotchi
       # +schema+ its inputSchema, +acts_as+ the name guardrail rules match
       # (mcp_<server>_<tool>; a bare name the call tool looks up too).
       # +refusal+ is why it can't be called (nil when it can), +mark+ what a
-      # search shows beside its name then ("(bad schema)"). A blank
-      # +acts_as+ raises ArgumentError: no rule could match the tool's calls.
-      Tool = Data.define(:group, :name, :description, :schema, :acts_as, :refusal, :mark) do
-        def initialize(group:, name:, acts_as:, description: "", schema: nil, refusal: nil, mark: nil)
+      # search shows beside its name then ("(bad schema)"). +entry+ is the
+      # Registry entry of a tool the index's own groups list (nil for a
+      # source's). A blank +acts_as+ raises ArgumentError: no rule could
+      # match the tool's calls.
+      Tool = Data.define(:group, :name, :description, :schema, :acts_as, :refusal, :mark, :entry) do
+        def initialize(group:, name:, acts_as:, description: "", schema: nil, refusal: nil, mark: nil, entry: nil)
           raise ArgumentError, "tool #{group}/#{name}: acts_as is blank" if acts_as.to_s.strip.empty?
 
           super(group: group.to_s, name: name.to_s, description: description.to_s,
                 schema: schema || { "type" => "object", "properties" => {} }, acts_as: acts_as.to_s,
-                refusal: refusal, mark: mark)
+                refusal: refusal, mark: mark, entry: entry)
         end
 
         def full_name = "#{group}/#{name}"
@@ -160,6 +177,13 @@ module Samagotchi
 
       def initialize
         @sources = []
+        # The Registry #declare registered in: the chi group reads it.
+        @registry = nil
+        # The source groups' lines in the search tool's description, as
+        # #declare found them (#find_description).
+        @described = [].freeze
+        @dropped = []
+        @dropped_mutex = Mutex.new
       end
 
       # A new source, not in the index yet (Plugin::Api#commit! #add's it).
@@ -172,16 +196,33 @@ module Samagotchi
 
       def sources = @sources.dup
 
-      # Every source's groups, now.
-      def groups = @sources.flat_map(&:groups)
+      # Every group, now: the index's own (#registry_groups), then the
+      # sources'. A source group with a reserved name, or one an earlier
+      # group has, is left out of search, lookup and the description (said
+      # once per name: a source publishes after load too).
+      def groups
+        own = registry_groups
+        taken = own.map(&:name) | RESERVED_GROUPS
+        kept = @sources.flat_map(&:groups).select do |group|
+          why = if RESERVED_GROUPS.include?(group.name) then "reserved"
+                elsif taken.include?(group.name) then "taken by another group"
+                end
+          dropped(group.name, why) if why
+          taken << group.name unless why
+          why.nil?
+        end
+        own + kept
+      end
 
       # Register the search and call tools in +registry+, once, after the
-      # plugins load: nothing without a source. A name another tool has is
-      # left out (a line in +failures+).
+      # plugins load (or without them: the built-ins a toolkit leaves out
+      # are reachable either way); +registry+ declares them per toolkit
+      # (Registry::Index). A name another tool has is left out (a line in
+      # +failures+).
       # @return [Array<String>] the names registered
       def declare(registry, failures: nil)
-        return [] if @sources.empty?
-
+        @registry = registry
+        @described = description_lines(groups.reject { |group| own?(group) }).freeze
         specs = [find_spec, call_spec]
         declared = specs.filter_map do |spec|
           if (taken = registry[spec.name])
@@ -190,13 +231,24 @@ module Samagotchi
             next
           end
 
-          registry.register(spec.name, source: SOURCE, **spec.entry_fields(nil))
+          unwrap = (->(call, layers) { unwrap(call, layers) } if spec.name == CALL_NAME)
+          registry.register(spec.name, source: SOURCE, unwrap: unwrap, **spec.entry_fields(nil))
           spec
         end
-        names = declared.map(&:name)
-        tokens = declared.sum { |spec| ToolIndex.spec_tokens(spec) }
-        @sources.each { |source| source.declared!(names, tokens) }
-        names
+        registry.index = Registry::Index.new(source: SOURCE, call_name: CALL_NAME, sourced: !@sources.empty?)
+        declared!(declared)
+        declared.map(&:name)
+      end
+
+      # The search tool's description again for the Registry's toolkit now
+      # (ToolkitBinding#apply!, at a turn's start): its chi line follows the
+      # toolkit, the source groups' are the ones #declare found.
+      def refresh!
+        entry = @registry && @registry[FIND_NAME]
+        return unless entry&.source == SOURCE
+
+        entry.schema = entry.schema.merge(description: find_description)
+        declared!([find_spec, call_spec].select { |spec| @registry[spec.name]&.source == SOURCE })
       end
 
       # A checked tool declaration's (Plugin::ToolSpec) definition as
@@ -217,49 +269,35 @@ module Samagotchi
       end
 
       # The search tool's description: how to use it, and one line per
-      # group from what is known when it is declared (a first-run server's:
-      # its name, and its summary if it has one). Never every tool: knowing
-      # the names, a model searches less and guesses arguments.
+      # group from what was known when it was declared (a first-run
+      # server's: its name, and its summary if it has one). Never every
+      # tool: knowing the names, a model searches less and guesses
+      # arguments.
       def find_description
-        lines = groups.map do |group|
-          count = group.callable.size
-          line = "- #{group.name}"
-          line += ": #{group.summary}" if group.summary
-          line += " (#{count} tool#{"s" unless count == 1})" unless group.tools.empty?
-          line
-        end
-        "Search the tools of the MCP servers below by keywords. It answers up to #{FIND_RESULTS} tools, each with " \
-          "its name (<server>/<tool>) and inputSchema; call one with #{CALL_NAME}. An empty query lists every tool's " \
-          "name.\nServers:\n#{lines.join("\n")}"
+        "Search tools this session doesn't declare, by keywords. It answers up to #{FIND_RESULTS} tools, each with " \
+          "its name (<group>/<tool>) and inputSchema; call one with #{CALL_NAME}. An empty query lists every tool's " \
+          "name.\nGroups:\n#{(description_lines(registry_groups) + @described).join("\n")}"
       end
 
       # ── Search ──────────────────────────────────────────────────────────
 
       # The search tool: the best matches with their schemas, or with an
-      # empty query every group's tool names.
-      def find(query, only = nil)
-        all = groups
-        searched = all
-        if only && !only.strip.empty?
-          searched = all.select { |group| group.name == only.strip }
-          return "Error: no MCP server #{only.strip}. Servers: #{all.map(&:name).join(", ")}" if searched.empty?
-        end
-        return names_text(searched) if words(query).empty?
-
-        matches = ranked(query, searched.flat_map(&:tools)).take(FIND_RESULTS)
-        return "No MCP tool matches \"#{query.strip}\".\n\n#{names_text(searched)}" if matches.empty?
-
-        blocks = matches.map { |tool| match_text(tool, all) }
-        unsearched = searched.filter_map { |group| "#{group.name} #{group.note}" if group.tools.empty? && group.note }
-        blocks << "Not searched: #{unsearched.join("; ")}." unless unsearched.empty?
-        "Call one with #{CALL_NAME}(tool: \"<server>/<tool>\", args: {…}).\n\n#{blocks.join("\n\n")}"
+      # empty query every group's tool names. +server+ is the parameter's
+      # name before it was +group+: a model that still gives it is told
+      # every group was searched.
+      def find(query, only = nil, server: nil)
+        answer = find_in(query, only)
+        return answer unless (only.nil? || only.strip.empty?) && !server.to_s.strip.empty?
+
+        "(searched every group)\n#{answer}"
       end
 
       # ── The call ────────────────────────────────────────────────────────
 
       # A call of the tool +name+ names, with +args+ typed by its schema,
       # run by its source. It fails closed: a tool that isn't the one
-      # guardrails were given (#claimed) is refused.
+      # guardrails were given (#claimed) is refused, and so is one of the
+      # index's own (a built-in runs as itself, #unwrap, or not at all).
       def call(name, args)
         tool = lookup(name)
         return tool if tool.is_a?(String)
@@ -270,10 +308,35 @@ module Samagotchi
 
         inner = inner_args(args, tool)
         return "Error: args must be an object.#{ToolIndex.schema_note(tool)}" unless inner
+        return "Error: #{tool.full_name} can't be called through #{CALL_NAME} here" if tool.entry
 
         source_of(tool.group).run(tool, inner)
       end
 
+      # The built-in a call_tool +call+ names, as the call that runs in its
+      # place (ToolRunner#run's first step, before the guardrail gate):
+      # built from its arguments as a direct call would be
+      # (BuiltinCalls.build), with via: "call_tool". The name is a chi tool
+      # (a bare one only while the toolkit reaches it), or chi/<built-in>
+      # for any registered built-in: one the toolkit removes or declares
+      # is then refused by its name before the gate (ToolRunner#left_out?),
+      # with no hook or card. Nil, so the call runs as call_tool, when the
+      # turn under +layers+ doesn't offer call_tool, for an MCP tool, a miss
+      # or arguments that aren't an object.
+      # @return [Hash, nil]
+      def unwrap(call, layers = [])
+        return nil unless @registry&.offered(CALL_NAME, layers: layers)
+
+        args = call[:args].is_a?(Hash) ? call[:args] : {}
+        name = args["tool"].to_s.strip
+        tool = lookup_quietly(name)
+        entry = tool&.entry || builtin_named(name)
+        return nil unless entry
+
+        inner = inner_args(args["args"], tool)
+        inner && BuiltinCalls.build(entry.name, inner).merge(via: CALL_NAME)
+      end
+
       # The call tool's activity row: <group>/<tool> and its arguments.
       def call_preview(args)
         tool = lookup_quietly(args["tool"].to_s)
@@ -302,21 +365,101 @@ module Samagotchi
       def find_spec
         Plugin::ToolSpec.build(FIND_NAME, find_description, params: FIND_PARAMS,
                                                            preview: lambda { |args|
-                                                             [args["query"].to_s.strip, args["server"] && "in #{args["server"]}"].compact.join(" ")
+                                                             [args["query"].to_s.strip, args["group"] && "in #{args["group"]}"].compact.join(" ")
                                                            }) do |args, _ctx|
-          find(args["query"].to_s, args["server"])
+          find(args["query"].to_s, args["group"], server: args["server"])
         end
       end
 
       def call_spec
-        Plugin::ToolSpec.build(CALL_NAME, CALL_DESCRIPTION, params: CALL_PARAMS, label: @sources.first.label,
+        Plugin::ToolSpec.build(CALL_NAME, CALL_DESCRIPTION, params: CALL_PARAMS, label: @sources.first&.label,
                                                            preview: ->(args) { call_preview(args) },
                                                            targets: ->(args) { call_targets(args) }) do |args, _ctx|
           call(args["tool"].to_s, args["args"])
         end
       end
 
-      def source_of(group) = @sources.find { |source| source.groups.any? { |g| g.name == group } }
+      # The source whose group +group+ is: nil for the index's own (a
+      # reserved name).
+      def source_of(group)
+        return nil if RESERVED_GROUPS.include?(group)
+
+        @sources.find { |source| source.groups.any? { |g| g.name == group } }
+      end
+
+      def find_in(query, only)
+        all = groups
+        searched = all
+        if only && !only.strip.empty?
+          searched = all.select { |group| group.name == only.strip }
+          return "Error: no group #{only.strip}. Groups: #{all.map(&:name).join(", ")}" if searched.empty?
+        end
+        return names_text(searched) if words(query).empty?
+
+        matches = ranked(query, searched.flat_map(&:tools)).take(FIND_RESULTS)
+        return "No tool matches \"#{query.strip}\".\n\n#{names_text(searched)}" if matches.empty?
+
+        blocks = matches.map { |tool| match_text(tool, all) }
+        unsearched = searched.filter_map { |group| "#{group.name} #{group.note}" if group.tools.empty? && group.note }
+        blocks << "Not searched: #{unsearched.join("; ")}." unless unsearched.empty?
+        "Call one with #{CALL_NAME}(tool: \"<group>/<tool>\", args: {…}).\n\n#{blocks.join("\n\n")}"
+      end
+
+      # What the sources hear of the declared tools (/mcp's last line).
+      def declared!(specs)
+        names = specs.map(&:name)
+        tokens = specs.sum { |spec| ToolIndex.spec_tokens(spec) }
+        @sources.each { |source| source.declared!(names, tokens) }
+      end
+
+      def own?(group) = RESERVED_GROUPS.include?(group.name)
+
+      # The registered built-in chi/<name> names, reachable or not.
+      def builtin_named(name)
+        return nil unless name.start_with?("#{CHI_GROUP}/")
+
+        entry = @registry[name.delete_prefix("#{CHI_GROUP}/")]
+        entry if entry&.core?
+      end
+
+      # The index's own groups: chi, the built-ins the Registry's toolkit
+      # leaves out but reaches (none: no group). Each tool's schema is its
+      # registered entry's (a config's execute description included), and
+      # it acts as itself.
+      # @return [Array<Group>]
+      def registry_groups
+        names = @registry ? @registry.reachable_names : []
+        return [] if names.empty?
+
+        tools = names.map do |name|
+          entry = @registry[name]
+          schema = ToolDeclarations.chat_schemas([entry.schema]).first
+          Tool.new(group: CHI_GROUP, name: name, acts_as: name, description: schema[:description].to_s,
+                   schema: JSON.parse(JSON.generate(schema[:parameters])), entry: entry)
+        end
+        [Group.new(name: CHI_GROUP, summary: CHI_SUMMARY, tools: tools)]
+      end
+
+      # One line per group in the search tool's description: its name, its
+      # summary and how many tools it can call.
+      def description_lines(groups)
+        groups.map do |group|
+          count = group.callable.size
+          line = "- #{group.name}"
+          line += ": #{group.summary}" if group.summary
+          line += " (#{count} tool#{"s" unless count == 1})" unless group.tools.empty?
+          line
+        end
+      end
+
+      # Say once per name that a source's group was left out (#groups).
+      def dropped(name, why)
+        first = @dropped_mutex.synchronize { @dropped.include?(name) ? false : (@dropped << name) }
+        return unless first
+
+        Log.warn(:plugins, "tool_group_dropped", group: name, why: why,
+                                                 msg: "tool group #{name} is left out of the tool index: #{why}")
+      end
 
       # One match: its name, why it can't be called (if so), its
       # description and schema.
@@ -335,7 +478,7 @@ module Samagotchi
           head = [group.name, group.note].compact.join(" ")
           names.empty? ? head : "#{head}: #{names.join(", ")}"
         end
-        "MCP tools by server (call one as <server>/<tool>; search for its inputSchema):\n#{lines.join("\n")}"
+        "Tools by group (call one as <group>/<tool>; search for its inputSchema):\n#{lines.join("\n")}"
       end
 
       # +tools+ that share a word with +query+, best first: a word scores
@@ -389,7 +532,7 @@ module Samagotchi
 
         same = all.flat_map(&:tools).select { |t| t.acts_as == name }
         return same.first if same.size == 1
-        return "Error: #{name} names #{same.map(&:full_name).join(" and ")}; call one as <server>/<tool>" if same.size > 1
+        return "Error: #{name} names #{same.map(&:full_name).join(" and ")}; call one as <group>/<tool>" if same.size > 1
 
         # A name with a group's <group>/ waits for that group only; any
         # other name (an acts_as) for every one starting.
@@ -404,9 +547,9 @@ module Samagotchi
         return "Error: MCP server #{failed.name} didn't start: #{failed.error}" if failed
 
         closest = ranked(name, all.flat_map(&:tools)).take(CLOSEST)
-        return "Error: no MCP tool #{name}. Search with #{FIND_NAME}." if closest.empty?
+        return "Error: no tool #{name}. Search with #{FIND_NAME}." if closest.empty?
 
-        "Error: no MCP tool #{name}. Closest: #{closest.map(&:full_name).join(", ")}"
+        "Error: no tool #{name}. Closest: #{closest.map(&:full_name).join(", ")}"
       end
 
       # #lookup's tool, without waiting for a start: nil on a miss.
@@ -417,17 +560,25 @@ module Samagotchi
 
       # The acts_as and label +name+ stands for, from the name alone:
       # <group>/<tool> of a known group (the one that has the tool, else the
-      # first whose name it starts with), its source naming the acts_as; or
-      # a bare name with a source's prefix as it is (no label). Nil for
+      # first whose name it starts with), its source naming the acts_as; a
+      # bare name of one of the index's own tools (it acts as itself); or a
+      # bare name with a source's prefix as it is (no label). Nil for
       # anything else.
       # @return [Array(String, String), Array(String, nil), nil]
       def claimed(name)
         all = groups
+        if (own = all.select { |g| own?(g) }.find { |g| g.tools.any? { |t| t.acts_as == name } })
+          return [name, "#{own.name}: #{name}"]
+        end
+
         named = all.select { |group| name.start_with?("#{group.name}/") }
         group = named.find { |g| g.tools.any? { |t| t.name == name.delete_prefix("#{g.name}/") } } || named.first
         if group
           rest = name.delete_prefix("#{group.name}/")
-          [source_of(group.name).acts_as(group.name, rest), "#{group.name}: #{rest}"]
+          # A group of the index's own has no source: its tools act as
+          # themselves.
+          source = source_of(group.name)
+          [source ? source.acts_as(group.name, rest) : rest, "#{group.name}: #{rest}"]
         elsif @sources.any? { |source| source.prefix && name.start_with?(source.prefix) }
           [name, nil]
         end

data/lib/samagotchi/version.rb

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

data/lib/samagotchi/web/app.rb

@@ -799,16 +799,16 @@ module Samagotchi
                                                        cwd: session.working_directory),
           failed_turn: failed_turn_for(session, raw_messages),
           current_turn: current_turn,
-          queued: turn_snapshot ? Array(turn_snapshot["queued"]) : [],
+          queued: snapshot_list(turn_snapshot, "queued"),
           # Commands waiting for the running turn's end (their bubbles).
-          queued_commands: turn_snapshot ? Array(turn_snapshot["queued_commands"]) : [],
+          queued_commands: snapshot_list(turn_snapshot, "queued_commands"),
           recap: turn_snapshot && turn_snapshot["recap"],
           saved_recap: saved_recap_for(id, session, turn_snapshot),
           continue_offer: turn_snapshot && turn_snapshot["continue_offer"],
           guardrail_warning: turn_snapshot && turn_snapshot["guardrail_warning"],
           plugin_warning: turn_snapshot && turn_snapshot["plugin_warning"],
           # Plugins' slow setup still running (chi.init): the page's init row.
-          init_tasks: turn_snapshot ? Array(turn_snapshot["init_tasks"]) : [],
+          init_tasks: snapshot_list(turn_snapshot, "init_tasks"),
           cards: cards_for_display(live_or_saved(turn_snapshot, "cards") { saved_cards(id) }),
           # The composer's / autocomplete; the built-ins until a worker
           # names its plugins' too.
@@ -826,6 +826,10 @@ module Samagotchi
         error_response(404, "not_found", e.message)
       end
 
+      # A list in the worker's turn +snapshot+ (queued prompts, commands,
+      # init tasks); [] without a worker.
+      def snapshot_list(snapshot, key) = Array(snapshot&.[](key))
+
       # A live worker's +key+ as its reading (+live+: a snapshot, a tail)
       # says it, nil included; without a worker (+live+ nil) the block's,
       # the server's own reading of the saved session. A nil value from a
@@ -902,17 +906,18 @@ module Samagotchi
         turn_id = nil if turn_id.empty?
         tail = live_tail(id, turn_id: turn_id)
         state = tail && tail["session_state_snapshot"]
-        if state.is_a?(Hash)
-          session_json = { id: id, status: state["status"], used_memory_names: Array(state["used_memory_names"]),
-                           prompt_notes: Array(state["prompt_notes"]) }
+        state = nil unless state.is_a?(Hash)
+        if state
+          status, used, notes = state.values_at("status", "used_memory_names", "prompt_notes")
           messages = last_assistant_for_display([tail["answer"]].compact)
         else
           session = @session_class.load(id, state_dir: default_state_dir)
-          state = nil
-          session_json = { id: id, status: displayed_status(session), used_memory_names: Array(session.used_memory_names),
-                           prompt_notes: session.prompt_notes.map(&:to_h) }
+          status = displayed_status(session)
+          used = session.used_memory_names
+          notes = session.prompt_notes.map(&:to_h)
           messages = last_assistant_for_display(session.messages, turn_id: turn_id, cwd: session.working_directory)
         end
+        session_json = { id: id, status: status, used_memory_names: Array(used), prompt_notes: Array(notes) }
         live_metrics = state && state["metrics"]
         # Without recent=1: a tab opened before this release (it replaces its
         # timing with the reply's). Remove this branch after the next release.

data/lib/samagotchi/web/message_parts.rb

@@ -10,6 +10,7 @@ require_relative "../image_store"
 require_relative "../llm_context_edit"
 require_relative "../token_usage"
 require_relative "../row_refs"
+require_relative "../tool_output_cut"
 
 module Samagotchi
   module Web
@@ -50,7 +51,8 @@ module Samagotchi
       # so an output that holds the joiner itself stays whole.
       JOINER_BEFORE_TAG = /\n\n---\n\n(?=\[)/
       # The row shows 300 chars and the rest on hover; a read of a big file
-      # would otherwise ride along with every reload.
+      # would otherwise ride along with every reload. A longer one keeps its
+      # head and tail (ToolOutputCut.preview).
       OUTPUT_MAX = 2000
 
       QWEN_THINK = %r{<think>(.*?)</think>}m
@@ -234,16 +236,19 @@ module Samagotchi
       # +tool_id+: its output's ToolIds id, with its ✂ mark in +marks+.
       def tool_part(call, output, registry, shown = nil, images = nil, label: nil, diff: nil, refs: nil, cwd: nil,
                     tool_id: nil, marks: {})
+        # A built-in reached through call_tool reloads as that built-in's
+        # row, with via (its saved params and label are the built-in's).
+        call = Tools::BuiltinCalls.unwrap_saved(call, output)
         name = call[:name].to_s
         params = shown.is_a?(String) ? shown : ToolActivity.tool_activity_params(name, call, registry: registry)
         part = { tool: name, params: params.to_s }
-        # Its row fields (ToolRowFields: title, called_as, view, ref), built from the saved
+        # Its row fields (ToolRowFields: title, called_as, via, view, ref), built from the saved
         # call (never saved themselves), so older sessions get them too. The
-        # saved call is rebuilt by BuiltinCalls, which sets called_as again.
+        # saved call is rebuilt by BuiltinCalls, which sets called_as and via again.
         part.merge!(ToolRowFields.for(name, call, cwd: cwd))
         part[:label] = label if label.is_a?(String) && !label.empty?
         unless output.nil?
-          part[:output] = output.length > OUTPUT_MAX ? output[0, OUTPUT_MAX] : output
+          part[:output] = ToolOutputCut.preview(output, cap: OUTPUT_MAX, tool: name)
           part[:output_truncated] = true if output.length > OUTPUT_MAX
         end
         shots = Array(images).select { |image| image.is_a?(Hash) }

data/lib/samagotchi/web/public/activity.js

@@ -40,6 +40,8 @@ export function newActivity() {
 //     it in place of the params when there is one.
 //   called_as: the name the model called the tool by when it was an
 //     alias's ("bash" run as execute); the row says so.
+//   via: the tool it was reached through ("call_tool": a built-in the
+//     session's toolkit doesn't declare); the row says so.
 //   view: the call's full arguments for the expanded row and the hovers
 //     (the server's ToolView: an execute/task_create's command, its cwd).
 //   ref: what the row traces to (the server's FileRef: {kind: "file",
@@ -48,7 +50,7 @@ export function newActivity() {
 //   refs: a plugin tool's refs (the server's RowRefs: [{kind, target,
 //     label?, actions}]): the first on the row's title, the others in its
 //     menu (refs.js bindRowRefs).
-export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as"]);
+export const ACTIVITY_FIELDS = Object.freeze(["title", "called_as", "via"]);
 export const EVENT_FIELDS = Object.freeze(["view", "ref", "refs"]);
 const ROW_FIELDS = Object.freeze([...ACTIVITY_FIELDS, ...EVENT_FIELDS]);