orizu 0.5.19 → 0.5.21

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

@@ -12,6 +12,34 @@ from typing import Any
 from .optimizer import DatasetRow, PromptContext
 
 
+def _instruction_set_from_wire(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    model_config = value.get("modelConfig")
+    components = value.get("components")
+    if not isinstance(model_config, dict) or not isinstance(components, dict):
+        return None
+    normalized_components: dict[str, Any] = {}
+    for key, component in components.items():
+        if isinstance(component, str):
+            normalized_components[key] = component
+        elif isinstance(component, dict):
+            normalized_components[key] = dict(component)
+        else:
+            return None
+    return {
+        "name": value.get("name"),
+        "model_config": model_config,
+        "shape": value.get("shape"),
+        "profile_version_id": value.get("profileVersionId"),
+        "model_config_settings_version_id": value.get("modelConfigSettingsVersionId"),
+        "version_number": value.get("versionNumber"),
+        "prompt_component_key": value.get("promptComponentKey"),
+        "components": normalized_components,
+        "pinned_components": value.get("pinnedComponents") or {},
+    }
+
+
 def _format_number(value: Any) -> str | None:
     if isinstance(value, bool):
         return None
@@ -102,18 +130,25 @@ class OrizuClient:
         *,
         project: str,
         optimizer_version_id: str,
-        prompt_version_id: str,
+        prompt_version_id: str | None,
+        prompt_version_ids: list[str] | None = None,
+        instruction_set_profile_version_id: str | None = None,
         scorer_version_id: str,
         dataset_version_id: str,
         split_set_id: str,
         train_split: str,
         validation_split: str,
+        model_config_settings_version_id: str | None = None,
         metadata: dict[str, Any] | None = None,
     ) -> str:
         query = urllib.parse.urlencode({"project": project})
