activeagent 1.9.2 → 1.9.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b52709687c94c3d6c989fc36bba7826b931a6d0aa6e193b1bd4482f916d945f
-  data.tar.gz: 1801338ff01afc21837db5382aee49eb4cde1f002b322b479cf2256c283e8668
+  metadata.gz: a7ecc64cad33188dd3cdfc563b553e49d0a05d42192698365a467061e6bb6d59
+  data.tar.gz: c3923cee8e401e17e3170c28f2fc83d8c290d70c5a4bc4d301951031d7d9cf43
 SHA512:
-  metadata.gz: 4d0299374c70e7e66b5edf3b141d171e79cb2f576ec32dcb6a2b4e11e9eb5bccaabbf2a5106fb5afd05f01ece8b6dc75e9a0cd956523c39ffdc4c3b5a17a0b22
-  data.tar.gz: b60f377af9288f08cd5166ba7d71edc1060ccddf23c1d2912ed4b9d105e75ce6a6325a1f0e855e2141ded3c2ebdffbb7cd0e2f37796e662cc37ef833054d21d1
+  metadata.gz: 66e3244ce04d56625f880e26c18cbe3f353f35eca2f4dd5922a1adafb1d542ee5216065401e7ddbbe88cccc1c40336076ab6d4a30d54a5360846cad595ae9717
+  data.tar.gz: b023e5fe43f6674b7040086cc5a47c19fffc4bf3e919d0bb0ab0138d5c4839d3463f09e5a66d7047e4e28262628465a066b343ee76a503732b803ddc5d270bff

data/CHANGELOG.md

