@opensearch-project/agent-health 0.6.0 → 0.7.0

package/docs/CONNECTORS.md

@@ -529,7 +529,7 @@ See `services/connectors/claude-code/ClaudeCodeConnector.ts` for a complete exam
 ### Kiro Connector
 
 See `services/connectors/kiro/KiroConnector.ts` for a `SubprocessConnector`
-subclass that overrides `parseStderrChunk()` to convert Kiro's stderr-borne
+subclass that overrides `parseStderrChunk(chunk, trajectory, onProgress, state)` to convert Kiro's stderr-borne
 `[tool] Running:` / `[tool] status:` markers into structured `action` +
 `tool_result` steps. The base `SubprocessConnector` also persists `stderr` to
 `rawOutput` and honors per-request `connectorConfig` overrides (`args` /

package/docs/SDK.md

@@ -64,7 +64,7 @@ async function ({ agent, judge, evaluate, expect, testInfo, provisioned }) { ...
 | `agent`  | `AgentFixture`                                   | `await agent.run(prompt?, options?)` — invoke the agent **once** (control inversion). Returns an `EvalResult`. |
 | `judge`  | `JudgeFn`                                         | Non-throwing LLM judge. `judge(...)` gates; `judge.observe(...)` is observational. Returns a `Verdict`. |
 | `evaluate` | `EvaluateFn`                                     | Run a custom programmatic evaluator registered with `defineEvaluator()`. |
-| `expect` | chai's `expect` with our recording plugin        | Synchronous matcher entry-point |
+| `expect` | chai's `expect` with our recording plugin        | Synchronous matcher entry-point. `expect.soft(...)` records a failing assertion instead of throwing — see [Always-record guarantee](#5-matchers-record-structured-verdicts). |
 | `testInfo` | `TestInfo` (read-only)                          | `{ name, benchmarkPath, sourceFile, testCaseId }` |
 | `provisioned` | `Readonly<Record<string, unknown>>`          | Values set by `beforeEach` via `provide()` |
 | `result` | `EvalResult` *(legacy eager path)*               | Pre-populated agent result — present when the runner invokes before the body. Prefer `await agent.run()`. |
@@ -187,6 +187,79 @@ Matchers (4/5 passed)
 This is the major upgrade over throw-and-fail: every assertion gets its own
 row, status, and detail block.
 
+#### Always-record guarantee
+
+chai's `expect()` is fail-fast — the first failing assertion throws, and the
+rest of the test body (any later `expect()`/`judge()`/`evaluate()` calls)
+never executes. For a pass/fail verdict that's the intended Playwright-style
+contract, but a report consumed by an optimizer (or by you, comparing runs)
+needs the objective actuals — duration, token usage, USD cost — from every
+axis, even when one gate fails partway through. A token-budget gate failing
+shouldn't erase the cost figure that would otherwise have been on the report.
+
+So regardless of where (or whether) the body throws, the runner **always**
+stamps `performanceMetrics.durationMs` / `.agentDurationMs` /
+`.totalTokens` / `.totalCostUsd` onto the report the moment `agent.run()`
+resolves — reading them straight from the same OTel-derived data
+`result.traces`/the `traces` fixture exposes, independent of whether the
+body's own code ever reached a matcher that asserted on them. (`totalTokens`/
+`totalCostUsd` are `undefined`, not `0`, when `useTraces: true` but spans
+never arrived — see the loud-failure accessor in "Traces fixture" below;
+they're real `0`s when `useTraces: false`.)
+
+This guarantee has one hard limit: a `judge()`/`evaluate()` call itself is
+already non-throwing and records its score/verdict the instant it's called —
+so a REACHED judge call is always on the report today, throw-or-not. But a
+judge call placed textually *after* a failing `expect()` never executes at
+all — that's a pure source-order problem the runner cannot retroactively fix
+(it can't record a call that never ran). Use `expect.soft(...)` (below) when
+you need later judge/evaluate calls to run even after an earlier assertion
+fails.
+
+The matcher panel also gets a distinct **"not reached"** row appended
+whenever the body threw — so "this axis never ran" (grey, not-reached) reads
+differently from "this axis ran and failed" (red). It's excluded from the
+passed/failed counts and gets its own tally: `(3/4 passed, 1 not reached)`.
+
+#### `expect.soft(...)` — keep going instead of bailing on the first failure
+
+`expect.soft(value)` is the same chai assertion surface as `expect(value)`
+— every built-in BDD matcher plus the custom ones below — except a failing
+assertion **records** the MatcherResult and returns instead of throwing:
+
+```javascript
+test('budget-aware RCA', { prompt: '...' }, async ({ agent, expect, judge }) => {
+  const result = await agent.run();
+  expect.soft(result.traces.totalTokens).to.be.lessThan(10_000);  // fails — recorded, body continues
+  expect.soft(result.traces.totalCost).to.be.lessThan(0.05);      // still runs
+  await judge(result, 'identifies the root cause');                // still runs — the whole point
+  expect(result.agentOutput).to.contain('root cause');             // a HARD expect still bails on ITS OWN failure
+});
+```
+
+The runner's overall verdict is unaffected by soft vs. hard: a test already
+fails when ANY recorded gate matcher has `pass: false` (that's exactly how
+non-throwing `judge()`/`evaluate()` gates have always worked) — `expect.soft`
+just extends that same non-throwing contract to chai assertions. Mix soft and
+hard freely in one body; a hard `expect()` after a soft failure still bails
+at that point (source order still matters for the calls *after* a HARD
+failure). Reach for `.soft` on measurement/budget-style axis checks where you
+want every number on the report regardless of which gates failed; keep hard
+`expect()` for a precondition that makes the rest of the body meaningless if
+it's false (e.g. "the agent produced any output at all").
+
+> **Known limitation: multi-step property chains can record a derivative
+> second failure.** `expect.soft(obj).to.have.property('x').that.equals(5)`
+> is really two chai assertions run back-to-back on the same chain (`property`
+> checks existence, `equals` checks the value) — with a HARD `expect()`, a
+> missing property throws immediately and `.that.equals(5)` never runs. In
+> soft mode nothing throws, so `.that.equals(5)` *does* run against
+> `undefined` and records its own "expected undefined to equal 5" failure —
+> real, but a symptom of the first failure, not independent information.
+> Prefer single-step matchers on primitive/simple values with `.soft` (as in
+> every example above); for a value that might not exist, use a hard
+> `expect()` to check existence first, then `.soft` on the value itself.
+
 ---
 
 ## Test options
@@ -575,6 +648,57 @@ The `.eval.js`, `.eval.ts`, and `.eval.mjs` loaders all run through a single
 code-import execution path, so `benchmark -f <file>` executes the SDK body
 directly.
 
+> **`.eval.js` and `.eval.ts` are both executed as synthetic CJS — only
+> `.eval.mjs` needs the package to be really resolvable.** `.eval.js` and
+> `.eval.ts` files are both executed in a synthetic context where the
+> `require(...)` call for `@opensearch-project/agent-health` is intercepted
+> directly, so they work from anywhere on disk regardless of whether the
+> package is actually installed at that location. (`.eval.ts` is
+> transpiled to CommonJS with `esbuild` — a required runtime dependency of
+> this package — before running through that exact same synthetic-CJS
+> path; it deliberately does NOT use a native `import()`, both to avoid two
+> different Node versions giving the same file two different
+> module-execution semantics, and because `import()` caches by URL, which
+> would make a `.eval.ts` file unloadable a second time in one process
+> without a restart. One consequence: an `.eval.ts` fixture can't use
+> `import.meta` or a top-level `await` — real-ESM-only features with no
+> CommonJS equivalent.) `.eval.mjs` files use a plain native `import()`, so
+> `import { test } from '@opensearch-project/agent-health'` in an `.mjs`
+> file must resolve through Node's normal module resolution — the package
+> needs to be a real dependency reachable from the file's location
+> (installed in `node_modules`, a workspace link, or a `node_modules`
+> symlink to a local checkout). Test registrations are shared process-wide
+> (keyed off `globalThis`) regardless of loader, so it doesn't matter
+> *which* physical copy of the package a given import resolves to — dist
+> vs source, symlinked vs installed all register into the same registry
+> the loader reads from.
+
+> **`.eval.ts` can `import` sibling `.ts` helper files, but not ESM-only
+> packages.** A relative/absolute `import` inside an `.eval.ts` file that
+> resolves to another `.ts` file (e.g. `import { helper } from
+> './helper.ts'`) is transpiled and executed through the same synthetic-CJS
+> mechanism recursively — multi-file `.eval.ts` fixtures work, and a helper
+> required more than once within one load executes exactly once (cached
+> for the duration of that load only, never across separate loads/reloads).
+> An `import` of a package that ships **no CommonJS entry point** (ESM-only,
+> e.g. modern `chalk`) fails with an actionable error — `.eval.ts` executes
+> as synthetic CJS, so under require()'s own rules that package can't load
+> there — unless the running Node version has native `require(esm)`
+> interop (stable since Node 22.12; check `process.features.require_module`),
+> in which case it works transparently via Node's own mechanism. If you hit
+> the error on an older Node, switch the fixture to `.eval.mjs` (real ESM,
+> can import ESM-only packages directly) or pre-compile to `.eval.js`.
+
+> **`.eval.mjs` reloads are cache-busted, not cached.** Every `import()` of
+> an `.eval.mjs` file is given a unique query string
+> (`?ah-reload=<timestamp>-<random>`) so re-loading the same file a second
+> time in one process (e.g. re-running the CLI against an edited fixture)
+> re-executes its top-level code instead of silently returning Node's
+> already-cached module for that URL. Accepted cost: each reload leaves one
+> module instance cached under a never-reused query string for the
+> lifetime of the process — negligible for CLI/server process lifetimes
+> (a handful to a few hundred loads, not an unbounded long-running loop).
+
 ---
 
 ## Dev tips
@@ -623,4 +747,4 @@ keeping it user-supplied lets you opt in without breaking anyone else.
 - [x] Non-throwing run-scoped `judge` with `gate` / `observe` roles + `skip` + `orThrow()`
 - [x] `defineEvaluator()` / `evaluate()` for mechanical / external verification ([#244](https://github.com/opensearch-project/agent-health/issues/244))
 - [x] Single code-import execution path (`benchmark -f *.eval.js` runs the SDK body) + unified `.js` / `.ts` / `.mjs` loaders + `agent-health migrate sdk-v2` codemod
-- [ ] `expect.soft()` to collect-all-failures instead of bail-on-first
+- [x] `expect.soft()` to collect-all-failures instead of bail-on-first

package/docs/skills/add-connector/SKILL.md

@@ -62,7 +62,11 @@ connectorRegistry.register(new CustomConnector());
   - `propagateHeader: true` → inject a `traceparent` HTTP header into HTTP/SSE agents (`injectTraceparentHeaders()`).
   - `serviceName: '<otel-service-name>'` → service-name + time-window fallback. Defaults: `claude-code-agent`, `kiro-agent`, `pi-agent`, `observio-sample-agent`. See the "Trace correlation conventions" section in `AGENTS.md`.
 - **Subprocess connectors** (`SubprocessConnector` subclasses) can override
-  `parseStderrChunk(chunk)` to turn stderr markers into trajectory steps (how
+  `parseStderrChunk(chunk, trajectory, onProgress, state)` to turn stderr markers into trajectory steps (how
   `kiro` surfaces `[tool] Running:` / `[tool] status:` as `action` +
   `tool_result` steps). The base class persists `stderr` to `rawOutput` and
   honors per-request `connectorConfig` overrides (`args` / `inputMode` / `timeout`).
+  Keep ALL streaming state (partial-line buffers, pending tool names, captured
+  ids) on the per-invocation `state` object (extend `SubprocessExecutionState`
+  via `createExecutionState()`), never on `this` — the registry shares one
+  connector instance across concurrent runs.

package/lib/dist/lib/agentTrends.d.ts

@@ -0,0 +1,210 @@
+/**
+ * Agent Trends Band — Aggregation Utilities
+ *
+ * Builds the per-run, per-agent data model behind the landing-page
+ * "Agent trends" band: v3 replaces the all-agents overlay chart (one
+ * ECharts line+scatter series per agent, sharing a 10-color palette) with
+ * a small-multiples sparkline-table — one row per agent, sorted by latest
+ * score or biggest drop, each row's sparkline + a single-agent focused
+ * detail chart built from the SAME gap-broken series shape.
+ *
+ * Deliberately kept UI-framework-free so it's cheaply unit testable and
+ * so it can be reused by the row list, the drawer, and the detail chart.
+ *
+ * Data-source note: accuracy/pass counts come straight from
+ * `Benchmark.runs[]` (already loaded by the Dashboard for the runs list —
+ * no extra fetch). Cost/tokens are trace-derived and only available for
+ * runs whose reports were resolved in the caller's `metricsMap` (see
+ * services/metrics.ts#fetchBatchMetrics); a run reports `costUsd`/`tokens`
+ * only when EVERY one of its reports resolved a match — a partial sum
+ * would understate the run's true cost while looking complete, which is
+ * worse than admitting "unknown" — so partially- or fully-unmatched runs
+ * get `null` rather than a fabricated or partial total, and callers render
+ * an honest "—" instead.
+ */
+import type { Benchmark, BenchmarkRun, EvaluationReport } from '../types/index.js';
+export type TrendMetricKey = 'accuracy' | 'cost' | 'tokens';
+export type TrendsTimeRange = '7d' | '30d' | '90d';
+export type TrendSortMode = 'latest' | 'biggestDrop';
+export interface RunMetricsLookup {
+    costUsd: number;
+    tokens: number;
+}
+/** One dot on the trend chart: a single BenchmarkRun for one agent. */
+export interface AgentRunPoint {
+    runDocId: string;
+    benchmarkId: string;
+    benchmarkName: string;
+    agentKey: string;
+    agentName: string;
+    modelId: string;
+    createdAt: string;
+    timestamp: number;
+    passed: number;
+    failed: number;
+    total: number;
+    /**
+     * 0-100 pass rate over the evaluable set, or `null` when the run had
+     * ZERO evaluable test cases (every case errored — no judge verdict at
+     * all). Owner-reported bug: this used to default to `0`, which is
+     * visually indistinguishable from a genuine "the agent passed nothing"
+     * result — a run with no signal must never render as a real data point.
+     */
+    accuracyPct: number | null;
+    costUsd: number | null;
+    tokens: number | null;
+}
+/**
+ * Deterministic, visually distinct color palette for the chart lines / chip
+ * left-borders. Assigned by sorted agentKey so colors stay stable across
+ * re-renders and time-range/benchmark filtering (not by first-seen order,
+ * which would shuffle as the visible run set changes).
+ *
+ * v3 note: the small-multiples redesign no longer overlays every agent's
+ * line on one chart, so per-agent hue no longer needs to scale to N agents
+ * (the old 10-color palette repeated after the 10th agent — "indistinguishable
+ * colors" in the owner's feedback with 14 agents in scope). Each row/detail
+ * chart is already labeled by name, so a single, theme-aware accent color
+ * plus semantic (up/down) delta coloring is used everywhere instead — see
+ * `TREND_LINE_COLOR` in AgentTrendSparkline/AgentTrendDetailChart.
+ */
+/**
+ * Compute passed/failed/total/accuracyPct for a run, preferring the
+ * denormalized `run.stats` (fast path) and falling back to bucketing
+ * `run.results` directly (same canonical logic used by the runs list) —
+ * no report fetch required either way.
+ */
+export declare function getRunAccuracy(run: BenchmarkRun): {
+    passed: number;
+    failed: number;
+    total: number;
+    accuracyPct: number | null;
+};
+export declare function timeRangeToSinceMs(range: TrendsTimeRange, nowMs?: number): number;
+export interface BuildAgentRunPointsOptions {
+    benchmarkId?: string | null;
+    sinceMs?: number | null;
+    agentDisplayName?: (agentKey: string) => string;
+}
+/**
+ * Build one AgentRunPoint per BenchmarkRun (skipping runs with zero test
+ * cases — e.g. still-provisioning or cancelled-before-start runs), sorted
+ * ascending by time.
+ */
+export declare function buildAgentRunPoints(benchmarks: Benchmark[], reports: EvaluationReport[], metricsMap: Map<string, RunMetricsLookup>, options?: BuildAgentRunPointsOptions): AgentRunPoint[];
+/** Group already time-sorted points by agentKey, preserving relative order. */
+export declare function groupPointsByAgent(points: AgentRunPoint[]): Map<string, AgentRunPoint[]>;
+export declare function metricValue(point: AgentRunPoint, metric: TrendMetricKey): number | null;
+export declare function formatMetricValue(metric: TrendMetricKey, value: number): string;
+/** One entry in a gap-broken trend series. `value: null` marks a synthetic break, never a real run. */
+export interface TrendSeriesEntry {
+    timestamp: number;
+    value: number | null;
+    point: AgentRunPoint | null;
+}
+/**
+ * Build one agent's gap-broken series for `metric`: points whose metric
+ * value is null (no evaluable accuracy, or no trace-resolved cost/tokens)
+ * are dropped — never plotted as a fake zero. A synthetic `{ value: null }`
+ * marker is inserted at the midpoint between any two consecutive PLOTTED
+ * points whose time gap exceeds `gapBreakMs` (default 7 days).
+ *
+ * Why: a chart line drawn between two data-array entries connects them
+ * with a straight (or smoothed) segment regardless of how far apart their
+ * x-values are — so two runs 25 days apart look, visually, like a
+ * continuous trend across those 25 days ("sparse runs produce misleading
+ * long interpolated lines" — owner feedback). Inserting a null-valued
+ * entry between them gives recharts' `<Line connectNulls={false}>` (the
+ * default) an explicit place to break the path, while the surrounding
+ * dead space still renders proportionally on a time-scaled x-axis.
+ */
+export declare function buildGapBrokenSeries(agentPoints: AgentRunPoint[], // already time-sorted, single agent
+metric: TrendMetricKey, gapBreakMs?: number): TrendSeriesEntry[];
+/** Latest-vs-previous delta for one agent's metric series (not week-over-week — the immediately prior run). */
+export interface TrendDelta {
+    latestValue: number | null;
+    previousValue: number | null;
+    /** latestValue - previousValue; null unless BOTH resolved to a real value. */
+    delta: number | null;
+}
+export declare function computeLatestDelta(agentPoints: AgentRunPoint[], metric: TrendMetricKey): TrendDelta;
+export declare function formatDelta(metric: TrendMetricKey, delta: number | null): string;
+/** One row in the sparkline-table: one agent, its gap-broken series for the current metric, latest value + delta. */
+export interface AgentTrendRow {
+    agentKey: string;
+    agentName: string;
+    runCount: number;
+    latestRunAt: string | null;
+    latestRunDocId: string | null;
+    latestBenchmarkId: string | null;
+    /** All of this agent's points, time-sorted (unfiltered by metric) — the detail chart re-derives per-metric series from this on focus. */
+    points: AgentRunPoint[];
+    /** Gap-broken series for the CURRENTLY selected metric — what the row's sparkline draws. */
+    series: TrendSeriesEntry[];
+    latestValue: number | null;
+    previousValue: number | null;
+    delta: number | null;
+}
+/**
+ * Group `points` by agent and shape each into a sparkline-table row for
+ * the given metric. One row per agent that has at least one point in
+ * scope — a single run is a perfectly valid row (a lone dot, `delta: null`
+ * rendered as "n/a"); there is no "not enough data" floor at the row
+ * level (unlike the old all-agents chart, which needed >=2 points across
+ * ALL agents just to avoid an empty canvas).
+ */
+export declare function buildAgentTrendRows(points: AgentRunPoint[], metric: TrendMetricKey, gapBreakMs?: number): AgentTrendRow[];
+/**
+ * Sort rows by latest value (highest first; rows with no value for the
+ * current metric sort last) or by biggest drop (most negative delta
+ * first; rows with no delta sort last, ordered among themselves by latest
+ * value so a still-informative "no signal yet" row isn't buried below a
+ * literal `undefined`-sorts-arbitrarily bucket).
+ */
+export declare function sortAgentTrendRows(rows: AgentTrendRow[], sortMode: TrendSortMode): AgentTrendRow[];
+/** Default benchmark selector value: the benchmark with the most recent run. */
+export declare function getMostRecentlyActiveBenchmarkId(benchmarks: Benchmark[]): string | null;
+/** One plottable dot: a run + its resolved metric value (metric-null points are never included). */
+export interface DotPlotEntry {
+    point: AgentRunPoint;
+    value: number;
+}
+/** One row of the ranked dot plot: one agent, its latest dot (solid) + earlier dots (faded). */
+export interface BenchmarkDotPlotRow {
+    agentKey: string;
+    agentName: string;
+    /** null when this agent has no run with a resolved value for the current metric (e.g. no trace-derived cost yet). */
+    latest: DotPlotEntry | null;
+    /** Earlier runs with a resolved value, time-ascending, EXCLUDING `latest`. */
+    history: DotPlotEntry[];
+    /** 0-based rank after `rankDotPlotRows` (0 = top/best); -1 until ranked. */
+    rank: number;
+}
+/**
+ * Group `points` (already scoped to one benchmark by the caller) by agent
+ * and split each agent's valued runs into `latest` (most recent with a
+ * resolved value) + `history` (earlier ones). An agent with zero valued
+ * runs for this metric still gets a row (`latest: null`) so it's visible
+ * in the list rather than silently disappearing when switching metrics.
+ */
+export declare function buildBenchmarkDotPlotRows(points: AgentRunPoint[], metric: TrendMetricKey): BenchmarkDotPlotRow[];
+/**
+ * Rank rows by latest value, best (highest) first — rows with no value for
+ * the current metric sort last (still listed, just unranked among
+ * themselves by name for a stable order). Stamps `rank` (0 = top) on the
+ * returned copies; does not mutate the input.
+ */
+export declare function rankDotPlotRows(rows: BenchmarkDotPlotRow[]): BenchmarkDotPlotRow[];
+/**
+ * Shared X-domain for a dot plot: accuracy is always anchored to the true
+ * [0, 100] scale (auto-scaling to the observed min/max would visually
+ * exaggerate small real-world differences, e.g. an 88-95% cluster would
+ * stretch to fill the whole width). Cost/tokens are zero-anchored (0 is a
+ * meaningful reference point for both) up to the observed max plus a
+ * little headroom so the top dot isn't flush against the edge. Returns
+ * `null` when there is nothing to plot at all.
+ */
+export declare function metricDomain(rows: BenchmarkDotPlotRow[], metric: TrendMetricKey): [number, number] | null;
+/** Map a value into a 0-100 position within `domain`, clamped — usable directly as a CSS `left`/`width` percentage. */
+export declare function valueToPercent(value: number, domain: [number, number]): number;
+//# sourceMappingURL=agentTrends.d.ts.map

package/lib/dist/lib/agentTrends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentTrends.d.ts","sourceRoot":"","sources":["../../agentTrends.ts"],"names":[],"mappings":"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"}