Skip to content

Tags

Tags

v0.1.4

Toggle v0.1.4's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
feat: ReflectionLM protocol + batch-based parallel proposals (gepa-ai…

…#329 Phases 1 & 4) (gepa-ai#369)

* feat: ReflectionLM protocol + StatelessReflectionLM (gepa-ai#329 Phase 1)

Add a ReflectionLM whose reflect() returns (proposal, next_lm); the stateless
default returns itself, so behavior is unchanged. Route propose_new_texts
through it. Sessions, agents, and ComBEE become later implementations.

Co-Authored-By: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-Authored-By: (Luke) Donghyun Lee <lukeleeai@gmail.com>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor: batch-based parallel proposals (gepa-ai#329 Phase 4, replaces gepa-ai#314)

Replace gepa-ai#314's ThreadPoolExecutor with a batch design: parallelism moves to
adapter.batch_evaluate() and the LM, keeping the engine sequential.

- Sampling: SingleMutationSampling (default), SameParentSampling,
  IndependentSampling, PxNSampling.
- Selection: AllImprovements (default), BestImprovement, TopKImprovements.
- propose() is a 5-stage pipeline returning list[CandidateProposal]; defaults
  reproduce the original single-proposal behavior.
- Optional batch_evaluate on GEPAAdapter + sequential fallback; batch_evaluator
  wired through optimize_anything (incorporates gepa-ai#279).

Closes gepa-ai#314. Incorporates gepa-ai#279.

Co-Authored-By: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-Authored-By: Shangyin Tan <shangyin@berkeley.edu>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat: batch reflection LM calls via litellm.batch_completion (gepa-ai#329 Phase 4)

When multiple proposals are sampled in one iteration, reflection round-trips
ran serially. Add an optional BatchReflectionLM protocol with reflect_many();
StatelessReflectionLM implements it, flattening every (task, component) prompt
into one LM.batch_complete() call. propose() now reflects all tasks in a single
batched request (per-task fallback on failure). N=1 is byte-identical.

Co-Authored-By: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* feat: batch full-valset eval of accepted candidates via batch_evaluate (gepa-ai#329 Phase 4)

When an iteration accepts multiple candidates (e.g. PxN sampling), their
full-valset evals are batched into a single adapter.batch_evaluate call, so any
parallelism lives at the adapter edge and the engine stays single-threaded. The
acceptance gate and pool/Pareto mutation remain sequential and ordered.

The GEPA evaluation cache and val_evaluation_policy are honored exactly as
before: only cache-miss examples are sent to the adapter, num_actual_evals
counts them, and the budget is incremented sequentially in _add_evaluated_program
when each candidate is added. Single-candidate iterations are unchanged.

Co-Authored-By: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* perf: fan optimize_anything batch_evaluate across candidates

The no-refiner fallback looped candidate-by-candidate, spinning up a
per-candidate thread pool that never saturated max_workers across the
multiple (candidate, batch) items the engine now batches. Flatten all
(candidate, example) pairs into one fan-out and regroup per item; shared
packaging keeps output identical to the per-item path. Only the parallel,
no-refiner, multi-item case changes.

* refactor: type proposal-strategy params + inherit strategy protocols (gepa-ai#329 Phase 4)

Address review: sampling_strategy / selection_strategy on optimize() and
EngineConfig were typed Any — use the SamplingStrategy / SelectionStrategy
protocols instead. Also have the built-in strategy classes explicitly inherit
their protocol, so pyright verifies conformance at the class definition
(notably for the strategies the library never instantiates itself). Parameters
stay protocol-typed, so external duck-typed strategies still work.

Co-Authored-By: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix: restore on_evaluation_skipped + capture per-param objective scores in batch eval (gepa-ai#329)

Addresses Devin review findings on gepa-ai#369:

- reflective_mutation.propose(): the batched Stage-3 rewrite dropped the
  on_evaluation_skipped callback for the no-trajectories and all-perfect skip
  branches. Re-fire it (reason "no_trajectories" / "all_scores_perfect") so
  callback consumers keep receiving skip events.
- OptimizeAnythingAdapter._batch_evaluate_via_user_fn: the batch_evaluator path
  captured only top-level side_info["scores"], dropping the per-parameter
  "<param>_specific_info" sub-scores that the single-example path captures via
  _extract_objective_scores. Use _extract_objective_scores so both paths agree.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix: make the engine the single accept+select authority (gepa-ai#329, Devin C3)

Move selection out of the reflective proposer. propose() now generates and
minibatch-evaluates candidates and returns all of them; the engine gates each by
the acceptance criterion (failures fire on_candidate_rejected), runs the
selection strategy over the accepted proposals, and full-evals + adds the
winners.

This removes the split that caused C3: acceptance lived on the engine but
selection lived in the proposer, so should_accept ran twice and
on_candidate_rejected never fired for reflective proposals. selection_strategy
now lives on GEPAEngine; sampling stays a proposer concern.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* fix: restore on_evaluation_start/end for child candidate evals; pin default-path behavior on the recorded AIME run

The batch propose() pipeline stopped emitting on_evaluation_start/end around
the new candidate's minibatch evaluation (the pre-batch sequential path
emitted them at both the parent and child sites). Restores the child-side
events with the same payload shape as before (candidate_idx=None, parent_ids
of the parent candidate).

Replaces the tautological TestDefaultStrategiesRetainBehavior (hasattr checks)
with real behavior pins against the recorded AIME replay run:
- default path reproduces the recorded run's golden optimized prompt (the
  replay fixture hard-fails on any LM input drift)
- budget-ledger consistency (monotonic, self-consistent deltas; only the seed
  valset eval precedes hook registration; final == result.total_metric_calls)
- explicit SingleMutationSampling+AllImprovements is event-for-event identical
  to the implicit defaults
- pinned budget-event composition (2 per proposal + 1 per accepted candidate)
  and child-evaluation event parity, so future granularity changes are made
  consciously

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat: reflection_strategy injection seam for custom ReflectionLM implementations

Adds a reflection_strategy parameter to ReflectiveMutationProposer and
gepa.optimize(): any ReflectionLM implementation can now own how reflective
mutation calls the reflection model, taking precedence over the stateless
default built from the raw reflection_lm callable. Implementations that only
provide reflect() are called once per task in the batch path; reflect_many
remains the batching fast path (getattr fallback, same pattern as
adapter.batch_evaluate).

This is the gepa-ai#329 Phase 2 entry point: session-based reflectors, coding-agent
reflectors, and aggregating reflectors like ComBEE (gepa-ai#307) plug in as
ReflectionLM implementations without touching the proposer pipeline.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: parallel-proposals guide (sampling/selection strategies, batch_evaluate)

Documents the strategy surface that replaces num_parallel_proposals: the four
sampling strategies, three selection strategies, the optional
adapter.batch_evaluate seam with its sequential fallback, budget-event
granularity, and the reflection_strategy seam.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* ci: cap litellm <1.92.0 on Python 3.14; disable matrix fail-fast

litellm 1.92.0 (released after this branch's last green run) ships a new Rust
extension with cp310-cp313 wheels only; on Python 3.14 the sdist build fails
(bundled pyo3 0.23.5 predates the 3.14 ABI), breaking dependency install for
every fresh CI run. Cap litellm below 1.92.0 on python_version >= '3.14' until
upstream publishes cp314 wheels.

Also set fail-fast: false on the test/build matrices: the 3.14 install failure
cancelled the 3.10/3.11/3.13 jobs mid-run (3.11 had already reported '510
passed' before cancellation), which made a single-interpreter dependency
breakage look like a five-version test failure.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: advance minibatch on repeated same-iteration sampler calls

Multi-proposal sampling strategies (SameParentSampling, IndependentSampling,
PxNSampling) call next_minibatch_ids once per task within a single iteration,
but EpochShuffledBatchSampler derived its position purely from state.i, so
every task in an iteration got the identical minibatch. The duplicate
(parent, minibatch) pairs were then deduplicated into one parent eval and the
N reflection jobs shared one prompt, collapsing best-of-N to temperature-only
diversity — contradicting the strategy docstrings and the mock-based unit
tests.

Track repeat calls within an iteration and advance one chunk per repeat call,
wrapping modulo the shuffled list. The first call of each iteration is
byte-identical to the previous behavior, and epoch/reshuffle bookkeeping
still uses the un-offset position, so the default single-call path and its
RNG sequence are unchanged. Document the within-iteration contract on the
BatchSampler protocol.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(optimize_anything): batch_evaluator parity with the evaluator path (review B1/H4/H2/L3)

batch_evaluator keeps its single-external-call contract (the whole point: all
(candidate, example) pairs in ONE call) while restoring everything that
survives that constraint:

- BatchEvaluatorWrapper: str-candidate unwrapping, per-pair opt_states
  injection when the signature accepts it (warm-start parity, gepa-ai#160),
  raise_on_exception policy (whole-call failure -> per-pair (0.0, {error})),
  and result normalization — float, (score, side_info) (the Evaluator-protocol
  mirror), or legacy 3-tuples all normalize to (score, side_info). A 2-tuple
  return no longer silently drops output (H4).
- _batch_evaluate_via_user_fn now packages through _assemble_no_refiner_batch:
  outputs are (score, candidate, side_info) triples, best-evals history is
  updated, objective scores extracted, metric calls counted — byte-identical
  to the sequential path (B1).
- ReflectionConfig.reflection_strategy: optimize_anything can now inject
  custom ReflectionLM implementations, symmetric with gepa.optimize() (H2).
- Documented the batch_evaluator contract (docstring + guide), including what
  structurally does NOT apply on this path: per-call oa.log() and stdio
  capture — diagnostics belong in each returned side_info.
- New test suite pinning all of the above (L3).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(proposer/engine): skip phantom children; selection sees all proposals (review H1/H3/L1/M1/M2-test)

- H1: when reflection returns empty new_texts (e.g. every requested component
  missing from the reflective dataset), skip the task before any proposal
  events fire — previously a child byte-identical to its parent burned
  len(minibatch) metric calls and emitted a guaranteed rejection.
- H3: the engine no longer pre-filters by acceptance criterion. The selection
  strategy is authoritative: it receives ALL evaluated proposals plus the
  criterion (built-ins filter; custom strategies may deliberately surface
  criterion-rejected proposals, e.g. exploration picks). Everything not
  selected fires on_candidate_rejected — including acceptance-passing
  proposals dropped by Best/TopK, which previously vanished without an event.
  Default behavior is unchanged (pinned by the recorded-run tests).
- L1: acceptance criteria may define reject_reason(proposal, state) -> str;
  the engine prefers it over the isinstance-based built-in messages.
- M1: class docstring no longer claims the proposer filters proposals.
- Tests: propose()-level harness pinning H1 both ways; cached-run spy proving
  a custom SelectionStrategy sees criterion-rejected proposals (H3);
  TrackingLM batch_complete exposure (M2).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* chore: review polish (M2/M3/M4/L4)

- M2: TrackingLM conditionally exposes batch_complete (with token estimation)
  when the wrapped callable provides it, so batched reflection is not silently
  downgraded to the per-task path by the tracking wrapper.
- M3: ProposalTask is Generic[DataId, DataInst]; minibatch_ids/minibatch are
  parameterized for custom SamplingStrategy authors.
- M4: SamplingStrategy docstring documents minibatch wrap-around when
  n * minibatch_size exceeds len(trainset).
- L4: StatelessReflectionLM docstring notes the batched-call mode.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* feat(optimize_anything): evaluator is optional when batch_evaluator is provided; unify the two transports

One mental model: batch_evaluator, when provided, is the preferred transport
for every multi-pair evaluation (proposer minibatch stages, valset/seed/merge
evals via adapter.evaluate) — one grouped external call each. Single-pair
resolutions (the refiner's evaluate->refine->re-evaluate loop) dispatch
through _resolve_pair: the single-pair evaluator when present, otherwise a
singleton batch call — so refiner + batch_evaluator-only now works instead of
being impossible, per maintainer decision.

Caching is now a first-class citizen of the batch path: the same
(candidate, example) keys and (score, output, side_info) values as
_call_evaluator, behind the same cache_mode switch (off/memory/disk) and lock.
Only cache misses reach the user's function — still as ONE call — and entries
are shared across paths: a pair cached by a grouped call is a hit for a
refiner singleton and vice versa.

optimize_anything(evaluator=) is now optional (keyword-only, so no call-site
breakage); a clear ValueError names the rule: provide evaluator=,
batch_evaluator=, or both. Remaining documented asymmetries: per-call
oa.log()/stdio capture apply only to the single-pair evaluator; batch users
return diagnostics in side_info.

Tests: transport validation, whole-batch routing through adapter.evaluate,
singleton refiner-seam routing, shared-cache behavior (miss-only grouped
calls, cross-path hits), both-transports routing preferences.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: evaluation-tier table; note parallel=True inertness and batch-fn concurrency

- Guide gains a three-tier table (sequential / parallel=True + singleton
  evaluator / batch_evaluator) making explicit that the tiers compose and
  none replaces the others: parallel=True remains the default easy path with
  the full per-call feature surface; batch_evaluator is for batching that
  threads-over-singletons cannot express.
- The adapter logs once when both parallel=True and batch_evaluator are set,
  since the thread pool is then not the transport for grouped evaluations.
- Documented (wrapper docstring, optimize_anything docstring, guide) that
  refiner_config + parallel=True with no single-pair evaluator calls the
  batch function concurrently with singleton batches — it must be
  thread-safe in that configuration.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: set reject_reason in the custom-criterion branch; narrow Optional in batch regroup

Pyright caught a real bug in the reject_reason hook: the custom-criterion
branch set only the log message, leaving the CandidateRejectedEvent's reason
variable unbound — a criterion actually defining reject_reason() would have
crashed at event construction. Both message and event reason now come from
the hook. The batch-path regroup also narrows the Optional slot explicitly
(assert guards the cache/miss bookkeeping invariant).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: batch_evaluate must not skip refinement when refiner + batch_evaluator are combined (N1)

The grouped batch_evaluate shortcut routed to no-refiner packaging whenever a
batch_evaluator existed, silently skipping refinement for proposer minibatch
and valset evaluations while adapter.evaluate-based paths (merge) still
refined — an inconsistent scoring regime with no warning. The shortcut is now
gated on refiner_config is None (the same guard evaluate() uses); with a
refiner, evaluation degrades to per-example refine loops whose evals reach
the batch function as singleton batches, as documented. Regression test pins
that the batch fn never sees a grouped call in this configuration.

Also: SamplingStrategy protocol is now Generic[DataId, DataInst], completing
the ProposalTask parameterization (N3); comment documents _resolve_pair's
output-slot placeholder contract (N2).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: truthful selection-drop reasons; reflection_strategy conflict guard; ReflectionProposal.metadata; per-task trace records

Four review findings:

1. Rejection reasons no longer lie about selection drops: a proposal that
   PASSES acceptance but is dropped by BestImprovement/TopK is reported as
   'passed acceptance but was not selected by the selection strategy (...)'
   instead of a fabricated score regression — in both the log line and
   CandidateRejectedEvent.reason, so experiment-tracker tables stay truthful.
2. reflection_strategy + adapter.propose_new_texts/custom_candidate_proposer
   now raises ValueError at construction instead of silently ignoring the
   strategy (the silent-config-noop class).
3. ReflectionProposal gains a free-form metadata field, threaded through
   propose_new_texts/_propose_texts_batch into CandidateProposal.metadata —
   multi-call reflection strategies (ComBEE's k+1 calls per component) get a
   diagnostics channel to callbacks/trackers/manifest now, before the
   interface hardens, instead of via a protocol break later.
4. full_program_trace records EVERY task in multi-task iterations (additive
   'n_tasks' + 'tasks' list with per-task ids and before/after scores);
   legacy first-task keys unchanged for existing tooling. Default single-task
   runs produce identical traces.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: adversarial-review round — 12 confirmed defects across engine, batch wrapper, reflection, api

Regressions vs main (both restored to main's contract):
- Acceptance criteria are judged EXACTLY once per proposal again: the engine
  wraps the criterion in a memoizing adapter shared by the selection strategy
  and rejection classification. Stateful/stochastic criteria previously got
  double-judged (selection + classification), flipping verdicts — zero
  acceptances and fabricated reasons in the repro.
- Legacy experiment-tracker keys subsample_score/new_subsample_score are
  emitted again alongside the new subsample/before|after keys.

New-feature defects (batch_evaluator / multi-proposal / reflection_strategy):
- Single-instance mode no longer leaks the internal _SingleInstanceSentinel
  to the user's batch function: examples are None (EvaluatorWrapper mirror).
- side_info returned by batch functions is defensively copied; retained-dict
  mutation can no longer corrupt the cache, best-evals, or objective scores.
- Whole-batch transient failures (raise_on_exception=False) are tagged and
  NEVER cached: one outage no longer poisons the disk cache for every pair.
- Non-dict side_info raises loudly (evaluator-path parity) instead of being
  silently dropped.
- Identical child candidates within an iteration are deduplicated before
  valset evaluation and pool insertion, with a truthful duplicate-rejection
  reason; selection strategies returning foreign objects are filtered with a
  log line; duplicate pool entries and double valset spend are gone.
- full_program_trace records ALL accepted program indices per iteration
  (new_program_indices), not just the last (legacy key preserved).
- gepa.optimize(reflection_strategy=...) works without a dummy reflection_lm
  (the requirement assert accepts either).
- max_reflection_cost + a strategy lacking total_cost now raises at config
  time instead of silently never stopping (unbounded spend); strategies
  exposing total_cost are wired into the cost stopper.
- Stateful ReflectionLM successors (next_lm) are chained instead of silently
  discarded; reflect_many results are length-validated; reflection metadata
  colliding with reserved prompt:/raw_lm_output: namespaces is remapped.
- Duplicate (candidate, example) pairs within one grouped call resolve to a
  single user-fn evaluation when caching is enabled; capture_stdio without an
  evaluator warns at config time.

Verification: differential harness vs main byte-identical on the recorded run
(modulo documented budget-event split); synthetic invariant suite
(tests/test_multi_proposal_invariants.py, new) covers PxN/SameParent/
Independent x All/Best/TopK x batched/plain x cache with budget-truth,
selection-margin, lineage, trace, save/load, determinism, dedup, and
stateful-criterion single-judgement invariants; 408 local tests pass.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: oa merge-proposer callbacks parity (v0.1.2 known issue); proposal_id metadata; contract docs

- optimize_anything's MergeProposer now receives callbacks, matching api.py —
  this was published as a known issue in the v0.1.2 release notes with a fix
  'queued for the next release' and had not actually been queued.
- Every CandidateProposal carries metadata['proposal_id'] (iteration-taskidx),
  giving run manifests and gepa-ai#346's per-proposal state anchors a stable key.
- SelectionStrategy protocol documents the engine contract (return objects
  from the given list; criterion is memoized to one judgement per proposal).
- batch_evaluator docstring: opt_states are snapshotted per grouped call
  (pairs within one call do not see each other's fresh results).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* style: strip trailing whitespace in SelectionStrategy docstring

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* docs: document the _gepa_transient_failure side_info contract

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Lakshya A Agrawal <lakshyaaagrawal@berkeley.edu>
Co-authored-by: (Luke) Donghyun Lee <lukeleeai@gmail.com>
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Co-authored-by: Shangyin Tan <shangyin@berkeley.edu>
Co-authored-by: Lakshya A Agrawal <lakshya.aagrawal@gmail.com>

v0.1.3

Toggle v0.1.3's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
fix: cap litellm <1.92 on Python 3.14 and make CI dependency resoluti…

…on deterministic (gepa-ai#391)

* fix: cap litellm <1.92 on Python 3.14 and make CI resolution deterministic

litellm 1.92.0 introduced a native extension built with PyO3 0.23.5 (max
Python 3.13) and ships no cp314 wheels, so its sdist cannot build on
Python 3.14. The v0.1.2 release bump also stranded uv.lock (project
version mismatch), causing plain `uv sync` in CI to silently re-resolve
against latest PyPI and pick up the unbuildable litellm — failing the
3.14 test and build jobs on main (run 29331310678).

- pyproject: constrain litellm to <1.92 on Python >= 3.14 (full and
  confidence extras) until litellm ships 3.14 support
- uv.lock: re-lock (records 0.1.2; litellm resolves to 1.91.3 everywhere)
- run_tests.yml: use `uv sync --locked` so a stale lock fails loudly
  instead of silently re-resolving; disable fail-fast so one interpreter
  failure doesn't cancel the rest of the matrix
- build_and_release.yml: refresh and commit uv.lock alongside the release
  version bump so release merges don't strand the lock
- dependency_canary.yml (new): scheduled fresh-resolution job simulating
  a user's pip install against latest PyPI, so upstream breaks surface in
  a dedicated signal instead of inside unrelated PRs or release merges

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: cap litellm <1.92 unconditionally; canary uses per-interpreter resolution

Review follow-ups, plus a broader finding the review prompted:

1. litellm 1.92.0's wheels are manylinux-only (cp310-cp313): no macOS,
   no Windows, no cp314. Everyone else builds the sdist, which needs
   Cargo >= 1.85 (edition2024) — verified failing locally on macOS
   arm64 / Python 3.12. So the cap must be unconditional, not gated on
   python_version >= '3.14': fresh installs of gepa[full] are broken
   for macOS/Windows users on every interpreter. This also dissolves
   the reviewer's unification finding — metadata and lock now agree on
   <1.92 everywhere by design instead of by resolver accident.

2. Canary: confirmed uv lock --upgrade re-unifies litellm at 1.91.3
   across all branches (single [[package]] entry, no resolution-marker
   fork), so re-locking cannot simulate user installs. The canary now
   uses uv pip install (per-interpreter, pip-semantics resolution) —
   verified locally that it picks 1.92.0 on 3.12 where the universal
   lock pins 1.91.3. Matrix widened to ubuntu+macos across all five
   interpreters (wheel gaps are platform- and ABI-specific), and
   failures now open/update a tracking issue instead of sitting
   silently in the Actions tab.

3. Drive-by: re-resolved wandb off the yanked 0.24.0 (-> 0.28.0).

Verified: uv lock --check passes; locked path (3.12): 476 passed,
4 skipped; fresh pip-semantics install on macOS 3.12 — the exact case
that failed before the cap — resolves litellm 1.91.3, 476 passed.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix: aggregate canary failure notification into a single post-matrix job

Per-leg notification raced: simultaneous first failures (the realistic
case — this incident broke multiple interpreters/platforms at once)
would each see no open issue and file duplicates. The notifier now runs
once after the matrix settles, names every failed leg in the issue body
(via the runs/:id/jobs API), and issues:write is scoped down from the
workflow level to just this job.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

v0.1.2

Toggle v0.1.2's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Update staging-docs.yml

v0.1.1

Toggle v0.1.1's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
feat: candidate tree visualization with interactive tooltips (gepa-ai…

…#256)

* feat: add candidate tree visualization with interactive tooltips

Add a zero-dependency visualization module that generates Graphviz DOT
and self-contained HTML views of the candidate lineage tree.

Key features:
- Nodes colored by role: best (cyan), pareto front (orange), other (gray)
- Hovering shows full candidate text, val score, parents, and role
- HTML page uses @viz-js/viz from CDN for client-side DOT rendering
- Works from both GEPAState (mid-run) and GEPAResult (post-run)

Integration:
- Engine auto-logs the tree after each accepted candidate to
  wandb (Html artifact), mlflow (HTML artifact), and run_dir
- ExperimentTracker gains a log_html() method
- GEPAResult gains candidate_tree_dot() and candidate_tree_html()

Closes gepa-ai#54

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: improve candidate tree tooltip UX and wandb panel sizing

- Replace pointer-events:none tooltip with hover+click model: hover shows
  a following tooltip for quick preview, click pins it for scrolling
- Strip native SVG <title> elements to prevent double tooltips
- Suppress DOT tooltip text (set to space) since custom JS handles it
- Make HTML fill iframe (flex layout, 100% height) for wandb panel
- Write candidate tree to wandb run summary so latest is always visible
- Add hint text ("Click to pin & scroll") for discoverability

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* fix: update test for suppressed DOT tooltip

The tooltip text was moved from DOT to HTML JS, so the test now
verifies the DOT tooltip is a space (suppressed) rather than checking
for candidate text in the DOT string.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Co-authored-by: Lakshya A Agrawal <lakshyaaagrawal+gepabot@berkeley.edu>

v0.1.0

Toggle v0.1.0's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Create details-anchor.js (gepa-ai#219)

v0.0.27

Toggle v0.0.27's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Merge pull request gepa-ai#155 from dbreunig/callbacks

Add callback system for optimization instrumentation

v0.0.26

Toggle v0.0.26's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Merge pull request gepa-ai#171 from chenmoneygithub/fix-mlflow-logging

Fix MLflow logging, and add tracking for how many metric calls have been issued

v0.0.25

Toggle v0.0.25's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Merge pull request gepa-ai#165 from gepa-ai/copilot/add-python-3-14-s…

…upport

Add Python 3.14 support

v0.0.24

Toggle v0.0.24's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Merge pull request gepa-ai#92 from MatsErdkamp/main

Allow for objective and hybrid pareto frontier tracking

v0.0.23

Toggle v0.0.23's commit message

Verified

This commit was created on GitHub.com and signed with GitHub’s verified signature.
Merge pull request gepa-ai#105 from Shashikant86/main

Add MCP (Model Context Protocol) Adapter Support