orizu 0.5.19 → 0.5.21

package/vendor/orizu-gepa/src/orizu_gepa_connector/skilled_proposer_bridge.py

@@ -0,0 +1,381 @@
+"""Typed DSPy bridge for the opt-in skilled-proposer integration.
+
+This module deliberately owns proposal-LM observability.  It does not use
+``dspy.LM`` or LiteLLM: every completion reaches the frozen provider transport
+through ``complete_reflection_messages`` and is recorded before DSPy sees its
+response.
+"""
+
+from __future__ import annotations
+
+import atexit
+import dataclasses
+import json
+import os
+import shutil
+import tempfile
+import uuid
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse
+
+try:
+    import dspy
+except ModuleNotFoundError as error:
+    if error.name != "dspy":
+        raise
+    dspy = None
+
+if TYPE_CHECKING:
+    import dspy as dspy_types
+
+from orizu_gepa.reflection import ProviderCompletion, complete_reflection_messages
+from orizu_gepa.optimizer import TextGepaConfig
+
+_SELECTION_ENV = "ORIZU_CANDIDATE_PROPOSER"
+_SELECTION_VALUE = "skilled-proposer"
+_SUPPORTED_ROLES = {"system", "user", "assistant"}
+_ALLOWED_DSPY_REQUEST_FIELDS = frozenset({"temperature", "max_tokens", "cache"})
+_DspyBaseLM = dspy.BaseLM if dspy is not None else object
+
+
+def _require_dspy() -> Any:
+    if dspy is None:
+        raise RuntimeError("ALI_1505_DSPY_UNAVAILABLE")
+    return dspy
+
+
+def _usage_totals() -> dict[str, int]:
+    return {"input_tokens": 0, "output_tokens": 0, "total_tokens": 0}
+
+
+def _require_usage(usage: dict[str, int]) -> dict[str, int]:
+    try:
+        normalized = {name: int(usage[name]) for name in _usage_totals()}
+    except (KeyError, TypeError, ValueError) as error:
+        raise RuntimeError("ALI_1505_PROPOSAL_USAGE_INVALID") from error
+    if any(value < 0 for value in normalized.values()):
+        raise RuntimeError("ALI_1505_PROPOSAL_USAGE_INVALID")
+    return normalized
+
+
+@dataclass
+class ProposalCallBudget:
+    """The connector-owned proposal ledger; GEPA metric accounting is separate."""
+
+    max_calls: int | None = None
+    max_tokens: int | None = None
+    call_count: int = 0
+    usage: dict[str, int] = field(default_factory=_usage_totals)
+
+    def record(self, usage: dict[str, int] | None = None) -> None:
+        self.call_count += 1
+        if usage is None:
+            return
+        normalized = _require_usage(usage)
+        for name, value in normalized.items():
+            self.usage[name] += value
+
+    def has_safe_boundary_stop(self) -> bool:
+        return ((self.max_calls is not None and self.call_count >= self.max_calls) or
+                (self.max_tokens is not None and self.usage["total_tokens"] >= self.max_tokens))
+
+
+class ProposalObservability:
+    """Durable per-provider-call proposal evidence and aggregate raw usage."""
+
+    def __init__(self, *, event_log_root: Path, durable_failure_root: Path, budget: ProposalCallBudget | None = None):
+        self.event_log_root = event_log_root
+        self.durable_failure_root = durable_failure_root
+        self.events: list[dict[str, Any]] = []
+        self.budget = budget or ProposalCallBudget()
+        self._temporary_root: Path | None = None
+
+    @classmethod
+    def local_for_test(
+        cls,
+        *,
+        event_log_root: Path | None = None,
+        durable_failure_root: Path | None = None,
+    ) -> "ProposalObservability":
+        root = Path(tempfile.mkdtemp(prefix="orizu-ali1505-proposal-events-"))
+        result = cls(
+            event_log_root=event_log_root or root / "events",
+            durable_failure_root=durable_failure_root or root / "durable-failures",
+        )
+        result._temporary_root = root
+        atexit.register(shutil.rmtree, root, ignore_errors=True)
+        return result
+
+    def bind_budget(self, budget: ProposalCallBudget) -> None:
+        self.budget = budget
+
+    def close(self) -> None:
+        if self._temporary_root is not None:
+            shutil.rmtree(self._temporary_root, ignore_errors=True)
+            self._temporary_root = None
+
+    def __del__(self) -> None:
+        self.close()
+
+    def _append_event(self, event: dict[str, Any]) -> None:
+        self.event_log_root.mkdir(parents=True, exist_ok=True)
+        with (self.event_log_root / "events.jsonl").open("a", encoding="utf-8") as handle:
+            handle.write(json.dumps(event, sort_keys=True) + "\n")
+        self.events.append(event)
+
+    def _write_durable_failure(self, *, code: str, detail: str, correlation_id: str | None = None) -> None:
+        try:
+            self.durable_failure_root.mkdir(parents=True, exist_ok=True)
+            payload: dict[str, Any] = {"source": "skilled_proposer", "code": code, "detail": detail}
+            if correlation_id is not None:
+                payload["correlation_id"] = correlation_id
+            (self.durable_failure_root / "latest.json").write_text(
+                json.dumps(payload, sort_keys=True) + "\n", encoding="utf-8",
+            )
+        except Exception:
+            # The original delivery failure remains the actionable error.  A
+            # second durable-store failure cannot be made durable by retrying it.
+            return
+
+    def record_success(self, event: dict[str, Any], usage: dict[str, int]) -> None:
+        self.budget.record(usage)
+        self._append_event(event)
+
+    def record_provider_failure(
+        self,
+        event: dict[str, Any],
+        *,
+        code: str,
+        detail: str,
+        usage: dict[str, int] | None = None,
+    ) -> None:
+        self.budget.record(usage)
+        self._write_durable_failure(code=code, detail=detail, correlation_id=event.get("correlation_id"))
+        self._append_event(event)
+
+    def record_event_failure(self, error: Exception, *, correlation_id: str) -> None:
+        self._write_durable_failure(
+            code="proposal_observability_event_failed", detail=str(error), correlation_id=correlation_id,
+        )
+
+    def terminal_stats(self) -> dict[str, Any]:
+        return {"call_count": self.budget.call_count, "usage": dict(self.budget.usage)}
+
+    def terminal_lm_stats(self) -> dict[str, int]:
+        return {
+            "total_tokens_in": self.budget.usage["input_tokens"],
+            "total_tokens_out": self.budget.usage["output_tokens"],
+            "total_tokens": self.budget.usage["total_tokens"],
+        }
+
+    def write_terminal_lm_stats_artifact(self) -> str:
+        self.event_log_root.mkdir(parents=True, exist_ok=True)
+        path = self.event_log_root / "lm_stats.json"
+        path.write_text(json.dumps(self.terminal_lm_stats(), sort_keys=True) + "\n", encoding="utf-8")
+        return str(path)
+
+    def read_durable_failure(self) -> dict[str, Any]:
+        return json.loads((self.durable_failure_root / "latest.json").read_text(encoding="utf-8"))
+
+    def has_safe_boundary_stop(self) -> bool:
+        return self.budget.has_safe_boundary_stop()
+
+
+def _reject(message: str, *, code: str = "proposal_dspy_request_rejected") -> Any:
+    return _require_dspy().LMError(message, code=code)
+
+
+def _provider_messages(request: "dspy_types.LMRequest") -> list[dict[str, str]]:
+    if request.tools:
+        raise _reject("proposal_dspy_request_rejected: tools are not supported")
+    messages: list[dict[str, str]] = []
+    for message in request.messages:
+        dumped = message.model_dump()
+        role = dumped.get("role")
+        if role not in _SUPPORTED_ROLES:
+            raise _reject(f"proposal_dspy_request_rejected: unsupported message role {role!r}")
+        text_parts: list[str] = []
+        for part in dumped.get("parts", []):
+            if part.get("type") != "text" or not isinstance(part.get("text"), str):
+                raise _reject("proposal_dspy_request_rejected: only text message parts are supported")
+            text_parts.append(part["text"])
+        if not text_parts:
+            raise _reject("proposal_dspy_request_rejected: text messages must contain at least one text part")
+        messages.append({"role": role, "content": "".join(text_parts)})
+    return messages
+
+
+def _request_config(request: "dspy_types.LMRequest", base: TextGepaConfig) -> TextGepaConfig:
+    config = request.config
+    unsupported = {
+        name: value
+        for name, value in config.model_dump().items()
+        if name not in _ALLOWED_DSPY_REQUEST_FIELDS and value not in (None, {})
+    }
+    if unsupported:
+        raise _reject("proposal_dspy_request_rejected: unsupported DSPy generation configuration")
+    cache = config.cache
+    if cache is not None and (getattr(cache, "enabled", False) or getattr(cache, "rollout_id", None) is not None):
+        raise _reject("proposal_dspy_cache_rejected: proposal response caching is disabled", code="proposal_dspy_cache_rejected")
+    changes: dict[str, Any] = {}
+    if config.temperature is not None:
+        changes["reflection_temperature"] = config.temperature
+    if config.max_tokens is not None:
+        if config.max_tokens <= 0:
+            raise _reject("proposal_dspy_request_rejected: max_tokens must be positive")
+        changes["reflection_max_tokens"] = config.max_tokens
+    return dataclasses.replace(base, **changes) if changes else base
+
+
+def _loopback_endpoint(endpoint: str) -> str:
+    parsed = urlparse(endpoint)
+    if parsed.scheme not in {"http", "https"} or parsed.hostname not in {"127.0.0.1", "::1", "localhost"}:
+        raise ValueError("ALI_1505_BRIDGE_ENDPOINT_OVERRIDE_NOT_LOOPBACK")
+    if parsed.username or parsed.password:
+        raise ValueError("ALI_1505_BRIDGE_ENDPOINT_OVERRIDE_INVALID")
+    return endpoint
+
+
+class OrizuSkilledProposerLM(_DspyBaseLM):
+    """A typed DSPy LM whose only completion path is Orizu's provider transport."""
+
+    forward_contract = "typed_lm"
+
+    def __init__(
+        self,
+        *,
+        config: TextGepaConfig,
+        observability: ProposalObservability,
+        endpoint_override: str | None = None,
+        ssl_cert_file: str | None = None,
+    ) -> None:
+        # Provider retries belong exclusively to the frozen transport.  DSPy
+        # must not retry after a durable-event failure and create unrecorded
+        # duplicate proposal attempts.
+        _require_dspy().BaseLM.__init__(
+            self,
+            config.reflection_model,
+            temperature=config.reflection_temperature,
+            max_tokens=config.reflection_max_tokens,
+            cache=False,
+            num_retries=0,
+        )
+        self._config = config
+        self._observability = observability
+        self._endpoint_override = _loopback_endpoint(endpoint_override) if endpoint_override else None
+        self._ssl_cert_file = ssl_cert_file
+
+    def forward(self, request: "dspy_types.LMRequest") -> "dspy_types.LMResponse":
+        dspy_module = _require_dspy()
+        correlation_id = uuid.uuid4().hex
+        if request.model != self.model:
+            raise _reject(
+                "proposal_dspy_model_rejected: requested model differs from the configured reflection model",
+                code="proposal_dspy_model_rejected",
+            )
+        messages = _provider_messages(request)
+        config = _request_config(request, self._config)
+        try:
+            completion: ProviderCompletion = complete_reflection_messages(
+                model=self.model,
+                messages=messages,
+                config=config,
+                endpoint_override=self._endpoint_override,
+                ssl_cert_file=self._ssl_cert_file,
+                # The explicit loopback harness must never receive a real
+                # provider credential from this process.
+                api_key_override="loopback-test-key" if self._endpoint_override else None,
+            )
+        except Exception as error:
+            provider_code = getattr(error, "code", None)
+            failure_usage = getattr(error, "usage", None)
+            failure_event = {
+                "source": "skilled_proposer",
+                "status": "failure",
+                "attempt": 1,
+                "correlation_id": correlation_id,
+                "provider": "openai" if self.model.startswith("openai/") else "anthropic",
+                "cache_state": "disabled",
+                "failure_code": provider_code or "ALI_1505_PROPOSAL_TRANSPORT_FAILURE",
+            }
+            if failure_usage is not None:
+                failure_event["usage"] = failure_usage
+            try:
+                self._observability.record_provider_failure(
+                    failure_event,
+                    code="proposal_provider_transport_failed",
+                    detail=str(error),
+                    usage=failure_usage,
+                )
+            except Exception as event_error:
+                self._observability.record_event_failure(event_error, correlation_id=correlation_id)
+                raise RuntimeError("proposal_observability_event_failed") from event_error
+            raise dspy_module.LMError(
+                f"proposal_provider_transport_failed: {error}",
+                code="proposal_provider_transport_failed",
+                model=self.model,
+                provider="orizu",
+                provider_code=provider_code,
+            ) from error
+
+        usage = _require_usage(completion.usage)
+        success_event = {
+            "source": "skilled_proposer",
+            "status": "success",
+            "attempt": 1,
+            "correlation_id": correlation_id,
+            "provider": completion.provider,
+            "model": self.model,
+            "request_id": completion.request_id,
+            "latency_ms": completion.latency_ms,
+            "usage": usage,
+            "cache_state": "disabled",
+        }
+        try:
+            self._observability.record_success(success_event, usage)
+        except Exception as error:
+            self._observability.record_event_failure(error, correlation_id=correlation_id)
+            raise RuntimeError("proposal_observability_event_failed") from error
+        return dspy_module.LMResponse.from_text(completion.text, model=self.model, usage=usage, cache_hit=False)
+
+
+def make_skilled_proposer_bridge(
+    *,
+    config: TextGepaConfig,
+    observability: ProposalObservability,
+    budget: ProposalCallBudget,
+    endpoint_override: str | None = None,
+    ssl_cert_file: str | None = None,
+) -> OrizuSkilledProposerLM:
+    """Create the cache-disabled typed LM passed to unmodified SkilledProposer."""
+    observability.bind_budget(budget)
+    return OrizuSkilledProposerLM(
+        config=config,
+        observability=observability,
+        endpoint_override=endpoint_override,
+        ssl_cert_file=ssl_cert_file,
+    )
+
+
+def make_skilled_proposer_from_environment(
+    *,
+    config: TextGepaConfig,
+    observability: ProposalObservability,
+    budget: ProposalCallBudget | None = None,
+    endpoint_override: str | None = None,
+) -> Any | None:
+    """Create the opt-in proposer only for the exact selected environment value."""
+    if os.environ.get(_SELECTION_ENV) != _SELECTION_VALUE:
+        return None
+    from skilled_proposer import SkilledProposer
+
+    bridge = make_skilled_proposer_bridge(
+        config=config,
+        observability=observability,
+        budget=budget or ProposalCallBudget(),
+        endpoint_override=endpoint_override,
+        ssl_cert_file=os.environ.get("SSL_CERT_FILE"),
+    )
+    return SkilledProposer(prompt_model=bridge)

