Repository navigation
Tags
Tags
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>
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>
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>
Merge pull request gepa-ai#155 from dbreunig/callbacks Add callback system for optimization instrumentation
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
Merge pull request gepa-ai#165 from gepa-ai/copilot/add-python-3-14-s… …upport Add Python 3.14 support
Merge pull request gepa-ai#92 from MatsErdkamp/main Allow for objective and hybrid pareto frontier tracking
Merge pull request gepa-ai#105 from Shashikant86/main Add MCP (Model Context Protocol) Adapter Support
PreviousNext