insika 0.9.0 → 1.0.1

data/lib/insika/studio/views/tools.erb

@@ -1,44 +1,59 @@
-<%# Tools — miller columns: [data tools + agents] master |
-    agent tool matrix in a turbo-frame. Master rows for agents frame-navigate
-    (?a=) with the URL advancing; data-tool rows keep full-page navigation to
-    their standalone editor. @sel_agent (from ?a=) drives the detail. %>
-<%# Roda renders with plain locals — no local_assigns hash (Rails-ism). %>
+<%# Tools — the catalog, as miller columns: every tool in the master (grouped by
+    origin, searchable, with how many agents can call it) | the detail in a
+    turbo-frame: a data tool's editor, or a read-only card for code and MCP
+    tools. Which agent may call what lives on the agent (its Tools tab).
+    @detail: nil (landing) | :edit (data-tool editor) | :info (read-only card). %>
 <% frame_only = defined?(frame_only) && frame_only %>
 <% unless frame_only %>
+<header class="page-head">
+  <h1>Tools<span class="sub">Every tool agents can call — edit HTTP tools, see who uses each one</span></h1>
+</header>
 <div class="drill" data-controller="list-filter">
   <aside class="drill-pane drill-master">
     <div class="drill-pane-head">
-      <div class="title"><strong>Tools <span class="count"><%= @tools.size %></span></strong></div>
-      <a class="btn primary btn-sm" href="/studio/tools/def/new">+ data tool</a>
+      <div class="title"><strong>Tools <span class="count" data-list-filter-target="count"><%= @tools.size %></span></strong></div>
+      <a class="btn primary btn-sm" href="/studio/tools/def/new" data-turbo-frame="tool-detail" data-turbo-action="advance">+ New tool</a>
     </div>
     <div class="drill-search">
-      <input type="search" class="filter-input" placeholder="Filter agents…" aria-label="Filter agents"
+      <input type="search" class="filter-input" placeholder="Search tools…" aria-label="Search tools"
              data-list-filter-target="query" data-action="input->list-filter#filter keydown->list-filter#clear">
+      <label class="switch" title="show only tools no agent can call">
+        <input type="checkbox" id="only-unused">
+        <span class="switch-track" aria-hidden="true"></span>
+        <span class="switch-label">only unused</span>
+      </label>
     </div>
-    <nav class="drill-pane-body drill-list" aria-label="tools and agents" data-controller="active-link">
-      <% unless @data_tool_names.empty? %>
-        <div class="drill-group-label">Data tools · HTTP, editable</div>
-        <% @data_tool_names.sort.each do |name| %>
-          <% dropped = @dropped_tool_names.include?(name) %>
-          <a class="drill-item drill-item-sm" href="/studio/tools/def/<%= Rack::Utils.escape(name) %>"
-             <%== %( title="its definition is invalid — no agent can call it until it is fixed") if dropped %>>
-            <div class="drill-item-name"><span class="txt" title="<%= name %>"><%= name %></span><span class="pill plain">data</span><% if dropped %> <span class="pill locked">dropped</span><% end %></div>
-          </a>
-        <% end %>
+    <nav class="drill-pane-body drill-list" aria-label="tools" data-controller="active-link">
+      <% @tool_groups.each do |label, tools| %>
+        <details class="drill-group" data-list-filter-target="group"<%== " open" unless label.start_with?("MCP") %>>
+          <summary class="drill-group-label"><%= label %> <span class="count"><%= tools.size %></span></summary>
+          <% tools.each do |t| %>
+            <% data = @data_tool_names.include?(t.name) %>
+            <% users = @tool_reach[t.name].size %>
+            <a class="drill-item drill-item-sm<%== ' active' if @selected == t.name %>"
+               href="/studio/tools/<%= data ? "def" : "info" %>/<%= Rack::Utils.escape(t.name) %>"<%== " data-unused" if users.zero? %>
+               data-turbo-frame="tool-detail" data-turbo-action="advance"
+               data-list-filter-target="item" data-filter-text="<%= "#{t.name} #{label}" %>"
+               data-active-link-target="item" data-action="click->active-link#select" title="<%= t.description %>">
+              <div class="drill-item-name"><span class="txt"><%= t.name %></span><% if data %><span class="pill plain">data</span><% end %><span class="pill <%= users.zero? ? "warn" : "plain" %>"><%= users %> <%= users == 1 ? "agent" : "agents" %></span></div>
+            </a>
+          <% end %>
+        </details>
       <% end %>
