activeagent 1.9.2 → 1.9.4

data/lib/active_agent/evals/report_html.rb

@@ -5,10 +5,15 @@ require "cgi"
 module ActiveAgent
   module Evals
     # Report#to_html: the run as one self-contained page on the dashboard's
-    # design system (DesignTokens) — inline styles, no scripts, no external
-    # assets — so a run's outcome can be archived next to a CI run or handed
-    # to a teammate, and so the dashboard can serve the same page for a
-    # persisted run.
+    # design system (DesignTokens) — inline styles, no external assets — so a
+    # run's outcome can be archived next to a CI run or handed to a teammate,
+    # and so the dashboard can serve the same page for a persisted run.
+    #
+    # Its one inline script (COPY_SCRIPT) backs the "Copy as Markdown"
+    # buttons: the whole report, the verdict, What to fix (for the model the
+    # filter shows), each fix card and each scenario. The Markdown each copies
+    # is ReportMarkdown's, embedded in a hidden textarea, so the page copies
+    # exactly what the dashboard and the CLI write.
     #
     # Same content as Report#to_markdown, laid out the way the dashboard's
     # suite card is: header and stat tiles, the MODELS panel with the judge's
@@ -50,6 +55,8 @@ module ActiveAgent
           #{html_footer}
           </section>
           </main>
+          #{markdown_store("md-report", to_markdown)}
+          <script>#{COPY_SCRIPT}</script>
           </body>
           </html>
         HTML
@@ -237,7 +244,7 @@ module ActiveAgent
 
         <<~HEADER
           <header>
-          <h1>#{h(title)}</h1>
+          <div class="title-row"><h1>#{h(title)}</h1>#{copy_button('md-report', label: 'Copy as Markdown', title: 'Copy the whole report as GitHub-flavored Markdown')}</div>
           <div class="chips">#{chips.join}</div>
           </header>
         HEADER
@@ -320,7 +327,8 @@ module ActiveAgent
 
         <<~PANEL
           <div class="panel">
-          <div class="panel-head"><span class="micro">Models</span><span class="right">judged by #{h(judged_by)}</span></div>
+          <div class="panel-head"><span class="micro">Models</span><span class="right">judged by #{h(judged_by)}</span>#{copy_button('md-verdict', title: 'Copy the verdict and the model comparison as Markdown')}</div>
+          #{markdown_store('md-verdict', verdict_markdown)}
           #{html_comparison_table if comparing?}
           #{html_intervals}
           #{blocks.join}