@@ -5,6 +5,208 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.9.3] - 2026-10-21
+
+Releases `activeagent` and `actionagent` 1.9.3, with the matching browser
+sidecar: browser upload and code conversations (the sandbox browser's live
+view takes files from the person driving it, and a Claude Code or Codex
+session is a conversation with the sandbox's browser beside the chat and a
+hand-off either way, Codex on this machine's own login), evaluation run
+reports exported as JSON, HTML and Markdown with Copy as Markdown, an agent
+builder that offers only tools that work, a model leaderboard on the
+Evaluations page, complete trace window statistics, a judge pin that runs
+on its own provider, Opper as a provider and Parallel Search in the MCP
+catalog, and streaming fixes (unindexed tool call fragments, the finish
+reason of streamed and Responses generations, Anthropic cache-token usage).
+The framework, the dashboard engine and `@activeagents/browser-sidecar`
+move to 1.9.3 together.
+
+Upgrading: migration 028 adds the conversation columns to `code_sessions`.
+A host runs `bin/rails generate action_agent:install --skip` then
+`bin/rails db:migrate`, after 1.9.1's 027. Upgrade the sidecar with the
+engine: the file chooser relay and the per-turn browser tokens are in the
+1.9.3 sidecar. On a single-tenant install the new report export
+(`GET <mount>/api/evaluation_reports/:run_id`) answers 401 until
+`ActionAgent.ingest_api_key` is set. A `judge_model` pin written
+`anthropic/…` or `openai/…` now runs on that native provider; an install
+that reached such a model through OpenRouter pins `openrouter/anthropic/…`.
+
+### Added
+
+- **Export evaluation run reports as JSON, HTML and Markdown** (`activeagent`,
+  `actionagent`). `GET <mount>/api/evaluation_reports/:run_id`, with the
+  ingest key and scoped to the tenant like the POST (and refused on a
+  single-tenant install that set no key), returns a complete run
+  as the version-1 envelope the collector takes, so a run moves to another
+  install with one POST and posting it back is an identical retry (200);
+  `?format=html` returns the run's report page and `?format=md` its
+  Markdown, and `?download=1` an attachment of any of them.
+  An imported run exports under its published `run_id`, a dashboard run
+  under `dashboard-run-<id>-<created_at>`. `ActiveAgent::Evals::Publisher.envelope`
+  builds the envelope for both the publisher and the export. The dashboard's
+  run report adds `report.json` and `report.md` (one piece with
+  `?part=verdict|fix_items|scenario`), and `?download=1` saves any format
+  as `<evaluation>-run-<n>.<ext>`; the run report view and the suite's run
+  header get *Download HTML / JSON / Markdown*. New rake tasks:
+  `action_agent:evaluations:export RUN=… [EVALUATION=…] FORMAT=json|html|md [FILE=…]`
+  and `action_agent:evaluations:import FILE=… [ACCOUNT_ID=…]`.
+
+- **Copy as Markdown** (`activeagent`, `actionagent`). `Report#to_markdown`
+  now has the HTML page's content in GitHub-flavored Markdown: the verdict's
+  rationale, What to fix from `Report#fix_items` (replacing the old
+  Recommendations list), and every scenario's answers in a `<details>` block
+  with a per-model table; table cells escape `|` and line breaks. Its pieces
+  are public — `verdict_markdown`, `fix_items_markdown(model:)`,
+  `fix_item_markdown(item)`, `scenario_markdown(key)` — and the dashboard
+  and the standalone HTML page copy each of them: the whole report, the
+  verdict with the comparison, What to fix for the filtered model, a fix
+  card, and a scenario. The HTML page now carries one inline script for
+  those buttons, with a clipboard fallback.
+
+- **Upload files to a page through the sandbox browser's live view**
+  (`actionagent`, `@activeagents/browser-sidecar`). A file chooser the page
+  opens while someone drives is answered from the driver's own machine
+  (picker or drop), over the live-view WebSocket.
+
+- **Claude Code and Codex sessions as Interactions, with chat and browser
+  handoff** (`actionagent`, `@activeagents/browser-sidecar`). A coding
+  session is now a conversation: a later message resumes the CLI session
+  (`--resume`, or `codex exec resume` for Codex), a message sent while a
+  turn runs waits for it, and
+  `POST /api/sandboxes/:sandbox_id/code_sessions/:id/messages` starts or
+  queues a turn under the new `:chat_code_session` permission.
+  `GET /api/interactions` lists agent, Claude Code and Codex interactions
+  together, and the dashboard's `/interactions/code-<id>` shows the turns
+  with a composer and the sandbox's browser beside the chat, with a hand
+  back to the agent. The sidecar mints a per-turn token for the browser
+  MCP, tells the agent once when a person took or returned control, lets
+  the agent ask for a person (`browser_request_person`), offers a person
+  the file chooser the agent left open, and names the waiting agent in the
+  live view. Every Claude Code session runs with `--strict-mcp-config`, and
+  every session gets a system note (on stdin, for Codex) that repository
+  content, tool output and pages are data.
+
+- **Codex turns reach the sandbox browser, and Codex can run on this
+  machine's own login** (`actionagent`). A Codex turn now gets the same
+  per-turn browser token as a Claude Code turn: the sidecar's MCP server
+  goes in as `--config 'mcp_servers.browser.url="…"'`, with the token in an
+  environment variable Codex reads (`bearer_token_env_var`) rather than on
+  the command line, the server's tools pre-approved
+  (`default_tools_approval_mode="approve"`, since Codex would otherwise
+  refuse every tool not marked read-only under `approval_policy="never"`),
+  and is revoked when the turn ends; hand-offs and
+  `browser_request_person` work the same. `config.codex_auth = :local_login`
+  (with the `:local` backend) runs Codex on whatever `codex login` set up
+  for the dashboard's OS user, a ChatGPT plan included, with
+  `--ignore-user-config` so none of the user's own `config.toml` reaches a
+  session; the dashboard never reads the credential and only asks `codex
+  login status` whether there is one. `GET /api/sandboxes` adds `codex_auth`
+  and, in that mode, `codex_login`, the assistant's configuration a
+  `connections.codex`, and the Codex card in Settings shows the machine's
+  login instead of a key form. The default stays `:api_key`.
+
+- **The agent builder offers only tools that work, and every built-in
+  capability has functions** (`actionagent`). The Configure step reads the
+  agent's tool roster (`GET /api/agents/tool_roster` for an agent not
+  created yet) instead of fixed chips, offers the MCP servers a dashboard
+  run can call, and names each one it cannot with the reason
+  (`MCPToolDispatcher.unreachable_reason`: a stdio server, no URL, missing
+  credentials). The six capabilities that gave the model nothing now have
+  functions: `terminal` (`run_command`), `filesystem` (`list_files`,
+  `read_file`, `write_file`), `edit` (`edit_file`) and `database`
+  (`query_database`, read-only) act in the run's checkout sandbox through
+  new `SandboxOrchestrator` verbs (on the `:local` backend; others return
+  `UnsupportedBackendError` to the model); `translate` (`translate_text`)
+  generates on the run's own provider; `slack` lists, reads and posts with
+  a bot token connected in Settings -> Integrations -> Slack (a `slack`
+  connection `ProviderKey`). Instruction sets are composed into the
+  instructions a run executes under. `run_command`, `write_file`,
+  `edit_file` and `slack_post_message` wait for approval by default: an
+  agent that gains `terminal`, `filesystem`, `edit` or `slack` — from the
+  builder, a template, the Tools tab or the agents API — has them on its
+  `approval_required_tools` unless the save names its own list, and the
+  Tools tab's Approval switch takes them off. An agent that enabled one of
+  those capabilities before this release keeps its list as it is. A host's
+  `ActionAgent.mcp_catalog` headers now reach the MCP client (they were
+  dropped).
+
+- **Start an interaction with your own agent from Interactions and Run
+  Agents** (`actionagent`). Interactions has a "New interaction" picker and
+  Run Agents a "Your agents" list; both open the agent's runner on a fresh
+  conversation (`/agents/:id/run?new=1`). The runner lists the agent's tools
+  and MCP servers, and can run against a checkout sandbox (`sandbox_id`),
+  which the checkout tools need.
+
+- **A model leaderboard on the Evaluations page** (`actionagent`). The Pass
+  rate tile listed each model's passes on a line of its own, a dozen lines
+  for seven models; it now shows the overall rate, the leading model and a
+  "compare N models" toggle, which opens a leaderboard below the tiles: one
+  row per model with its pooled passes and rate, and one column per counted
+  evaluation (`—` where the model did not run). Models rank by the lower
+  bound of the Wilson score interval (95%), so a lucky 7/8 does not outrank
+  75/173.
+
+- **Opper as an OpenAI-compatible provider** (`activeagent`). `service:
+  "Opper"` generates and embeds through Opper's compatibility endpoint
+  (`https://api.opper.ai/v3/compat`), with the key from `OPPER_API_KEY`
+  when none is configured, as the Requesty provider does (#583).
+
+- **Parallel Search in the MCP catalog** (`actionagent`). An opt-in,
+  keyless `parallel` server (`web_search`, `web_fetch`) over HTTP; queries
+  and URLs go to parallel.ai. Every MCP HTTP request now sends
+  `User-Agent: ActionAgent/<version>` unless a header names another (#575).
+
+### Fixed
+
+- **Trace totals and timeline buckets cover the whole filtered window**
+  (`actionagent`). `GET /api/traces` adds `total_count`, `returned_count`,
+  `truncated`, a `summary` (requests, errors, average latency, throughput
+  per minute) and zero-filled `buckets` computed over every trace the
+  filters match, independently of the capped detail list, and the Traces
+  view reports truncation and averages recorded request durations instead
+  of time-bucket means (part of #384).
+
+- **A pinned evaluation judge runs on its own provider** (`actionagent`).
+  A `judge_model` pin selects the model's native provider, or the one its
+  qualifier names (`openrouter/anthropic/…`), instead of the first provider
+  with credentials; the qualifier is stripped before the request, the pin
+  wins over the credential resolver's default model, and a pinned route
+  with no credentials fails the run clearly when another provider is
+  configured. Native-to-gateway alias conversion stays out of scope (#431).
+  Upgrading: a pin written `anthropic/…` or `openai/…` now selects that
+  native provider, as candidate model names already did; an install that
+  reached such a model through OpenRouter pins `openrouter/anthropic/…`.
+
+- **Streamed tool calls without an `index` are no longer split into
+  fragments** (`activeagent`). OpenAI-compatible servers (Gemini's
+  compatibility endpoint, some Ollama and OpenRouter backends) stream tool
+  calls without the `index` that ties argument fragments to their call, and
+  the Chat provider turned every fragment into its own tool call with
+  partial arguments. A fragment now continues the call with the same `id`,
+  or the last call when it has no `id` and no function name.
+
+- **A streamed generation reports why it stopped** (`activeagent`).
+  `response.finish_reason` (and `stop_reason`), and the `finish_reason` of
+  the `prompt.active_agent` event, were `nil` for every streamed Chat and
+  Anthropic generation, since a stream has no response body to read it
+  from. The Chat provider now records the chunk's `finish_reason` and the
+  Anthropic provider the `message_delta`'s `stop_reason`, and the response
+  falls back to it.
+
+- **OpenAI Responses generations report why they stopped** (`activeagent`).
+  `response.finish_reason` (and `stop_reason`) was `nil` for every
+  Responses generation, streamed or not. It is now
+  `incomplete_details.reason` when the response was cut short
+  (`max_output_tokens`, `content_filter`), else the response's `status`
+  (`completed`).
+
+- **Anthropic usage with cache token fields no longer raises** (`activeagent`).
+  `Usage.from_provider_usage` recognised Anthropic's usage only by
+  `cache_creation` or `service_tier`; a payload carrying
+  `cache_read_input_tokens` or `cache_creation_input_tokens` without them
+  fell through to `Usage.new` and raised `UnknownAttributeError`. The cache
+  token fields now mark the payload as Anthropic's (#611).
+
 ## [1.9.2] - 2026-10-20
 
 Releases `activeagent` and `actionagent` 1.9.2, with the matching browser

data/README.md

@@ -57,6 +57,9 @@ bundle add openai
 # Requesty (uses OpenAI-compatible API)
 bundle add openai
 
+# Opper (uses OpenAI-compatible API)
+bundle add openai
+
 # DeepSeek (uses OpenAI-compatible API)
 bundle add openai
 

data/lib/active_agent/base.rb

@@ -26,7 +26,7 @@ module ActiveAgent
   #
   # @example Basic agent
   #   class MyAgent < ActiveAgent::Base
-  #     generate_with :openai, model: "gpt-4"
+  #     generate_with :openai, model: "gpt-5"
   #
   #     def greet
   #       prompt instructions: "Greet the user warmly"
@@ -112,7 +112,7 @@ module ActiveAgent
     # @return [void]
     #
     # @example
-    #   generate_with :openai, model: "gpt-4", temperature: 0.7
+    #   generate_with :openai, model: "gpt-5"
     def self.generate_with(provider_reference, **agent_options)
       self.prompt_provider = provider_reference
 

data/lib/active_agent/evals/publisher.rb

@@ -94,11 +94,7 @@ module ActiveAgent
       # report may be a Report or its saved JSON hash. Full prompts, answers and
       # tool results are included; applications should make publication opt-in.
       def call(report:, run_id:, source:, agent_name:, suite:)
-        identities = { "run_id" => run_id, "source" => source, "agent_name" => agent_name, "suite" => suite }
-        identities.each do |key, value|
-          raise ArgumentError, "#{key} must be a nonempty string" unless value.is_a?(String) && !value.strip.empty?
-        end
-        body = encode(identities.merge("version" => 1, "report" => report_hash(report)))
+        body = encode(self.class.envelope(report: report, run_id: run_id, source: source, agent_name: agent_name, suite: suite))
         raise Error, "Evaluation report exceeds the 2 MiB delivery limit; publish a smaller selection" if body.bytesize > MAX_BYTES
 
         deliver("retain the report and run_id for retry") do
@@ -143,6 +139,24 @@ module ActiveAgent
         end
       end
 
+      # The version-1 envelope a collector stores: the four identities, the
+      # version and the report's hash. What #call sends, and what a
+      # collector's export of a stored run returns, so the export can be
+      # posted again. report may be a Report or its saved JSON hash.
+      #
+      # Raises ArgumentError for an identity that is not a nonempty string,
+      # or a report that is neither.
+      def self.envelope(report:, run_id:, source:, agent_name:, suite:)
+        identities = { "run_id" => run_id, "source" => source, "agent_name" => agent_name, "suite" => suite }
+        identities.each do |key, value|
+          raise ArgumentError, "#{key} must be a nonempty string" unless value.is_a?(String) && !value.strip.empty?
+        end
+        hash = report.to_h if report.respond_to?(:to_h) && !report.nil? && !report.is_a?(Array)
+        raise ArgumentError, "report must be a Report or its saved JSON hash" unless hash.is_a?(Hash)
+
+        identities.merge("version" => 1, "report" => hash)
+      end
+
       private
 
       # Posts +body+ to the endpoint with the bearer key and the delivery timeouts.
@@ -176,13 +190,6 @@ module ActiveAgent
         raise Error.new("Evaluation delivery failed (#{e.class}); #{guidance}", retryable: true)
       end
 
-      def report_hash(report)
-        hash = report.to_h if report.respond_to?(:to_h) && !report.nil? && !report.is_a?(Array)
-        raise ArgumentError, "report must be a Report or its saved JSON hash" unless hash.is_a?(Hash)
-
-        hash
-      end
-
       # Returns the envelope as JSON. A report holding invalid UTF-8, NaN,
       # Infinity or nesting over JSON's depth limit raises a non-retryable
       # Error, without the generator's message, which can quote the report.

data/lib/active_agent/evals/report.rb

@@ -8,6 +8,7 @@ module ActiveAgent
     # Markdown, or a self-contained HTML page (ReportHtml).
     class Report
       include ReportHtml
+      include ReportMarkdown
 
       # The judge a verdict names when the framework ranked the models by
       # pass rate itself, no judge having been available to rule on them.
@@ -307,24 +308,6 @@ module ActiveAgent
         JSON.pretty_generate(to_h, *args)
       end
 
-      def to_markdown
-        scenario_count = @results.map { |result| result.scenario.key }.uniq.size
-        lines = [ "# Evaluation — #{scenario_count} scenario#{'s' unless scenario_count == 1} × #{@models.size} model#{'s' unless @models.size == 1}", "" ]
-        label = @judge_label || @judge&.label
-        lines << (label ? "Judged by `#{label}`." : "No judge; scored on rules and expectations alone.")
-        lines << ""
-        lines.concat(summary_table)
-        lines << ""
-        lines.concat(total_lines)
-        lines << "**Best model: #{winner}**" if winner
-        lines << ""
-        lines.concat(comparison_lines)
-        lines.concat(matrix_table)
-        lines.concat(detail_lines)
-        lines.concat(recommendation_lines)
-        lines.join("\n")
-      end
-
       private
 
       # Whether a model summary's cost is an estimate — any replay priced
@@ -559,7 +542,7 @@ module ActiveAgent
           latency = stats["avg_duration_ms"] ? "#{stats['avg_duration_ms']} ms" : "—"
           percentiles = stats["p50_duration_ms"] ? "#{stats['p50_duration_ms']} / #{stats['p95_duration_ms']} ms" : "—"
           cells = [
-            "`#{label}`",
+            cell("`#{label}`"),
             Format.passes(stats["passed"], stats["scenarios"], style: :markdown),
             Format.score(stats["avg_score"]),
             latency,
@@ -568,7 +551,7 @@ module ActiveAgent
             Format.money(stats["cost"], estimated: estimated_cost?(stats)),
             per_thousand_cell(stats),
             (judge_cell(stats) if judged),
-            faults.presence || "—"
+            cell(faults.presence || "—")
           ].compact
           "| #{cells.join(' | ')} |"
         end
@@ -617,13 +600,13 @@ module ActiveAgent
         lines = [ "## Comparison", "", "| Model | Pass rate | #{confidence} | Scenarios |", "|---|---|---|---|" ]
         comparison["ranking"].each do |label|
           stats = comparison["models"][label]
-          lines << "| `#{label}` | #{rate_text(stats['pass_rate'])} | #{interval_text(stats['interval'])} | #{stats['scenarios']} |"
+          lines << "| #{cell("`#{label}`")} | #{rate_text(stats['pass_rate'])} | #{interval_text(stats['interval'])} | #{stats['scenarios']} |"
         end
         lines += [ "", "| Pair | Difference | #{confidence} | Shared scenarios | Decisive |", "|---|---|---|---|---|" ]
         comparison["pairs"].each do |pair|
           a, b = pair["models"]
           difference = pair["difference"] ? format("%+.1f points", pair["difference"]) : "—"
-          lines << "| `#{a}` vs `#{b}` | #{difference} | #{interval_text(pair['interval'])} | #{pair['scenarios']} | #{pair['decisive'] ? 'yes' : 'no'} |"
+          lines << "| #{cell("`#{a}` vs `#{b}`")} | #{difference} | #{interval_text(pair['interval'])} | #{pair['scenarios']} | #{pair['decisive'] ? 'yes' : 'no'} |"
         end
         lines += [ "", comparison["conclusion"].to_s, "",
                    "_#{confidence} from #{Format.delimited(method['resamples'])} resamples of whole scenarios (seed #{method['seed']})._", "" ]
@@ -642,16 +625,16 @@ module ActiveAgent
       # cost across every model, and in brackets what the judge spent on it.
       def matrix_table
         labels = @models.map(&:label)
-        header = [ "| Scenario | #{labels.map { |label| "`#{label}`" }.join(' | ')} | Cost |", "|---|#{labels.map { '---' }.join('|')}|---|" ]
+        header = [ "| Scenario | #{labels.map { |label| cell("`#{label}`") }.join(' | ')} | Cost |", "|---|#{labels.map { '---' }.join('|')}|---|" ]
         rows = @results.group_by { |result| result.scenario.key }.map do |key, cohort|
           cells = labels.map do |label|
             result = cohort.find { |candidate| candidate.label == label }
             next "—" unless result
 
             mark = result.passed? ? "✅" : (result.errored? ? "⚠️" : "❌")
-            [ mark, (Format.score(result.score) if result.score), result.fault&.tr("_", " ") ].compact.join(" ")
+            cell([ mark, (Format.score(result.score) if result.score), result.fault&.tr("_", " ") ].compact.join(" "))
           end
-          "| `#{key}` #{cell(cohort.first.scenario.prompt.truncate(70))} | #{cells.join(' | ')} | #{scenario_cost_cell(key)} |"
+          "| #{cell("`#{key}` #{cohort.first.scenario.prompt.truncate(70)}")} | #{cells.join(' | ')} | #{scenario_cost_cell(key)} |"
         end
         header + rows
       end
@@ -664,30 +647,11 @@ module ActiveAgent
         text
       end
 
-      # A prompt may contain " | " (ScenarioParser keeps it), which would
-      # otherwise split the table cell.
+      # A prompt may contain " | " (ScenarioParser keeps it), and an answer
+      # or a label a line break, either of which would otherwise break the
+      # table row.
       def cell(text)
-        text.to_s.gsub("|") { "\\|" }
-      end
-
-      def detail_lines
-        lines = [ "", "## Answers", "" ]
-        @results.each do |result|
-          lines << "### `#{result.scenario.key}` · `#{result.label}` · #{result.status}" \
-                   "#{" · score #{Format.score(result.score)}" if result.score}#{" · #{answer_cost(result)}" if result.replay.cost}"
-          lines << ""
-          lines << "> #{result.scenario.prompt}"
-          lines << ""
-          if result.replay.tool_calls.any?
-            lines << "Tools: #{result.replay.tool_calls.map { |call| "#{call['name']}#{' ✗' if call['error']}" }.join(', ')}"
-          end
-          lines << "Fault: #{result.fault.tr('_', ' ')} — #{result.summary} #{result.recommendation}" if result.fault
-          lines << "Error: #{result.replay.error}" if result.replay.error
-          lines << ""
-          lines << (result.replay.answer.presence || "_(no answer)_").to_s.truncate(1_500)
-          lines << ""
-        end
-        lines
+        text.to_s.gsub(/\s*\r?\n\s*/, " ").gsub("|") { "\\|" }
       end
 
       # "~$0.0243 · judge ~$0.0015": what one answer cost, and what judging
@@ -698,20 +662,6 @@ module ActiveAgent
         text += " · judge #{Format.money(judge_cost, estimated: estimated_usage?(result.judge_usage))}" if judge_cost
         text
       end
-
-      # Renders after `detail_lines`, whose trailing blank line separates the two sections.
-      def recommendation_lines
-        return [] if recommendations.empty?
-
-        lines = [ "## Recommendations", "" ]
-        recommendations.each do |entry|
-          lines << "- **#{entry['fault'].tr('_', ' ')}** ×#{entry['count']} (#{entry['scenario_keys'].join(', ')}): #{entry['recommendation']}"
-          entry["suggested_tools"].each do |tool|
-            lines << "  - suggested tool `#{tool['name']}`: #{tool['description']}"
-          end
-        end
-        lines << ""
-      end
     end
   end
 end

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/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

data/lib/active_agent/providers/opper_provider.rb

@@ -0,0 +1,72 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "opper/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to Opper's OpenAI-compatible LLM gateway.
+    #
+    # Extends the OpenAI provider to work with Opper's OpenAI-compatible API,
+    # enabling access to models from many providers through a single
+    # interface. Model ids are bare pool names (e.g. +claude-sonnet-4-6+);
+    # a +provider/model+ id (e.g. +anthropic/claude-sonnet-4-6+) pins a route.
+    #
+    # Opper is a plain OpenAI-compatible gateway: requests, responses and
+    # transforms are identical to the OpenAI Chat API, so this provider reuses
+    # OpenAI::Chat::RequestType and OpenAI::Chat::Transforms directly. The only
+    # Opper-specific configuration is the base URL and API key, which live in
+    # Opper::Options.
+    #
+    # @example Configuration in active_agent.yml
+    #   opper:
+    #     service: "Opper"
+    #     api_key: <%= ENV["OPPER_API_KEY"] %>
+    #     model: "claude-sonnet-4-6"
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://docs.opper.ai
+    class OpperProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "Opper"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        Opper::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        OpenAI::Chat::RequestType.new
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.embed_request_type
+        OpenAI::Embedding::RequestType.new
+      end
+
+      protected
+
+      # Executes an embedding request via Opper's OpenAI-compatible API.
+      #
+      # @param parameters [Hash]
+      # @return [Hash] symbolized API response
+      def api_embed_execute(parameters)
+        client.embeddings.create(**parameters).as_json.deep_symbolize_keys
+      end
+
+      # @see BaseProvider#api_response_normalize
+      # @param api_response [OpenAI::Models::ChatCompletion]
+      # @return [Hash] normalized response hash
+      def api_response_normalize(api_response)
+        return api_response unless api_response
+
+        OpenAI::Chat::Transforms.gem_to_hash(api_response)
+      end
+    end
+  end
+end

data/lib/active_agent/version.rb

@@ -1,3 +1,3 @@
 module ActiveAgent
-  VERSION = "1.9.2"
+  VERSION = "1.9.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activeagent
 version: !ruby/object:Gem::Version
-  version: 1.9.2
+  version: 1.9.3
 platform: ruby
 authors:
 - Justin Bowen
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-20 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -467,6 +467,7 @@ files:
 - lib/active_agent/evals/replay.rb
 - lib/active_agent/evals/report.rb
 - lib/active_agent/evals/report_html.rb
+- lib/active_agent/evals/report_markdown.rb
 - lib/active_agent/evals/result.rb
 - lib/active_agent/evals/ruby_llm.rb
 - lib/active_agent/evals/runner.rb
@@ -585,6 +586,9 @@ files:
 - lib/active_agent/providers/open_router_provider.rb
 - lib/active_agent/providers/openai_provider.rb
 - lib/active_agent/providers/openrouter_provider.rb
+- lib/active_agent/providers/opper/_types.rb
+- lib/active_agent/providers/opper/options.rb
+- lib/active_agent/providers/opper_provider.rb
 - lib/active_agent/providers/requesty/_types.rb
 - lib/active_agent/providers/requesty/options.rb
 - lib/active_agent/providers/requesty_provider.rb