-      <div class="drill-group-label">Agents · allow / deny</div>
-      <% @agents.each do |a| %>
-        <a class="drill-item<%== ' active' if @sel_agent && @sel_agent.id == a.id %>"
-           href="/studio/tools?a=<%= Rack::Utils.escape(a.id) %>"
-           data-turbo-frame="tool-detail" data-turbo-action="advance"
-           data-list-filter-target="item" data-filter-text="<%= a.id %>"
-           data-active-link-target="item" data-action="click->active-link#select">
-          <div class="drill-item-name"><span class="txt" title="<%= a.id %>"><%= a.id %></span>
-            <span class="pill plain"><%= a.tools_allow.nil? ? "all" : "#{tools_on_count(a, @tools)}/#{@tools.size}" %></span>
-          </div>
-        </a>
+      <% if @dropped_tool_names.any? %>
+        <details class="drill-group" data-list-filter-target="group" open>
+          <summary class="drill-group-label">Invalid definitions <span class="count"><%= @dropped_tool_names.size %></span></summary>
+          <% @dropped_tool_names.sort.each do |name| %>
+            <a class="drill-item drill-item-sm" href="/studio/tools/def/<%= Rack::Utils.escape(name) %>"
+               data-turbo-frame="tool-detail" data-turbo-action="advance"
+               data-list-filter-target="item" data-filter-text="<%= name %>"
+               title="its definition is invalid — no agent can call it until it is fixed">
+              <div class="drill-item-name"><span class="txt"><%= name %></span><span class="pill locked">dropped</span></div>
+            </a>
+          <% end %>
+        </details>
       <% end %>
-      <div class="empty" data-list-filter-target="empty" hidden>No agents match your filter.</div>
+      <div class="empty" data-list-filter-target="empty" hidden>No tools match your search.</div>
     </nav>
   </aside>
 <% end %>
@@ -47,54 +62,28 @@
       <% if flash["error"] %><div class="flash err" role="alert"><%= flash["error"] %></div><% end %>
       <% if flash["notice"] %><div class="flash ok" role="status"><%= flash["notice"] %></div><% end %>
     <% end %>
-    <% if @sel_agent.nil? %>
-      <div class="drill-empty">
-        <div>
-          <h2>Tools</h2>
-          <p>Pick an agent to set which tools it can call — or edit a data tool on the left. <strong>all</strong> = open allowlist (every tool flows through); a <span class="pill locked">locked</span> tool is on the denylist (deny always wins).</p>
-        </div>
-      </div>
-    <% else %>
-      <% a = @sel_agent %>
+    <% case @detail %>
+    <% when :edit %>
+      <%== render("_tool_edit") %>
+    <% when :info %>
+      <% t = @info_tool %>
       <div class="drill-pane-head">
         <div class="title">
-          <strong class="mono"><%= a.id %></strong>
+          <strong class="mono"><%= t.name %></strong>
+          <span class="count"><%= @info_label %></span>
         </div>
-        <button type="submit" form="tools-form" class="btn primary" data-turbo-submits-with="Saving…">Save tools</button>
       </div>