+        input_prompt_version_ids = sorted(set(prompt_version_ids or ([prompt_version_id] if prompt_version_id else [])))
+        if not input_prompt_version_ids and not instruction_set_profile_version_id:
+            raise RuntimeError("optimization run requires at least one prompt version id")
         data = self._request("POST", f"/api/cli/optimization-runs?{query}", {
             "optimizerVersionId": optimizer_version_id,
-            "promptVersionIds": [prompt_version_id],
+            "promptVersionIds": input_prompt_version_ids,
+            **({"instructionSetProfileVersionId": instruction_set_profile_version_id} if instruction_set_profile_version_id else {}),
             "scorers": [
                 {
                     "scorerVersionId": scorer_version_id,
@@ -129,25 +164,31 @@ class OrizuClient:
             "trainSplitName": train_split,
             "validationSplitName": validation_split,
             "metadata": metadata or {},
+            **({"modelConfigSettingsVersionId": model_config_settings_version_id} if model_config_settings_version_id else {}),
         })
         return data["optimization_run_id"]
 
     def fetch_exec_context(
         self,
         *,
-        prompt_version_id: str,
+        prompt_version_id: str | None,
         runner_version_id: str,
         dataset_version_id: str,
         split_set_id: str,
         split: str,
+        instruction_set_profile_version_id: str | None = None,
     ) -> tuple[PromptContext, list[DatasetRow]]:
-        query = urllib.parse.urlencode({
-            "promptVersion": prompt_version_id,
+        params = {
             "runnerVersion": runner_version_id,
             "datasetVersion": dataset_version_id,
             "splitSet": split_set_id,
             "split": split,
-        })
+        }
+        if prompt_version_id:
+            params["promptVersion"] = prompt_version_id
+        query = urllib.parse.urlencode(params)
+        if instruction_set_profile_version_id:
+            query = f"{query}&" + urllib.parse.urlencode({"instructionSetProfileVersionId": instruction_set_profile_version_id})
         data = self._request("GET", f"/api/cli/runners/exec-context?{query}")
         prompt = data["prompt"]
         rows = [
@@ -158,9 +199,11 @@ class OrizuClient:
             body=prompt.get("body"),
             body_kind=prompt.get("bodyKind") or "text",
             provider_settings=prompt.get("providerSettings") or {},
-            prompt_version_id=prompt["promptVersionId"],
+            prompt_version_id=prompt.get("promptVersionId"),
             runner_version_id=prompt["runnerVersionId"],
             prompt_id=prompt.get("promptId"),
+            instruction_set=_instruction_set_from_wire(data.get("instructionSet")),
+            body_present="body" in prompt,
         ), rows
 
     def fetch_scorer_exec_context(
@@ -200,6 +243,8 @@ class OrizuClient:
             prompt_version_id=prompt["promptVersionId"],
             runner_version_id=prompt["runnerVersionId"],
             prompt_id=prompt.get("promptId"),
+            instruction_set=_instruction_set_from_wire(data.get("instructionSet")),
+            body_present="body" in prompt,
             # The request may use a legacy prompt-version alias. Persist and
             # submit the canonical executable scorer version returned by the
             # server so optimization runs never mix the two ID namespaces.

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

@@ -70,6 +70,17 @@ class LocalOptimizationLogger:
     def append_event(self, event: dict[str, Any]) -> None:
         _append_jsonl(self.directory / "events.jsonl", event)
 
+    def write_preflight(self, *, project: str, verdict: dict[str, Any], kind: str = "preflight_refusal") -> Path:
+        """Write a preflight verdict before or alongside the optimization event stream."""
+        path = self.directory / "preflight.json"
+        _write_json(path, {
+            "schema_version": "orizu.optimization-preflight.v1",
+            "kind": kind,
+            "project": project,
+            "verdict": verdict,
+        })
+        return path
+
     def append_evaluations(
         self,
         *,
@@ -111,6 +122,47 @@ class LocalOptimizationLogger:
             "candidate_text": candidate_text,
         })
 
+    def append_reflection_failure(
+        self,
+        *,
+        iteration: int | None,
+        parent_candidate_id: str | None,
+        row_ids: list[str],
+        error_type: str,
+        error_message: str,
+        gepa_prompt_chars: int,
+        parent_text_chars: int,
+        parent_result_count: int,
+        parent_context_chars: int,
+    ) -> None:
+        """Persist a GEPA-swallowed reflection exception in the shared ledger."""
+        _append_jsonl(self.directory / "reflections.jsonl", {
+            "status": "failed",
+            "iteration": iteration,
+            "parent_candidate_id": parent_candidate_id,
+            "child_candidate_id": None,
+            "row_ids": row_ids,
+            "error_type": error_type,
+            "error_message": error_message,
+            "gepa_prompt_chars": gepa_prompt_chars,
+            "parent_text_chars": parent_text_chars,
+            "parent_result_count": parent_result_count,
+            "parent_context_chars": parent_context_chars,
+        })
+
+    def write_lm_stats(
+        self, *, total_cost: float, total_tokens_in: int, total_tokens_out: int, total_tokens: int,
+    ) -> None:
+        """Record connector reflection usage in the local run's stable JSON form."""
+        _write_json(self.directory / "lm_stats.json", {
+            "reflection": {
+                "total_cost": total_cost,
+                "total_tokens_in": total_tokens_in,
+                "total_tokens_out": total_tokens_out,
+                "total_tokens": total_tokens,
+            },
+        })
+
     def write_result(self, result: TextGepaResult) -> None:
         _write_json(self.directory / "result.json", {
             "optimization_run_id": result.run_id,

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

@@ -81,12 +81,14 @@ class PromptContext:
     body: str | None
     body_kind: str
     provider_settings: dict[str, Any]
-    prompt_version_id: str
+    prompt_version_id: str | None
     runner_version_id: str
     prompt_id: str | None = None
     scorer_version_id: str | None = None
     metric_key: str | None = None
     higher_is_better: bool = True
+    instruction_set: dict[str, Any] | None = None
+    body_present: bool = True
 
 
 @dataclass(frozen=True)
@@ -145,6 +147,9 @@ class ReflectionResult:
     prompt: str
     response: str
     candidate_text: str
+    usage: dict[str, int] | None = None
+    request_id: str | None = None
+    latency_ms: float | None = None
 
 
 class RetryableReflectionError(RuntimeError):
@@ -520,7 +525,7 @@ class TextGepaConfig:
 class TextGepaResult:
     run_id: str
     best_candidate_id: str
-    best_candidate_text: str
+    best_candidate_text: str | dict[str, str]
     best_score: float
     seed_score: float
     promoted_prompt_version_id: str | None
@@ -568,7 +573,7 @@ class EventSink(Protocol):
         ...
 
 
-CandidateRunner = Callable[[str, DatasetRow, PromptContext, str], RunnerCallResult]
+CandidateRunner = Callable[[str | dict[str, str], DatasetRow, PromptContext, str], RunnerCallResult]
 ScorerRunner = Callable[[DatasetRow, RunnerCallResult, PromptContext, str], RunnerCallResult]
 Reflector = Callable[[str, list[RowEvaluation], TextGepaConfig], ReflectionResult]
 
@@ -887,7 +892,7 @@ class EvaluationCache:
     def key(
         self,
         *,
-        candidate_text: str,
+        candidate_text: str | dict[str, str],
         row: DatasetRow,
         split: str,
         prompt_context: PromptContext,
@@ -1106,7 +1111,7 @@ def _candidate_id(iteration: int, text: str) -> str:
 
 def evaluate_candidate(
     *,
-    candidate_text: str,
+    candidate_text: str | dict[str, str],
     candidate_id: str,
     rows: list[DatasetRow],
     split: str,