package/vendor/orizu-gepa/src/orizu_gepa_connector/stop_conditions.py

@@ -0,0 +1,55 @@
+"""GEPA stop conditions that preserve Orizu's iteration boundaries."""
+
+from collections.abc import Callable
+
+
+class IterationBoundaryStopper:
+    def __init__(self, max_iterations: int):
+        self.max_iterations = max_iterations
+
+    def __call__(self, state):
+        # GEPA's real loop starts at i=-1. Let it enter and complete the first
+        # iteration so this red is raised from the engine boundary, not test setup.
+        return state.i >= self.max_iterations - 1
+
+
+class MandatoryLoggingStopper:
+    """Stop at GEPA's next safe boundary after a durable-log failure."""
+
+    def __init__(self, failure_flag):
+        self.failure_flag = failure_flag
+
+    def __call__(self, state):
+        return bool(self.failure_flag()) and state.i >= 0
+
+
+class MaxCandidateProposalsStopper:
+    """Bound M1's candidate proposals at a safe GEPA boundary.
+
+    A completed iteration can skip reflection and produce no candidate. The
+    callback trace is therefore authoritative; rejected proposals still count.
+    """
+
+    def __init__(self, max_candidate_proposals: int, proposal_count: Callable[[], int]):
+        self.max_candidate_proposals = max_candidate_proposals
+        self.proposal_count = proposal_count
+
+    def __call__(self, state):
+        return self.proposal_count() >= self.max_candidate_proposals
+
+
+class ProposalBudgetStopper:
+    """Stop only between GEPA iterations after an owned proposal budget trips.
+
+    A custom candidate proposer does not pass through GEPA's ``reflection_lm``
+    or its cost tracking.  Its typed DSPy bridge instead records raw provider
+    usage in an Orizu-owned ledger.  This stopper deliberately reads only that
+    ledger and never changes ``state.total_num_evals``: metric-call budgeting
+    remains evaluator-only.
+    """
+
+    def __init__(self, proposal_budget):
+        self.proposal_budget = proposal_budget
+
+    def __call__(self, state):
+        return self.proposal_budget.has_safe_boundary_stop() and state.i >= 0