-      <div class="drill-pane-body" data-controller="toggle-counter">
-        <div class="matrix-topline">
-          <span class="count-badge mono" data-toggle-counter-target="count"><%= a.tools_allow.nil? ? "all" : "#{tools_on_count(a, @tools)}/#{@tools.size} on" %></span>
-          <label class="switch" title="open allowlist — every tool flows through">
-            <input type="checkbox" name="all_tools" value="1" form="tools-form"<%== " checked" if a.tools_allow.nil? %>
-                   data-toggle-counter-target="all" data-action="change->toggle-counter#update">
-            <span class="switch-track" aria-hidden="true"></span>
-            <span class="switch-label">all tools</span>
-          </label>
-          <button type="button" class="btn ghost btn-sm" data-action="click->toggle-counter#selectNone"
-                  title="uncheck every tool (deny-all — Save tools to apply)">none</button>
+      <div class="drill-pane-body">
+        <p><%= t.description %></p>
+        <p class="muted"><%= t.plugin.to_s.start_with?("mcp:") ? "Comes from an MCP server; edit the server under MCP." : "Built into the engine; it cannot be edited here." %></p>
+        <%== render("_tool_users", locals: { name: t.name }) %>
+      </div>
+    <% else %>
+      <div class="drill-empty">
+        <div>
+          <h2>Tools</h2>
+          <p>Pick a tool to see which agents can call it. HTTP tools open their editor; MCP and built-in tools are read-only. Which tools an agent may call is set on the agent, in its <strong>Tools</strong> tab.</p>
         </div>
-        <p class="muted">Checked tools are allowed next turn. A <span class="pill locked">locked</span> tool is on the denylist — deny always wins, so it can't be granted here.</p>
-        <form id="tools-form" method="post" action="/studio/tools/<%= Rack::Utils.escape(a.id) %>">
-          <%== csrf_tag %>
-          <% if @tools.empty? %>
-            <p class="muted">No tools registered in the runtime.</p>
-          <% else %>
-            <div class="check-grid tool-grid<%== " is-open" if a.tools_allow.nil? %>" data-toggle-counter-target="grid">
-              <% @tools.each do |t| %>
-                <% denied = tool_denied_for?(a, t.name) %>
-                <label class="check tool-check<%== " locked" if denied %>" title="<%= denied ? "denied — deny wins" : t.description %>">
-                  <input type="checkbox" name="tools[]" value="<%= t.name %>"
-                         <%== " checked" if tool_allowed_for?(a, t.name) && !denied %>
-                         <%== " disabled" if denied %>
-                         data-toggle-counter-target="tool" data-locked="<%= denied %>"
-                         data-action="change->toggle-counter#update">
-                  <span class="mono"><%= t.name %></span><% if @data_tool_names.include?(t.name) %> <span class="pill plain">data</span><% end %><% if denied %> <span class="pill locked">locked</span><% end %>
-                </label>
-              <% end %>
-            </div>
-          <% end %>
-        </form>
       </div>
     <% end %>
   </turbo-frame>

data/lib/insika/task_actor.rb

@@ -41,8 +41,11 @@ module Insika
     end
 
     # Runs the block on an Async fiber CHILD of the parent. Returns the Task.
+    # The fiber yields nil: Async keeps a finished task linked to the siblings that
+    # follow it (List#remove! leaves `tail`), so one stale reference to an old turn
+    # keeps every later one reachable — with its result, unless the result is nil.
     def run(&turn_block)
-      @async_task = @parent.async { turn_block.call(self) }
+      @async_task = @parent.async { turn_block.call(self); nil }
     end
 
     # Drains the mailbox WITHOUT blocking (boundaries). `:cancel` raises (the top

data/lib/insika/task_store.rb

@@ -117,6 +117,48 @@ module Insika
       to_task(record)
     end
 
+    # -> Task; begin_execution + the move to :running in ONE write and one
+    # transaction (the dispatch claim, like transition). Only queued, paused and
+    # waiting move to :running; any other status (a recovered orphan already
+    # :running) keeps its own, exactly as the two separate calls did.
+    def start_execution(id)
+      @store.transaction do
+        record = fetch!(id)
+        raise ArgumentError, "an open Execution already exists on task #{id}" if open_execution(record)
+
+        record["status"] = "running" if %w[queued paused waiting].include?(record["status"])
+        record["executions"] += [{ "attempt" => record["executions"].size + 1, "started_at" => timestamp,
+                                   "finished_at" => nil, "outcome" => nil, "error" => nil }]
+        record["updated_at"] = timestamp
+        @store.set(SCOPE, key_for(id), record)
+        to_task(record)
+      end
+    end
+
+    # -> Task; finish_execution + transition(to: outcome) in ONE write and one
+    # transaction. ArgumentError (nothing written) for no open Execution or an
+    # invalid transition.
+    def complete_execution(id, outcome:)
+      target = outcome.to_sym
+      raise ArgumentError, "invalid status: #{outcome}" unless STATUSES.include?(target)
+
+      @store.transaction do
+        record = fetch!(id)
+        open = open_execution(record)
+        raise ArgumentError, "no open Execution on task #{id}" if open.nil?
+
+        from = record["status"].to_sym
+        raise ArgumentError, "invalid transition: #{from} -> #{target}" unless TRANSITIONS.fetch(from).include?(target)
+
+        open["finished_at"] = timestamp
+        open["outcome"] = target.to_s
+        record["status"] = target.to_s
+        record["updated_at"] = timestamp
+        @store.set(SCOPE, key_for(id), record)
+        to_task(record)
+      end
+    end
+
     # -> Task; closes the current Execution. ArgumentError if none is open.
     # Does NOT touch status (that is transition's job).
     def finish_execution(id, outcome:)