@@ -612,12 +620,13 @@ module ActiveAgent
         expects = scenario.expected_tools.any? ? %(<span class="exp">expects <b>#{h(scenario.expected_tools.join(' or '))}</b></span>) : ""
         labels = @models.map(&:label)
         cards = cohort.sort_by { |result| labels.index(result.label) || labels.size }.map { |result| html_result_card(result) }
+        md_id = "md-#{anchor(scenario)}"
 
         <<~BLOCK
           <div id="#{h(anchor(scenario))}">
           <details>
           <summary><span class="chev">&gt;</span><span class="key">#{h(scenario.key)}</span><span class="prompt">#{h(scenario.prompt)}</span>#{expects}</summary>
-          <div class="drill">#{cards.join}</div>
+          <div class="drill">#{cards.join}<div class="drill-copy">#{copy_button(md_id, title: "Copy #{scenario.key} as Markdown")}#{markdown_store(md_id, scenario_markdown(scenario.key, answer_limit: ANSWER_LIMIT))}</div></div>
           </details>
           </div>
         BLOCK
@@ -670,14 +679,16 @@ module ActiveAgent
                "#{plural(faulted.map { |result| result.scenario.key }.uniq.size, 'scenario')}"
         body =
           if items.any?
-            %(<div class="fixes">#{items.map { |item| html_fix_card(item) }.join}</div>)
+            %(<div class="fixes">#{items.each_with_index.map { |item, index| html_fix_card(item, index) }.join}</div>)
           else
             %(<div class="nothing">[+] nothing to fix</div>)
           end
 
         <<~FIXES
           <section class="section fix-section" aria-label="Recommendations">
-          <div class="section-head"><span class="micro">What to fix</span><span class="meta">#{h(meta)}</span></div>
+          <div class="section-head"><span class="micro">What to fix</span><span class="meta">#{h(meta)}</span>#{copy_button('md-fixes', model_filtered: comparing? && items.any?, title: 'Copy What to fix as Markdown, for the model the filter shows')}</div>
+          #{markdown_store('md-fixes', fix_items_markdown)}
+          #{@models.each_index.map { |index| markdown_store("md-fixes-m#{index}", fix_items_markdown(model: @models[index].label)) }.join if comparing? && items.any?}
           #{html_fix_filter(items) if comparing? && items.any?}
           #{body}
           </section>
@@ -706,7 +717,7 @@ module ActiveAgent
         labels.filter_map { |label| (index = @models.index(model_by_label(label))) && "m#{index}" }.join(" ")
       end
 
-      def html_fix_card(item)
+      def html_fix_card(item, index)
         tone = item["kind"] == "instruction" ? "info" : "error"
         glyph = tone == "info" ? "[i]" : "[!]"
         title = fault_name(item["fault"]) + (item["count"].to_i > 1 ? " ×#{item['count']}" : "")
@@ -719,6 +730,7 @@ module ActiveAgent
         parts << html_fix_server(item["server"]) if item["server"]
         parts << %(<div class="note">#{h(item['note'])}</div>) if item["note"].present?
         parts << html_fix_action(item["action"]) if item["action"]
+        parts << %(<div class="fix-copy">#{copy_button("md-fix-#{index}", title: 'Copy this fix as Markdown')}#{markdown_store("md-fix-#{index}", fix_item_markdown(item))}</div>)
         models = fix_model_tokens(item)
         %(<div class="fix"#{%( data-models="#{models}") if models.present?}>#{parts.join}</div>)
       end
@@ -771,6 +783,19 @@ module ActiveAgent
         "#{scenarios} · #{models}"
       end
 
+      # --- Copy as Markdown -------------------------------------------------
+
+      # A button COPY_SCRIPT answers by copying the textarea +id+ names; with
+      # +model_filtered+, the one for the model the fix filter has checked.
+      def copy_button(id, label: "Copy as Markdown", title: nil, model_filtered: false)
+        %(<button type="button" class="copy-md" data-md="#{h(id)}"#{' data-md-model' if model_filtered}) +
+          %(#{%( title="#{h(title)}") if title}>#{h(label)}</button>)
+      end
+
+      def markdown_store(id, markdown)
+        %(<textarea class="md-store" id="#{h(id)}" hidden readonly>#{h(markdown)}</textarea>)
+      end
+
       # --- footer ----------------------------------------------------------
 
       # The run's terms: the judge, the criteria and the pass mark, what it
@@ -804,6 +829,48 @@ module ActiveAgent
 
       # Colors only through the token variables; radii 4 badges · 6 chips ·
       # 8 controls · 10 nested panels · 12 cards · 999 bars; no shadows.
+      # Copies the Markdown a button names: the async Clipboard API where the
+      # page may use it, else a selected textarea and the copy command, which
+      # still works on an http:// host and in the dashboard's frame.
+      COPY_SCRIPT = <<~JS.gsub(/\n\s*/, "").freeze
+        document.addEventListener("click", function (event) {
+          var button = event.target.closest && event.target.closest("button.copy-md");
+          if (!button) return;
+          event.preventDefault();
+          var id = button.getAttribute("data-md");
+          if (button.hasAttribute("data-md-model")) {
+            var picked = document.querySelector('input[name="fix-model"]:checked');
+            if (picked && picked.value !== "all") id += "-" + picked.value;
+          }
+          var store = document.getElementById(id);
+          if (!store) return;
+          var text = store.value;
+          var label = button.getAttribute("data-label") || button.textContent;
+          button.setAttribute("data-label", label);
+          var done = function (ok) {
+            button.textContent = ok ? "Copied" : "Copy failed";
+            setTimeout(function () { button.textContent = label; }, 1500);
+          };
+          var legacy = function () {
+            var area = document.createElement("textarea");
+            area.value = text;
+            area.style.position = "fixed";
+            area.style.opacity = "0";
+            document.body.appendChild(area);
+            area.select();
+            var ok = false;
+            try { ok = document.execCommand("copy"); } catch (error) {}
+            document.body.removeChild(area);
+            done(ok);
+          };
+          if (navigator.clipboard && navigator.clipboard.writeText) {
+            navigator.clipboard.writeText(text).then(function () { done(true); }, legacy);
+          } else {
+            legacy();
+          }
+        });
+      JS
+
       STYLES = <<~CSS.freeze
         * { box-sizing: border-box; }
         html, body { margin: 0; min-height: 100%; }
@@ -913,6 +980,14 @@ module ActiveAgent
         .action { display: flex; align-items: center; gap: 10px; margin-top: auto; padding-top: 2px; flex-wrap: wrap; }
         .btn { display: inline-block; padding: 6px 12px; border-radius: 8px; font-size: 13px; font-weight: 500; color: var(--color-text-cell); border: 1px solid var(--color-border-strong); background: transparent; white-space: nowrap; }
         .btn:hover { background: var(--color-hover); color: var(--color-text-primary); text-decoration: none; }
+        .copy-md { font-family: var(--font-mono); font-size: 11px; padding: 3px 8px; border-radius: 6px; border: 1px solid var(--color-border); background: transparent; color: var(--color-text-secondary); cursor: pointer; white-space: nowrap; }
+        .copy-md:hover { background: var(--color-hover); color: var(--color-text-primary); }
+        .title-row { display: flex; align-items: center; gap: 12px; flex-wrap: wrap; }
+        .section-head .copy-md, .panel-head .copy-md { margin-left: auto; }
+        .panel-head .right + .copy-md { margin-left: 0; }
+        .drill-copy, .fix-copy { display: flex; justify-content: flex-end; }
+        .drill-copy { grid-column: 1 / -1; }
+        @media print { .copy-md { display: none; } }
         .hint { font-family: var(--font-mono); font-size: 11px; color: var(--color-text-muted); white-space: nowrap; }
         .matrix { border: 1px solid var(--color-border-light); border-radius: 10px; overflow-x: auto; }
         .mx { display: grid; gap: 12px; padding: 10px 12px; border-top: 1px solid var(--color-border-light); }

data/lib/active_agent/evals/report_markdown.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Evals
+    # Report#to_markdown: the run as GitHub-flavored Markdown with the same
+    # content as Report#to_html — the per-model table and the cost, the
+    # verdict with the model comparison, the scenario matrix, every answer
+    # (one `<details>` block per scenario, since GitHub strips the HTML
+    # page's styles), and What to fix from Report#fix_items — so it can be
+    # pasted into a pull request or an issue.
+    #
+    # Each piece is public on its own, for the pieces people paste one at a
+    # time: #fix_item_markdown, #fix_items_markdown (optionally for one
+    # model), #verdict_markdown and #scenario_markdown. The whole report is
+    # built from them, so a piece copied alone reads as it does in the report.
+    #
+    # Table cells escape `|` and fold line breaks; text set inside the HTML
+    # of a `<details>` block escapes `<`, `>` and `&`.
+    module ReportMarkdown
+      # How much of an answer the whole report quotes; a scenario copied on
+      # its own quotes the whole answer.
+      MARKDOWN_ANSWER_LIMIT = 1_500
+
+      def to_markdown
+        lines = [ "# #{markdown_title}", "" ]
+        lines << judged_by_line
+        lines << ""
+        lines.concat(summary_table)
+        lines << ""
+        lines.concat(total_lines)
+        lines.concat(verdict_lines)
+        lines.concat(comparison_lines)
+        lines.concat(matrix_table)
+        lines.concat([ "", "## Answers", "" ])
+        scenario_keys.each { |key| lines << scenario_markdown(key, details: true, answer_limit: MARKDOWN_ANSWER_LIMIT) << "" }
+        lines << fix_items_markdown(heading: "##")
+        "#{lines.join("\n").rstrip}\n"
+      end
+
+      # One fix item (Report#fix_items) as a heading and its body: the fault
+      # and how often, the scenarios and models it covers, the
+      # recommendation, the judge's proposed instruction change as a quote,
+      # the tools involved, the server that serves them, the note and where
+      # in the dashboard the fix lives.
+      def fix_item_markdown(item, heading: "###")
+        item = item.to_h.stringify_keys
+        title = item["fault"].to_s.tr("_", " ") + (item["count"].to_i > 1 ? " ×#{item['count']}" : "")
+        lines = [ "#{heading} #{item['kind'] == 'instruction' ? 'ℹ️' : '❗'} #{title}", "" ]
+
+        scope = [ "Scenarios: #{Array(item['scenario_keys']).map { |key| "`#{key}`" }.join(', ')}" ]
+        scope << "models: #{Array(item['models']).map { |label| "`#{label}`" }.join(', ')}" if Array(item["models"]).any?
+        scope << "judge suggestion" if item["kind"] == "instruction"
+        lines << scope.join(" · ") << ""
+        lines << item["recommendation"].to_s.strip << "" if item["recommendation"].present?
+        lines.concat(quoted(item["quote"]).push("")) if item["quote"].present?
+        tools = Array(item["tools"])
+        if tools.any?
+          lines << "**#{item['tools_label'].presence || 'tools'}:** " + tools.map { |tool| tool_text(tool) }.join(", ")
+          lines << ""
+        end
+        if (server = item["server"])
+          state = server["status"] == "enabled" ? "enabled for #{@agent_name}" : "#{server['status'].presence || 'unknown'} · not enabled for #{@agent_name}"
+          lines << "Served by **#{server['name'].presence || server['key']}** (#{state})" << ""
+        end
+        lines << "_#{item['note'].to_s.strip}_" << "" if item["note"].present?
+        if (action = item["action"])
+          lines << "Fix: #{[ action['label'], action['hint'] ].compact_blank.join(' — ')}" << ""
+        end
+        lines.join("\n").rstrip
+      end
+
+      # What to fix: every fix item, or with +model+ (a model label) the ones
+      # attributed to that model, as the report's model filter shows them.
+      def fix_items_markdown(model: nil, heading: "##")
+        items = fix_items
+        items = items.select { |item| Array(item["models"]).empty? || item["models"].include?(model) } if model.present?
+        lines = [ "#{heading} What to fix#{" for `#{model}`" if model.present?}", "" ]
+        if items.empty?
+          lines << "_Nothing to fix._"
+        else
+          sub = "#{heading}#"
+          lines << items.map { |item| fix_item_markdown(item, heading: sub) }.join("\n\n")
+        end
+        lines.join("\n")
+      end
+
+      # The verdict — the best model, why, and who picked it — then the
+      # per-model table and, comparing models, the comparison with its
+      # intervals.
+      def verdict_markdown(heading: "##")
+        lines = [ "#{heading} Verdict", "", judged_by_line, "" ]
+        lines.concat(verdict_lines)
+        lines.concat(summary_table)
+        lines << ""
+        lines.concat(total_lines)
+        lines.concat(comparison_lines.map { |line| line.start_with?("## ") ? line.sub("## ", "#{heading}# ") : line })
+        lines.join("\n").rstrip
+      end
+
+      # One scenario: its prompt and expectations, a table of each model's
+      # status, score, tool calls, fault and cost, then each model's answer.
+      # With +details+ it is a `<details>` block whose summary names the key,
+      # the prompt and each model's mark, the way the report folds it.
+      # Raises KeyError for a key the report has no result for.
+      def scenario_markdown(key, details: false, answer_limit: nil)
+        cohort = @results.select { |result| result.scenario.key == key.to_s }
+        raise KeyError, "no results for scenario #{key}" if cohort.empty?
+
+        scenario = cohort.first.scenario
+        labels = @models.map(&:label)
+        cohort = cohort.sort_by { |result| labels.index(result.label) || labels.size }
+        body = []
+        body << "**Prompt**" << "" << quoted(scenario.prompt).join("\n") << ""
+        expectations = expectation_lines(scenario)
+        body.concat(expectations).push("") if expectations.any?
+        body << "| Model | Status | Score | Tools | Fault | Cost |" << "|---|---|---|---|---|---|"
+        cohort.each do |result|
+          tools = result.replay.tool_calls.map { |call| "#{call['name']}#{' ✗' if call['error']}" }.join(", ")
+          body << "| #{[ "`#{result.label}`", status_text(result), (result.score ? Format.score(result.score) : '—'), tools.presence || '—',
+                         result.fault&.tr('_', ' ') || '—', (result.replay.cost ? answer_cost(result) : '—') ].map { |text| cell(text) }.join(' | ')} |"
+        end
+        body << ""
+        cohort.each do |result|
+          body << "**`#{result.label}`** — #{status_text(result)}"
+          body << ""
+          body << "Fault: #{result.fault.tr('_', ' ')} — #{[ result.summary, result.recommendation ].compact.join(' ')}" << "" if result.fault
+          body << "Error: #{result.replay.error}" << "" if result.replay.error
+          answer = result.replay.answer.to_s
+          answer = answer.truncate(answer_limit) if answer_limit
+          body << (answer.present? ? quoted(answer).join("\n") : "_(no answer)_") << ""
+        end
+        text = body.join("\n").rstrip
+        return "### Scenario `#{scenario.key}`\n\n#{text}" unless details
+
+        marks = cohort.map { |result| "#{status_mark(result)} #{result.label}" }.join(" · ")
+        summary = "<code>#{html_text(scenario.key)}</code> #{html_text(scenario.prompt.truncate(80))} — #{html_text(marks)}"
+        "<details>\n<summary>#{summary}</summary>\n\n#{text}\n\n</details>"
+      end
+
+      private
+
+      def markdown_title
+        scenarios = scenario_keys.size
+        "Evaluation — #{scenarios} scenario#{'s' unless scenarios == 1} × #{@models.size} model#{'s' unless @models.size == 1}"
+      end
+
+      def scenario_keys
+        @results.map { |result| result.scenario.key }.uniq
+      end
+
+      def judged_by_line
+        label = @judge_label || @judge&.label
+        label ? "Judged by `#{label}`." : "No judge; scored on rules and expectations alone."
+      end
+
+      # "**Best model: gpt-5-mini**" with the verdict's rationale under it
+      # and, when a judge (not the pass-rate ranking) wrote it, who did.
+      def verdict_lines
+        return [] unless winner
+
+        lines = [ "**Best model: #{winner}**", "" ]
+        rationale = verdict["rationale"].to_s.strip
+        judge = verdict["judge"].presence
+        rationale += " _(#{judge == Report::PASS_RATE_JUDGE ? 'ranked by pass rate' : "judged by #{judge}"})_" if judge && rationale.present?
+        lines << rationale << "" if rationale.present?
+        lines
+      end
+
+      def expectation_lines(scenario)
+        lines = []
+        lines << "Expects tools: #{scenario.expected_tools.map { |name| "`#{name}`" }.join(' or ')}" if scenario.expected_tools.any?
+        lines << "Expects the answer to contain: #{scenario.expected_patterns.map { |text| "`#{text}`" }.join(', ')}" if scenario.expected_patterns.any?
+        lines << "Expects the answer not to contain: #{scenario.forbidden_patterns.map { |text| "`#{text}`" }.join(', ')}" if scenario.forbidden_patterns.any?
+        lines.map { |line| "- #{line}" }
+      end
+
+      def status_mark(result)
+        result.passed? ? "✅" : (result.errored? ? "⚠️" : "❌")
+      end
+
+      def status_text(result)
+        "#{status_mark(result)} #{result.status}"
+      end
+
+      def tool_text(tool)
+        tool = tool.is_a?(Hash) ? tool.stringify_keys : { "name" => tool.to_s }
+        note = tool["note"].presence
+        "`#{tool['name']}`#{" (#{note})" if note}"
+      end
+
+      # Each line of +text+ as a blockquote line, `<` and `>` escaped so an
+      # answer cannot open or close the HTML around it.
+      def quoted(text)
+        text.to_s.strip.split(/\r?\n/).map { |line| line.strip.empty? ? ">" : "> #{line.gsub('<', '&lt;').gsub('>', '&gt;')}" }
+      end
+
+      def html_text(text)
+        text.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub(/\s+/, " ")
+      end
+    end
+  end
+end

data/lib/active_agent/evals.rb

@@ -27,6 +27,7 @@ require_relative "evals/judge"
 require_relative "evals/result"
 require_relative "evals/design_tokens"
 require_relative "evals/report_html"
+require_relative "evals/report_markdown"
 require_relative "evals/report"
 require_relative "evals/runner"
 require_relative "evals/correlation"

data/lib/active_agent/inline_preview_interceptor.rb

@@ -28,6 +28,7 @@ module ActiveAgent
     end
 
     def transform! # :nodoc:
+      return context unless context.respond_to?(:html_part)
       return context if html_part.blank?
 
       html_part.body = html_part.decoded.gsub(PATTERN) do |match|

data/lib/active_agent/preview/templates/layouts/active_agent/preview.html.erb

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>ActiveAgent Previews</title>
+  <style>
+    body { color-scheme: light dark; font: 16px/1.5 system-ui, sans-serif; max-width: 1000px; padding: 1rem; margin: auto; }
+    pre { white-space: pre-wrap; overflow-wrap: anywhere; border: 1px solid; border-radius: .25rem; padding: 1rem; }
+    a { text-underline-offset: .2em; }
+  </style>
+</head>
+<body>
+  <nav><%= link_to "All agent previews", rails_agent_previews_path %></nav>
+  <%= yield %>
+</body>
+</html>

data/lib/active_agent/preview/templates/rails/agents/index.html.erb

@@ -0,0 +1,14 @@
+<h1>Agent Previews</h1>
+<% if @previews.empty? %>
+  <p>No previews found. Generate an agent or add an ActiveAgent::Preview subclass under test/agents/previews.</p>
+<% end %>
+<% @previews.each do |preview| %>
+  <section>
+    <h2><%= preview.preview_name %></h2>
+    <ul>
+      <% preview.prompts.each do |prompt| %>
+        <li><%= link_to prompt, rails_agent_preview_path("#{preview.preview_name}/#{prompt}") %></li>
+      <% end %>
+    </ul>
+  </section>
+<% end %>

data/lib/active_agent/preview/templates/rails/agents/preview.html.erb

@@ -0,0 +1,3 @@
+<h1><%= @preview.preview_name %> / <%= @prompt %></h1>
+<p><%= link_to "Download Markdown", "#{download_rails_agent_preview_path("#{@preview.preview_name}/#{@prompt}")}?#{request.query_parameters.to_query}" %></p>
+<pre><%= @content %></pre>

data/lib/active_agent/providers/_base_provider.rb

@@ -132,6 +132,7 @@ module ActiveAgent
                     :stream_broadcaster, :streaming,   # Callback (Streams)
                     :stream_completion_pending,        # Callback (Streams)
                     :stream_completion_result,         # Callback (Streams)
+                    :stream_finish_reason,             # Callback (Streams)
                     :tools_function,                   # Callback (Tools)
                     :usage_stack,                      # Usage Tracking
                     :stream_usage_index,               # Usage Tracking (Streams)
@@ -607,6 +608,7 @@ module ActiveAgent
           messages:,
           raw_request:  prompt_request_type.serialize(request),
           raw_response: api_response,
+          streamed_finish_reason: stream_finish_reason,
           usages: usage_stack,
           **attributes
         )

data/lib/active_agent/providers/anthropic_provider.rb

@@ -237,6 +237,7 @@ module ActiveAgent
         when :message_delta
           delta = Anthropic::Transforms.gem_to_hash(api_response_chunk.delta)
           self.message_stack.last.merge!(delta)
+          self.stream_finish_reason = delta[:stop_reason] if delta[:stop_reason]
 
         # Message Completed [Full Message]
         when :message_stop

data/lib/active_agent/providers/common/responses/base.rb

@@ -63,6 +63,16 @@ module ActiveAgent
           #   @return [Array<Usage>]
           attribute :usages, default: -> { [] }, writable: false
 
+          # @!attribute [r] streamed_finish_reason
+          #   Why a streamed generation stopped, as the provider reported it.
+          #
+          #   A streamed generation has no response body to read it from, so
+          #   the provider records it from the stream. {#finish_reason} falls
+          #   back to it.
+          #
+          #   @return [String, nil]
+          attribute :streamed_finish_reason, writable: false
+
           # Initializes response with deep-duplicated attributes.
           #
           # Deep duplication prevents external modifications from affecting internal state.
@@ -180,14 +190,17 @@ module ActiveAgent
           #   response.stop_reason    #=> "stop" (alias)
           def finish_reason
             @finish_reason ||= begin
-              return nil unless raw_response
+              return streamed_finish_reason unless raw_response
 
               if raw_response.is_a?(Hash)
                 # OpenAI format: choices[0].finish_reason or choices[0].message.finish_reason
                 raw_response.dig(:choices, 0, :finish_reason) ||
                   raw_response.dig(:choices, 0, :message, :finish_reason) ||
                   # Anthropic format: stop_reason
-                  raw_response[:stop_reason]
+                  raw_response[:stop_reason] ||
+                  # OpenAI Responses format: why it was cut short, else its status
+                  raw_response.dig(:incomplete_details, :reason) ||
+                  raw_response[:status]
               end
             end
           end

data/lib/active_agent/providers/common/usage.rb

@@ -335,8 +335,10 @@ module ActiveAgent
           # Detect Ollama by presence of nanosecond duration fields
           if usage.key?(:total_duration)
             from_ollama(usage_hash)
-          # Detect Anthropic by presence of cache_creation or service_tier
-          elsif usage.key?(:cache_creation) || usage.key?(:service_tier)
+          # Detect Anthropic by presence of cache_creation or service_tier, or by its
+          # cache token fields (a usage payload does not always carry the former two)
+          elsif usage.key?(:cache_creation) || usage.key?(:service_tier) ||
+                usage.key?(:cache_read_input_tokens) || usage.key?(:cache_creation_input_tokens)
             from_anthropic(usage_hash)
           # Detect OpenAI Responses API by input_tokens/output_tokens with details
           elsif usage.key?(:input_tokens) && usage.key?(:input_tokens_details)

data/lib/active_agent/providers/open_ai/chat_provider.rb

@@ -117,6 +117,10 @@ module ActiveAgent
             return if api_message.nil?
 
             # If we have a delta, we need to update a message in the stack
+            if (finish_reason = api_message.try(:finish_reason))
+              self.stream_finish_reason = finish_reason.to_s
+            end
+
             message = find_or_create_message(api_message.index)
             message_merge_delta(message, api_message.delta.deep_to_h)
 
@@ -263,6 +267,39 @@ module ActiveAgent
           message_stack.last
         end
 
+        # Finds the streamed tool call an unindexed delta continues
+        #
+        # OpenAI-compatible servers (Gemini's compatibility endpoint, some Ollama
+        # and OpenRouter backends) omit the `index` that ties argument fragments
+        # to their call. A delta carrying an `id` continues the call with that
+        # id; one without an id or a function name continues the last call;
+        # anything else starts a new call.
+        #
+        # @param tool_calls [Array<Hash>] calls accumulated so far
+        # @param delta_item [Hash] unindexed tool call delta
+        # @return [Hash, nil] the call to merge into, or nil for a new call
+        def unindexed_tool_call_target(tool_calls, delta_item)
+          if delta_item[:id].present?
+            tool_calls.find { _1[:id] == delta_item[:id] }
+          elsif delta_item.dig(:function, :name).blank?
+            tool_calls.last
+          end
+        end
+
+        # Strips the fields a server repeats on every fragment (`id`, `type`,
+        # the function name), so merging does not concatenate them.
+        #
+        # @param hash_item [Hash] the call the fragment continues
+        # @param delta_item [Hash] unindexed tool call delta
+        # @return [Hash] the fragment to merge
+        def unindexed_tool_call_fragment(hash_item, delta_item)
+          fragment = delta_item.except(:id, :type)
+          if fragment[:function].is_a?(Hash) && fragment.dig(:function, :name) == hash_item.dig(:function, :name)
+            fragment = fragment.merge(function: fragment[:function].except(:name))
+          end
+          fragment
+        end
+
         # Recursively merges delta changes into a hash structure
         #
         # Handles complex delta merging for OpenAI's streaming API, including
@@ -285,6 +322,8 @@ module ActiveAgent
                   else
                     hash[key] << delta_item
                   end
+                elsif key == :tool_calls && delta_item.is_a?(Hash) && (hash_item = unindexed_tool_call_target(hash[key], delta_item))
+                  hash_merge_delta(hash_item, unindexed_tool_call_fragment(hash_item, delta_item))
                 else
                   hash[key] << delta_item
                 end

data/lib/active_agent/providers/open_ai/responses_provider.rb

@@ -181,6 +181,9 @@ module ActiveAgent
             # usage from, so it is recorded from the final event.
             record_stream_usage(api_response_event.response.usage)
 
+            response = api_response_event.response
+            self.stream_finish_reason = (response.incomplete_details&.reason || response.status).to_s
+
             # Completion, tool loop included, runs from stream_finished! once
             # the stream has drained, so each turn's tool calls run once.
             self.stream_completion_pending = true

data/lib/active_agent/providers/opper/_types.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/chat/_types"
+require_relative "options"
+
+module ActiveAgent
+  module Providers
+    module Opper
+      # ActiveModel type for casting and serializing Opper requests.
+      #
+      # Opper is OpenAI-compatible, so requests use the same shape as the
+      # OpenAI Chat API. This delegates entirely to OpenAI::Chat::RequestType.
+      RequestType = ActiveAgent::Providers::OpenAI::Chat::RequestType
+    end
+  end
+end

data/lib/active_agent/providers/opper/options.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../open_ai/options"
+
+module ActiveAgent
+  module Providers
+    module Opper
+      # Configuration options for the Opper provider.
+      #
+      # Extends OpenAI::Options, overriding the base URL to point at Opper's
+      # OpenAI-compatible gateway and resolving the API key from OPPER_API_KEY.
+      # Opper does not use organization or project identifiers.
+      #
+      # @example Basic configuration
+      #   options = Options.new(api_key: ENV["OPPER_API_KEY"])
+      #
+      # @see https://docs.opper.ai
+      # @see https://platform.opper.ai Opper API Keys
+      class Options < ActiveAgent::Providers::OpenAI::Options
+        # @!attribute base_url
+        #   @return [String] API endpoint (default: "https://api.opper.ai/v3/compat")
+        attribute :base_url, :string, as: "https://api.opper.ai/v3/compat"
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["OPPER_API_KEY"]
+        end
+
+        # Not used as part of Opper
+        def resolve_organization_id(kwargs) = nil
+        def resolve_project_id(kwargs)      = nil
+      end
+    end
+  end
+end