package/vendor/orizu-gepa/src/orizu_gepa_connector/translator.py

@@ -0,0 +1,203 @@
+"""Translate official-GEPA callbacks into Orizu's established event envelope."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+
+TRUNCATION_MARKER = "…[truncated]"
+
+
+def _candidate_id(value: Any) -> str | None:
+    if value is None:
+        return None
+    return str(value)
+
+
+def _truncate(value: str, limit: int | None) -> tuple[str, bool]:
+    if limit is None or len(value) <= limit:
+        return value, False
+    return value[:limit] + TRUNCATION_MARKER, True
+
+
+def _components(candidate: Any, limit: int | None) -> tuple[dict[str, str], dict[str, int]]:
+    if not isinstance(candidate, dict):
+        return {}, {}
+    result: dict[str, str] = {}
+    truncated: dict[str, int] = {}
+    for key, value in candidate.items():
+        if not isinstance(key, str) or not isinstance(value, str):
+            continue
+        text, did_truncate = _truncate(value, limit)
+        result[key] = text
+        if did_truncate:
+            truncated[f"components.{key}"] = len(value.encode("utf-8"))
+    return result, truncated
+
+
+def _row_results(event: dict[str, Any]) -> list[dict[str, Any]]:
+    scores = event.get("scores_by_val_id") or event.get("scores_by_id") or {}
+    outputs = event.get("outputs_by_val_id") or event.get("outputs_by_id") or {}
+    feedbacks = event.get("feedbacks_by_val_id") or {}
+    errors = event.get("errors_by_val_id") or {}
+    if not isinstance(scores, dict):
+        return []
+    rows = []
+    for row_id, score in scores.items():
+        output = outputs.get(row_id) if isinstance(outputs, dict) else None
+        side_info = output if isinstance(output, dict) else {}
+        adapter_row_id = side_info.get("row_id")
+        if adapter_row_id is None and str(row_id).isdigit():
+            raise ValueError(
+                "official GEPA callback carried positional row id without adapter row identity"
+            )
+        feedback = feedbacks.get(row_id) if isinstance(feedbacks, dict) else None
+        error = errors.get(row_id) if isinstance(errors, dict) else None
+        rows.append({
+            "row_id": str(adapter_row_id if adapter_row_id is not None else row_id),
+            "score": score if isinstance(score, (int, float)) else None,
+            # Official GEPA's typed callback has no feedback fields. The
+            # adapter therefore carries them in its rollout side-info; accept
+            # explicit callback maps too for forward compatibility.
+            "feedback": feedback if feedback is not None else side_info.get("feedback"),
+            "error": error if error is not None else side_info.get("error"),
+            "output": side_info.get("output", output),
+        })
+    return rows
+
+
+def translate_callback(event_name: str, event: dict[str, Any], *, run_id: str, **options: Any) -> dict[str, Any]:
+    """Return an Orizu event for one official callback.
+
+    ``max_payload_chars`` is deliberately characters, not bytes: the payload
+    disclosure retains original UTF-8 byte lengths for auditability.
+    """
+    max_chars = options.get("max_payload_chars")
+    if max_chars is not None and (not isinstance(max_chars, int) or max_chars <= 0):
+        raise ValueError("max_payload_chars must be a positive integer")
+
+    iteration = event.get("iteration")
+    candidate_id = _candidate_id(event.get("candidate_idx", event.get("new_candidate_idx")))
+    parent_ids = event.get("parent_ids")
+    parent_candidate_id = (
+        _candidate_id(parent_ids[0])
+        if isinstance(parent_ids, (list, tuple)) and parent_ids else None
+    )
+    candidate = (
+        event.get("candidate")
+        or event.get("new_instructions")
+        or event.get("seed_candidate")
+        or event.get("parent_candidate")
+        or {}
+    )
+    components, truncation = _components(candidate, max_chars)
+    payload: dict[str, Any] = {"components": components} if components else {}
+    translated_name = event_name.removeprefix("on_")
+    event_type = translated_name
+
+    if event_name == "on_optimization_start":
+        event_type = "run_started"
+        payload.pop("components", None)
+        payload.update({
+            "seed_candidate_text": next(iter(components.values()), None),
+            "seed_components": components,
+            "trainset_size": event.get("trainset_size"),
+            "valset_size": event.get("valset_size"),
+        })
+    elif event_name == "on_iteration_start":
+        event_type = "iteration_started"
+    elif event_name == "on_iteration_end":
+        event_type = "iteration_completed"
+        payload.update({
+            "accepted": event.get("proposal_accepted"),
+            "skipped_reflection": event.get("skipped_reflection", False),
+        })
+    elif event_name == "on_optimization_end":
+        event_type = "run_completed"
+        payload.update({
+            "best_candidate_id": _candidate_id(event.get("best_candidate_idx")),
+            "total_iterations": event.get("total_iterations"),
+            "total_metric_calls": event.get("total_metric_calls"),
+        })
+    elif event_name == "on_candidate_accepted":
+        event_type = "acceptance_decision_made"
+        payload.update({
+            "accepted": True,
+            "proceed_to_valset": True,
+            "parent_score_total": event.get("parent_score_total"),
+            "child_score_total": event.get("child_score_total", event.get("new_score")),
+        })
+    elif event_name == "on_candidate_rejected":
+        event_type = "acceptance_decision_made"
+        payload.update({
+            "accepted": False,
+            "proceed_to_valset": False,
+            "parent_score_total": event.get("parent_score_total", event.get("old_score")),
+            "child_score_total": event.get("child_score_total", event.get("new_score")),
+            "reason": event.get("reason"),
+        })
+    elif event_name == "on_evaluation_skipped":
+        event_type = "reflection_skipped"
+        skipped_scores = event.get("scores") or []
+        payload.update({"reason": event.get("reason"), "parent_score_mean": (sum(skipped_scores) / len(skipped_scores)) if skipped_scores else None})
+    elif event_name == "on_valset_evaluated":
+        is_seed = iteration == 0 and candidate_id in {"0", "seed"}
+        event_type = "seed_val_set_completed" if is_seed else "child_val_set_completed"
+        rows = _row_results(event)
+        payload.update({
+            "candidate_id": "seed" if is_seed else candidate_id,
+            "split": "validation",
+            "score_mean": event.get("average_score"),
+            "row_results": rows,
+            "is_new_best": bool(event.get("is_best_program")),
+        })
+    elif event_name == "on_proposal_end":
+        event_type = "reflection_completed"
+        raw = event.get("raw_lm_outputs")
+        response = next(iter(raw.values()), None) if isinstance(raw, dict) else raw
+        prompts = event.get("prompts")
+        prompt = next(iter(prompts.values()), None) if isinstance(prompts, dict) else prompts
+        payload.update({"prompt": prompt, "response": response, "candidate_text": next(iter(components.values()), None)})
+    elif event_name == "on_budget_updated":
+        budget_kind = options.get("budget_kind", "max_metric_calls")
+        budget_limit = options.get("budget_limit")
+        if budget_kind == "max_metric_calls":
+            used = event.get("metric_calls_used")
+            remaining = event.get("metric_calls_remaining")
+        elif budget_kind == "max_iterations":
+            used = event.get("iteration", 0)
+            remaining = max(0, budget_limit - used) if isinstance(budget_limit, int) else None
+        else:
+            used = event.get("num_full_ds_evals", event.get("iteration", 0))
+            remaining = max(0, budget_limit - used) if isinstance(budget_limit, int) else None
+        event_type = "optimization_progress"
+        payload = {
+            "budget_kind": budget_kind,
+            "used": used,
+            "metric_calls_used": event.get("metric_calls_used"),
+            "metric_calls_remaining": event.get("metric_calls_remaining"),
+            "limit": budget_limit,
+            "budget_limit": budget_limit,
+            "metric_call_budget": options.get("approx_metric_call_limit") if budget_kind != "max_iterations" else None,
+            "remaining": remaining,
+        }
+    elif event_name == "on_merge_attempted":
+        note = {
+            "eventType": "run_note", "eventLayer": "extension", "optimizerFamily": "gepa",
+            "payload": {"code": "unsupported_gepa_merge", "message": "unsupported GEPA merge: two-parent candidates cannot be rendered"},
+        }
+        sink = options.get("run_note_sink")
+        if isinstance(sink, Callable):
+            sink(note)
+        raise ValueError("unsupported GEPA merge: two-parent candidates cannot be rendered")
+
+    if truncation:
+        payload["payload_truncated"] = True
+        payload["truncation"] = {"fields": truncation}
+    return {
+        "runId": run_id, "eventType": event_type, "optimizerFamily": "gepa", "iteration": iteration,
+        "candidateId": "seed" if event_name == "on_valset_evaluated" and iteration == 0 and candidate_id in {"0", "seed"} else candidate_id,
+        "parentCandidateId": parent_candidate_id, "childCandidateId": None,
+        "payload": payload,
+    }

package/vendor/orizu-gepa-python/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools>=68"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "orizu-gepa"
+name = "orizu-gepa-legacy"
 version = "0.1.0"
 description = "Orizu-owned text prompt optimizer with GEPA-style reflection and mandatory live logging."
 requires-python = ">=3.10"

package/vendor/orizu-gepa-python/src/orizu_gepa/cli.py

@@ -276,6 +276,7 @@ def main() -> None:
 
     run_metadata = {
         **metadata,
+        "engine": "legacy",
         "scorer_input_contract": scorer_input_contract,
         "scorer_candidate_output_field": scorer_candidate_output_field,
         "optimizer_package": "orizu-gepa-python",