@@ -189,6 +231,20 @@ module Insika
     def queued = with_status(:queued)
 
     # -> enumerates ids without the "task:" prefix; without a block returns an Enumerator.
+    # -> [Task] every record, from ONE bulk read of the backend (see
+    # Store#entries) instead of a read per id.
+    def all
+      @store.entries(SCOPE, KEY_PREFIX).map { |_, record| to_task(record) }
+    end
+
+    # -> [Task] one page, most recently written first (every status change
+    # rewrites the task, so this is "most recently updated"). Reads only the page.
+    def recent(limit, offset: 0)
+      # offset only when paging: a backend written for the 3-argument #recent keeps working
+      rows = offset.zero? ? @store.recent(SCOPE, KEY_PREFIX, limit) : @store.recent(SCOPE, KEY_PREFIX, limit, offset)
+      rows.map { |_, record| to_task(record) }
+    end
+
     def each_id
       return enum_for(:each_id) unless block_given?
 
@@ -201,7 +257,17 @@ module Insika
     # tasks go with it, terminal tasks only (a live :running task must never
     # be deleted under its own fiber).
     def delete(id)
-      @store.delete(SCOPE, key_for(id))
+      @store.transaction do
+        # Read the task first: the trace recorders read it before writing, so on a
+        # backend that locks per key read this orders a purge against them.
+        @store.get(SCOPE, key_for(id))
+        @store.list(ModelMetricsStore::SCOPE, ModelMetricsStore.task_prefix(id)).each do |key|
+          @store.delete(ModelMetricsStore::SCOPE, key)
+        end
+        @store.delete(LLMTraceStore::SCOPE, id.to_s)
+        @store.delete(ModelMetricsStore::TURN_SCOPE, id.to_s)
+        @store.delete(SCOPE, key_for(id))
+      end
     end
 
     private

data/lib/insika/telemetry/pricing.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require_relative "../env_schema"
 
 module Insika
   module Telemetry
@@ -22,9 +23,9 @@ module Insika
     # nothing is emitted and the dashboard shows a gap instead of a lie.
     #
     # Token accounting (matches `Executor#usage_of`, which mirrors the providers):
-    # `cached_tokens` is a SUBSET of `input_tokens`, `cache_creation_tokens` is not.
-    #   - `cached_input` given -> cached tokens are billed at that rate and
-    #     subtracted from the fresh input; absent -> they stay at the input rate.
+    # All buckets are disjoint, matching RubyLLM::Tokens.
+    #   - `cached_input` given -> cached tokens are billed at that rate;
+    #     absent -> they use the input rate.
     #   - `cache_write` given -> cache-creation tokens billed at that rate; absent
     #     -> at the input rate (they are input tokens the provider did write).
     class Pricing
@@ -47,21 +48,22 @@ module Insika
 
         rate = rate_for(usage[:model]) or return nil
 
-        input   = usage[:input_tokens].to_i
-        cached  = usage[:cached_tokens].to_i
-        written = usage[:cache_creation_tokens].to_i
-        output  = usage[:output_tokens].to_i
+        buckets = [[usage[:input_tokens], rate["input"]],
+                   [usage[:output_tokens], rate["output"]],
+                   [usage[:cached_tokens], rate["cached_input"] || rate["input"]],
+                   [usage[:cache_creation_tokens], rate["cache_write"] || rate["input"]]]
+        return nil if buckets.all? { |count, _| count.nil? }
+        return nil if buckets.any? { |count, price| count.to_i.positive? && price.nil? }
 
-        cached_rate = rate["cached_input"]
-        fresh = cached_rate ? [input - cached, 0].max : input
-
-        millionths = fresh * rate["input"].to_f +
-                     (cached_rate ? cached * cached_rate.to_f : 0.0) +
-                     written * (rate["cache_write"] || rate["input"]).to_f +
-                     output * rate["output"].to_f
+        millionths = buckets.sum { |count, price| count.to_i * price.to_f }
         (millionths / 1_000_000.0).round(PRECISION)
       end
 
+      # The operator's table from INSIKA_MODEL_PRICING (empty when unset): the ONE
+      # cost rule Studio, traces and metrics share — the cost the provider library
+      # reported, and these rates only for what it could not price.
+      def self.from_env(env = ENV) = parse(Insika::EnvSchema.read("INSIKA_MODEL_PRICING", env))
+
       # Parses the operator's table. Accepts a JSON object; anything else (blank,
       # malformed, not an object) -> an EMPTY Pricing, never an exception: telemetry
       # config must not be able to stop a boot.

data/lib/insika/telemetry/recorder.rb

@@ -18,8 +18,8 @@ module Insika
     # a deliberate LOW-CARDINALITY subset of the span attributes — never task_id or
     # session_id. `meter:` nil -> spans only (the metrics SDK is optional).
     #
-    # `pricing:` nil -> no cost attribute/metric. Cost is an ESTIMATE from an
-    # operator-declared rates table (see Pricing) — the engine ships no prices.
+    # Native attempt-time cost is the default. An operator-declared rates table
+    # can override it with a negotiated-price estimate (see Pricing).
     #
     # PURE/testable: talks to a DUCK-TYPED `tracer` (start_span/set_attribute/
     # record_error/finish) and `meter` (create_counter/create_histogram -> add/
@@ -29,7 +29,7 @@ module Insika
     # Robust: `record` NEVER raises (telemetry doesn't bring down a turn). Timestamps
     # come from each event's `meta.at` (spans reconstructed with real time).
     class Recorder
-      Turn = Struct.new(:span, :tools, :labels, :start) # tools = FIFO queue of open tools
+      Turn = Struct.new(:span, :tools, :labels, :start, :requests, :requests_truncated) # tools = FIFO queue of open tools
       OpenTool = Struct.new(:span, :name, :start)
 
       # Ceiling of open turns: a kill -9 without a terminal event would leave the turn
@@ -41,9 +41,11 @@ module Insika
       # renaming one breaks every dashboard built on it.
       class Instruments
         attr_reader :turns, :turn_duration, :tokens, :cost, :tool_calls, :tool_duration,
-                    :cache_hit_rate, :loop_intervened, :context_compacted, :tool_blocked
+                    :cache_hit_rate, :loop_intervened, :context_compacted, :tool_blocked, :confirmations, :llm_attempts, :llm_failures
 
         def initialize(meter)
+          @llm_attempts = meter.create_counter("insika.llm.attempts", unit: "{attempt}", description: "Native model attempts")
+          @llm_failures = meter.create_counter("insika.llm.failures", unit: "{attempt}", description: "Failed native model attempts")
           @turns = meter.create_counter("insika.turns", unit: "{turn}",
                                                         description: "Turns completed, by outcome")
           @turn_duration = meter.create_histogram("insika.turn.duration", unit: "s",
@@ -62,6 +64,8 @@ module Insika
                                                                                  description: "Loop-detector warnings delivered to the model")
           @tool_blocked = meter.create_counter("insika.tool.blocked", unit: "{call}",
                                                description: "Tool calls blocked before execution")
+          @confirmations = meter.create_counter("insika.confirmation", unit: "{hold}",
+                                                description: "Calls held for the customer's confirmation, by outcome")
           @context_compacted = meter.create_counter("insika.context.compacted", unit: "{compaction}",
                                                                                 description: "In-session compactions persisted (RFC-0044)")
         end
@@ -79,11 +83,16 @@ module Insika
         data = event.data || {}
         case event.type
         when :task_started   then start_turn(meta, data)
+        when :llm_request, :llm_usage then model_event(meta, data, event.type)
         when :tool_call      then start_tool(meta, data)
         when :tool_result    then finish_tool(meta)
         when :data_tool_call then point_tool(meta, data)
         when :tool_loop_intervened then count_loop(meta, data)
         when :tool_blocked then count_blocked(meta, data)
+        when :confirmation_requested then count_confirmation(meta, data, "requested")
+        when :confirmation_confirmed then count_confirmation(meta, data, "confirmed")
+        when :confirmation_cancelled then count_confirmation(meta, data, "cancelled")
+        when :confirmation_expired then count_confirmation(meta, data, "expired")
         when :context_compacted then count_compaction(data)
         when :task_completed then finish_turn(meta, data, :ok)
         when :task_failed    then finish_turn(meta, data, :error)
@@ -108,7 +117,7 @@ module Insika
           "insika.turn", parent: nil, start_time: at,
           attributes: labels.merge(attrs("insika.task_id" => id, "insika.session_id" => meta[:session_id]))
         )
-        @turns[id] = Turn.new(span, [], labels, at)
+        @turns[id] = Turn.new(span, [], labels, at, [], false)
       end
 
       def start_tool(meta, data)
@@ -147,11 +156,80 @@ module Insika
         at = ts(meta[:at])
         usage = data[:usage]
         set_usage(turn.span, usage)
+        rerank_cost = rerank_cost(turn)
+        if rerank_cost
+          turn.span.set_attribute("insika.cost.rerank_usd", rerank_cost)
+          chat_cost = estimated_cost(usage)
+          turn.span.set_attribute("insika.cost.total_usd", chat_cost + rerank_cost) if chat_cost
+        end
         turn.span.set_attribute("insika.status", status.to_s)
-        turn.span.record_error(data[:message].to_s) if status == :error
+        turn.span.record_error(exception_class(data[:error])) if status == :error
+        finish_requests(turn)
         turn.tools.each { |t| t.span.finish(end_time: at) } # orphans (failure mid-way)
         turn.span.finish(end_time: at)
-        count_turn(turn, usage, status.to_s, elapsed(turn.start, at))
+        count_turn(turn, usage, status.to_s, elapsed(turn.start, at), rerank_cost)
+      end
+
+      def rerank_cost(turn)
+        return nil if turn.requests_truncated
+
+        requests = turn.requests.select { |entry| entry["type"] == "llm_request" && entry["operation"] == "rerank" }
+        attempts = turn.requests.select { |entry| entry["type"] == "llm_usage" && entry["operation"] == "rerank" }
+        return nil if attempts.empty? || attempts.any? { |entry| !entry["cost"].is_a?(Numeric) }
+        return nil if requests.any? { |request| attempts.none? { |entry| entry["request_id"] == request["request_id"] } }
+
+        attempts.sum { |entry| entry["cost"] }
+      end
+
+      def exception_class(value)
+        value.is_a?(String) && value.match?(/\A[A-Z]\w*(?:::[A-Z]\w*)*\z/) ? value[0, 256] : "Task failed"
+      end
+
+      def model_event(meta, data, type)
+        turn = @turns[meta[:task_id]] or return
+        entry = LLMTraceStore.sanitize(data.merge("type" => type.to_s, "at" => meta[:at]))
+        turn.requests << entry
+        if turn.requests.size > LLMTraceStore::MAX_PER_TASK
+          turn.requests.shift
+          turn.requests_truncated = true
+        end
+        return unless @instruments && type == :llm_usage
+
+        labels = turn.labels.merge(attrs("insika.model" => entry["model"], "insika.provider" => entry["provider"],
+                                          "insika.operation" => entry["operation"], "insika.status" => entry["status"]))
+        @instruments.llm_attempts.add(1, attributes: labels)
+        @instruments.llm_failures.add(1, attributes: labels) if entry["status"] == "failed"
+      end
+
+      # Success usage can arrive after request completion. Reconstruct at the turn
+      # terminal, so exported spans include late usage without modifying closed spans.
+      def finish_requests(turn)
+        turn.span.set_attribute("insika.llm.truncated", true) if turn.requests_truncated
+        turn.requests.group_by { |entry| entry["request_id"] }.each do |id, entries|
+          next if id.nil? || id.empty?
+          request = entries.find { |entry| entry["type"] == "llm_request" }
+          next unless request && request["duration_ms"]
+
+          at = ts(request["at"])
+          next unless at
+          attempts = entries.select { |entry| entry["type"] == "llm_usage" }
+          attributes = attrs("insika.llm.request_id" => id, "insika.model" => request["model"],
+            "insika.provider" => request["provider"], "insika.operation" => request["operation"],
+            "insika.status" => request["status"], "insika.llm.duration_ms" => request["duration_ms"],
+            "insika.llm.truncated" => turn.requests_truncated,
+            "insika.llm.attempts" => attempts.size, "insika.llm.failures" => attempts.count { |e| e["status"] == "failed" })
+          attempts.each_with_index do |attempt, index|
+            (%w[status] + LLMTraceStore::NUMBER_FIELDS - %w[turn duration_ms]).each do |key|
+              attributes["insika.llm.attempt.#{index + 1}.#{key}"] = attempt[key] unless attempt[key].nil?
+            end
+          end
+          span = @tracer.start_span("insika.llm.request", parent: turn.span,
+            start_time: at - request["duration_ms"] / 1000.0, attributes: attributes)
+          span.record_error(exception_class(request["exception_class"])) if request["status"] == "failed"
+          span.finish(end_time: at)
+        rescue StandardError
+          # A failed exporter must not prevent remaining requests or the turn closing.
+        end
       end
 
       def set_usage(span, usage)
@@ -164,13 +242,14 @@ module Insika
         span.set_attribute("insika.tokens.cache_creation", usage[:cache_creation_tokens]) if usage[:cache_creation_tokens]
         span.set_attribute("insika.model", usage[:model].to_s) if usage[:model]
         span.set_attribute("insika.model_source", usage[:model_source].to_s) if usage[:model_source]
+        span.set_attribute("insika.provider", usage[:provider].to_s) if usage[:provider]
         cost = estimated_cost(usage)
         span.set_attribute("insika.cost.usd", cost) if cost
       end
 
       # --- metrics (no-op when no meter was injected) ------------------------
 
-      def count_turn(turn, usage, status, seconds)
+      def count_turn(turn, usage, status, seconds, rerank_cost = nil)
         return unless @instruments
 
         model = usage && usage[:model]
@@ -178,6 +257,7 @@ module Insika
         @instruments.turns.add(1, attributes: labels)
         @instruments.turn_duration.record(seconds, attributes: labels) if seconds
         count_usage(turn, usage)
+        @instruments.cost.add(rerank_cost, attributes: turn.labels.merge("insika.operation" => "rerank")) if rerank_cost
         count_cache_hit(turn, usage)
       end
 
@@ -209,6 +289,17 @@ module Insika
         @instruments.loop_intervened.add(1, attributes: labels)
       end
 
+      # One counter for the whole life of a customer hold; `outcome` tells the
+      # four moments apart, so requested minus the other three is what is open.
+      def count_confirmation(meta, data, outcome)
+        return unless @instruments
+
+        turn = @turns[meta[:task_id]]
+        labels = (turn ? turn.labels : {}).merge(attrs("insika.tool" => data[:tool]&.to_s,
+                                                       "insika.outcome" => outcome))
+        @instruments.confirmations.add(1, attributes: labels)
+      end
+
       def count_blocked(meta, data)
         return unless @instruments
 
@@ -250,7 +341,9 @@ module Insika
         @instruments.tool_duration.record(seconds, attributes: labels) if seconds
       end
 
-      def estimated_cost(usage) = @pricing&.cost(usage)
+      # Turn usage arrives already priced per response (Executor#usage_of applies
+      # the same rule), so its cost_usd wins; the table covers usage that was not.
+      def estimated_cost(usage) = usage&.fetch(:cost_usd, nil) || @pricing&.cost(usage)
 
       # -----------------------------------------------------------------------
 
@@ -260,6 +353,7 @@ module Insika
 
         turn.tools.each { |t| t.span.finish(end_time: nil) }
         turn.span.set_attribute("insika.status", "abandoned")
+        finish_requests(turn)
         turn.span.finish(end_time: nil)
         count_turn(turn, nil, "abandoned", nil)
       end

data/lib/insika/telemetry/ruby_llm_instrumenter.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Insika
+  module Telemetry
+    # One instance belongs to one chat context, never to a graph or current fiber.
+    class RubyLLMInstrumenter
+      def initialize(emit:, delegate: nil, operation: nil, model: nil, pricing: nil)
+        @emit, @delegate, @operation, @model, @pricing = emit, delegate, operation, model, pricing
+      end
+
+      def instrument(name, payload = {}, &block)
+        return chat(payload, &block) if name == "chat.ruby_llm" && block
+        return request(payload, &block) if name == "request.ruby_llm" && block
+
+        result = delegate(name, payload, &block)
+        record(:llm_usage, payload) if name == "usage.ruby_llm"
+        result
+      end
+
+      private
+
+      def chat(payload, &block)
+        previous_model, previous_request = @model, @request_id
+        @model, @request_id = scalar(payload[:model]), nil
+        delegate("chat.ruby_llm", payload, &block)
+      ensure
+        @model, @request_id = previous_model, previous_request
+      end
+
+      def request(payload, &block)
+        @request_id = SecureRandom.uuid
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        error = nil
+        begin
+          delegate("request.ruby_llm", payload, &block)
+        rescue Exception => error # Preserve cancellation and the original model exception too.
+          raise
+        ensure
+          record(:llm_request, payload, error: error,
+            duration_ms: (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000)
+        end
+      end
+
+      # Host notifications still wrap the operation. A broken subscriber must not
+      # retry the model, replace its result, or swallow/replace its exception.
+      def delegate(name, payload, &block)
+        return block&.call(payload) unless @delegate.respond_to?(:instrument)
+
+        called = false
+        result = error = nil
+        operation = proc do |*args|
+          called = true
+          begin
+            result = block.call(*args)
+          rescue Exception => caught
+            error = caught
+            raise
+          end
+        end
+        begin
+          block ? @delegate.instrument(name, payload, &operation) : @delegate.instrument(name, payload)
+        rescue StandardError
+          # Telemetry is best effort; the operation's outcome is authoritative.
+        end
+        raise error if error
+        return unless block
+
+        called ? result : block.call(payload)
+      end
+
+      def record(type, payload, error: nil, duration_ms: nil)
+        data = {
+          "operation" => scalar(payload[:operation] || @operation),
+          "provider" => scalar(payload[:provider]),
+          "model" => scalar(payload[:model] || @model),
+          "status" => type == :llm_request ? (error ? "failed" : "succeeded") : scalar(payload[:status]),
+          "request_id" => @request_id
+        }
+        if type == :llm_request
+          data["duration_ms"] = duration_ms
+          data["exception_class"] = error.class.name if error
+        else
+          %i[input output cache_read cache_write thinking].each do |field|
+            value = payload[:tokens]&.public_send(field)
+            data["#{field}_tokens"] = value.is_a?(Numeric) ? value : nil
+          end
+          value = payload[:cost]&.total
+          value = priced(data) unless value.is_a?(Numeric)
+          data["cost"] = value.is_a?(Numeric) ? value : nil
+        end
+        @emit.call(type, data)
+      rescue StandardError
+        nil
+      end
+
+      # The operator's rates fill in only what the library could not price (Pricing.from_env).
+      def priced(data)
+        @pricing&.cost(model: data["model"], input_tokens: data["input_tokens"],
+                       output_tokens: data["output_tokens"], cached_tokens: data["cache_read_tokens"],
+                       cache_creation_tokens: data["cache_write_tokens"])
+      end
+
+      def scalar(value)
+        value.to_s if value.is_a?(String) || value.is_a?(Symbol)
+      end
+    end
+  end
+end