verifiers 0.1.15.dev164__tar.gz → 0.1.15.dev166__tar.gz

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev164
+Version: 0.1.15.dev166
 Summary: Verifiers: Environments for LLM Reinforcement Learning
 Project-URL: Homepage, https://github.com/primeintellect-ai/verifiers
 Project-URL: Documentation, https://github.com/primeintellect-ai/verifiers

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/tests/test_composable_env.py

@@ -193,25 +193,20 @@ def test_taskset_repr():
     assert "3" in repr(ts)
 
 
-def test_composable_mini_swe_agent_unversioned_package_uses_unpinned_requirement():
-    setup = build_mini_swe_agent_install_script(package="  mini-swe-agent  ")
+def test_composable_mini_swe_agent_install_script_uses_pip_requirement():
+    setup = build_mini_swe_agent_install_script()
 
-    assert (
-        "vf_python_install --target /opt/mini-swe-agent/prefix/site-packages mini-swe-agent"
-        in setup
-    )
-    assert "mini-swe-agent==mini-swe-agent" not in setup
+    assert "mini-swe-agent==2.2.8" in setup
+    assert "files.pythonhosted.org" not in setup
 
 
-def test_composable_opencode_unversioned_release_uses_latest_download_url():
+def test_composable_opencode_install_script_owns_release_download():
     setup = build_opencode_install_script(
-        release="  PrimeIntellect-ai/opencode  ",
         install_ripgrep=False,
     )
 
-    assert "OPENCODE_RELEASE_REPO=PrimeIntellect-ai/opencode" in setup
-    assert "OPENCODE_RELEASE_PATH=releases/latest/download" in setup
-    assert "releases/download/vPrimeIntellect-ai/opencode" not in setup
+    assert "PrimeIntellect-ai/opencode/releases/download/v1.1.63-rl2" in setup
+    assert "tar -xzf /tmp/opencode.tar.gz" in setup
 
 
 @pytest.mark.asyncio

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/tests/test_environment.py

@@ -673,8 +673,8 @@ class TestMaybeRetry:
         rollout_outputs = outputs["outputs"]
         assert env.call_counts[0] == 1  # No retries for non-retryable error
         assert rollout_outputs[0].get("error") is not None
-        error_info = rollout_outputs[0]["error"]
-        assert "ToolError" == error_info["error"]
+        error_data = rollout_outputs[0]["error"]
+        assert "ToolError" == error_data["error"]
 
     @pytest.mark.asyncio
     async def test_error_in_state_after_max_retries_exhausted(
@@ -694,8 +694,8 @@ class TestMaybeRetry:
         rollout_outputs = outputs["outputs"]
         assert env.call_counts[0] == 3  # 1 initial + 2 retries
         assert rollout_outputs[0].get("error") is not None
-        error_info = rollout_outputs[0]["error"]
-        assert "InfraError" == error_info["error"]
+        error_data = rollout_outputs[0]["error"]
+        assert "InfraError" == error_data["error"]
 
 
 class TestEmptyModelResponseErrors:

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/tests/test_v1_config_extension.py

@@ -1156,12 +1156,13 @@ def test_lifecycle_fields_are_framework_managed() -> None:
     task = Task({"prompt": [{"role": "user", "content": "hi"}]}).freeze()
     state = vf.State.for_task(task)
     assert state.uses_v1_contract is True
+    error = vf.Error("boom")
 
     for key, value in {
         "is_completed": True,
         "stop_condition": "done",
         "is_truncated": True,
-        "error": {"message": "boom"},
+        "error": error,
     }.items():
         assert State({key: value})[key] == value
         with pytest.raises(RuntimeError, match="framework-managed"):
@@ -1188,12 +1189,14 @@ def test_lifecycle_fields_are_framework_managed() -> None:
     state._set_completed(True)
     state._set_stop_condition("done")
     state._set_truncated(True)
-    state._set_error({"message": "boom"})
+    with pytest.raises(TypeError, match="vf.Error"):
+        state._set_error(cast(Any, {"message": "boom"}))
+    state._set_error(error)
 
     assert state["is_completed"] is True
     assert state["stop_condition"] == "done"
     assert state["is_truncated"] is True
-    assert state["error"] == {"message": "boom"}
+    assert state["error"] is error
 
 
 def test_toolsets_config_accepts_addressable_map_and_fn_tables() -> None:

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/tests/test_v1_runtime_lifecycle.py

@@ -1646,14 +1646,19 @@ def test_sandbox_program_patch_cannot_set_lifecycle_fields() -> None:
     patch = {
         "stop_condition": "no_tools",
         "is_truncated": True,
-        "error": {"message": "handled"},
+        "error": vf.ErrorData(
+            error="SandboxError",
+            message="handled",
+            error_chain_repr="SandboxError('handled')",
+            error_chain_str="SandboxError",
+        ),
     }
     apply_internal_state_patch(state, patch, mode="base")
 
     assert patch == {}
     assert state["stop_condition"] == "no_tools"
     assert state["is_truncated"] is True
-    assert state["error"] == {"message": "handled"}
+    assert isinstance(state["error"], vf.SandboxError)
 
 
 def test_program_channels_mcp_injects_proxy_into_sandbox_program() -> None:

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/envs/experimental/cli_agent_env.py

@@ -717,7 +717,7 @@ class CliAgentEnv(SandboxMixin, vf.MultiTurnEnv):
         num_turns = len(state.get("trajectory", []))
         stop_condition = state.get("stop_condition", "unknown")
         error = state.get("error")
-        error_info = (
+        error_summary = (
             f"{type(error).__name__}: {truncate(str(error), 80)}" if error else None
         )
         exit_code = state.get("agent_exit_code")
@@ -741,8 +741,8 @@ class CliAgentEnv(SandboxMixin, vf.MultiTurnEnv):
         ]
         if timed_out:
             parts.append("timed_out=True")
-        if error_info:
-            parts.append(f"error={error_info}")
+        if error_summary:
+            parts.append(f"error={error_summary}")
         self.logger.info(" | ".join(parts))
 
     @vf.cleanup

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/envs/experimental/composable/harnesses/__init__.py

@@ -9,7 +9,8 @@ from verifiers.envs.experimental.composable.harnesses.rlm import (
 )
 from verifiers.envs.experimental.composable.harnesses.opencode import (
     DEFAULT_DISABLED_TOOLS,
-    DEFAULT_RELEASE,
+    DEFAULT_RELEASE_REPO,
+    DEFAULT_RELEASE_VERSION,
     DEFAULT_SYSTEM_PROMPT,
     OPENCODE_INSTALL_SCRIPT,
     build_install_script as build_opencode_install_script,
@@ -39,7 +40,8 @@ __all__ = [
     "build_opencode_run_command",
     "OPENCODE_INSTALL_SCRIPT",
     "DEFAULT_DISABLED_TOOLS",
-    "DEFAULT_RELEASE",
+    "DEFAULT_RELEASE_REPO",
+    "DEFAULT_RELEASE_VERSION",
     "DEFAULT_SYSTEM_PROMPT",
     "mini_swe_agent_harness",
     "build_mini_swe_agent_install_script",

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/envs/experimental/composable/harnesses/mini_swe_agent.py

@@ -3,18 +3,15 @@
 from pathlib import PurePosixPath
 import shlex
 
-from harnesses.mini_swe_agent import (
-    MINI_SWE_AGENT_DEFAULT_PACKAGE,
-    build_mini_swe_agent_install_script as build_packaged_mini_swe_agent_install_script,
-)
-
 DEFAULT_INSTALL_DIR = "/opt/mini-swe-agent"
 DEFAULT_PREFIX_DIR = f"{DEFAULT_INSTALL_DIR}/prefix"
 DEFAULT_SITE_PACKAGES_DIR = f"{DEFAULT_PREFIX_DIR}/site-packages"
+DEFAULT_UV_SITE_PACKAGES_DIR = f"{DEFAULT_INSTALL_DIR}/uv-site-packages"
 DEFAULT_MINI_BINARY = f"{DEFAULT_PREFIX_DIR}/bin/mini"
 MINI_SWE_AGENT_CLI_PACKAGE = "mini-swe-agent"
 MINI_SWE_AGENT_CLI_VERSION = "2.2.8"
-DEFAULT_PACKAGE = MINI_SWE_AGENT_DEFAULT_PACKAGE
+MINI_SWE_AGENT_PYTHON_VERSION = "3.11"
+UV_PACKAGE_VERSION = "0.11.7"
 DEFAULT_INSTRUCTION_PATH = "/mini-swe-agent/prompt.txt"
 DEFAULT_SYSTEM_PROMPT_PATH = "/mini-swe-agent/system.txt"
 DEFAULT_LOG_DIR = "/logs/agent"
@@ -27,14 +24,59 @@ DEFAULT_ENVIRONMENT_TIMEOUT = 120
 
 
 def build_mini_swe_agent_install_script(
-    package: str = DEFAULT_PACKAGE,
     prefix_dir: str = DEFAULT_PREFIX_DIR,
+    install_python: bool = True,
 ) -> str:
     """Build the shell script that installs mini-SWE-agent."""
-    return build_packaged_mini_swe_agent_install_script(
-        package=package,
-        prefix_dir=prefix_dir,
-    )
+    install_tools = ""
+    if install_python:
+        # Acquire::Retries=3 mitigates transient archive.ubuntu.com CDN sync
+        # mismatches that fail fresh-sandbox apt-get update mid-rollout.
+        install_tools = """\
+export DEBIAN_FRONTEND=noninteractive
+if ! command -v python3 >/dev/null 2>&1 || ! python3 -m pip --version >/dev/null 2>&1; then
+  apt-get -o Acquire::Retries=3 update -qq
+  apt-get -o Acquire::Retries=3 install -y -qq python3 python3-pip ca-certificates
+fi
+"""
+
+    quoted_prefix_dir = shlex.quote(prefix_dir)
+    site_packages_dir = f"{prefix_dir}/site-packages"
+    package_requirement = f"{MINI_SWE_AGENT_CLI_PACKAGE}=={MINI_SWE_AGENT_CLI_VERSION}"
+    quoted_site_packages_dir = shlex.quote(site_packages_dir)
+    quoted_install_dir = shlex.quote(DEFAULT_INSTALL_DIR)
+    quoted_uv_site_packages_dir = shlex.quote(DEFAULT_UV_SITE_PACKAGES_DIR)
+    quoted_package_requirement = shlex.quote(package_requirement)
+    return f"""\
+set -e
+{install_tools}
+rm -rf {quoted_prefix_dir}
+mkdir -p {quoted_install_dir} {quoted_prefix_dir}/bin {quoted_site_packages_dir} {quoted_uv_site_packages_dir} {shlex.quote(DEFAULT_LOG_DIR)} /mini-swe-agent
+export PIP_CONFIG_FILE=/dev/null
+export PIP_INDEX_URL=https://pypi.org/simple
+export PIP_BREAK_SYSTEM_PACKAGES=1
+unset PIP_EXTRA_INDEX_URL
+PYTHON_BIN="$(command -v python3)"
+MINI_SWE_AGENT_PYTHON="$PYTHON_BIN"
+if ! "$PYTHON_BIN" -c 'import sys; raise SystemExit(sys.version_info < (3, 10))'; then
+  "$PYTHON_BIN" -m pip install --quiet --target {quoted_uv_site_packages_dir} uv=={UV_PACKAGE_VERSION}
+  env PYTHONPATH={quoted_uv_site_packages_dir} "$PYTHON_BIN" -m uv python install {MINI_SWE_AGENT_PYTHON_VERSION}
+  MINI_SWE_AGENT_PYTHON="$(env PYTHONPATH={quoted_uv_site_packages_dir} "$PYTHON_BIN" -m uv python find {MINI_SWE_AGENT_PYTHON_VERSION})"
+fi
+if [ "$MINI_SWE_AGENT_PYTHON" = "$PYTHON_BIN" ]; then
+  "$PYTHON_BIN" -m pip install --quiet --target {quoted_site_packages_dir} {quoted_package_requirement}
+else
+  env PYTHONPATH={quoted_uv_site_packages_dir} "$PYTHON_BIN" -m uv pip install --python "$MINI_SWE_AGENT_PYTHON" --target {quoted_site_packages_dir} {quoted_package_requirement}
+fi
+echo "$MINI_SWE_AGENT_PYTHON" > {quoted_prefix_dir}/python
+cat > {quoted_prefix_dir}/bin/mini <<'EOF'
+#!/usr/bin/env sh
+export PYTHONPATH={shlex.quote(site_packages_dir)}:${{PYTHONPATH:-}}
+exec "$(cat {quoted_prefix_dir}/python)" -m minisweagent.run.mini "$@"
+EOF
+chmod +x {quoted_prefix_dir}/bin/mini
+test -x {quoted_prefix_dir}/bin/mini
+"""
 
 
 def build_mini_swe_agent_run_command(
@@ -133,7 +175,6 @@ def mini_swe_agent_harness(
     system_prompt_path: str = DEFAULT_SYSTEM_PROMPT_PATH,
     log_path: str = DEFAULT_LOG_PATH,
     trajectory_path: str = DEFAULT_TRAJECTORY_PATH,
-    package: str = DEFAULT_PACKAGE,
     config_spec: str = DEFAULT_CONFIG_SPEC,
     model_class: str = DEFAULT_MODEL_CLASS,
     environment_timeout: int = DEFAULT_ENVIRONMENT_TIMEOUT,
@@ -152,9 +193,7 @@ def mini_swe_agent_harness(
     # The system prompt is passed through ComposableEnv as a file and injected
     # into mini's agent.system_template at runtime.
     return Harness(
-        install_script=build_mini_swe_agent_install_script(
-            package=package,
-        ),
+        install_script=build_mini_swe_agent_install_script(),
         run_command=build_mini_swe_agent_run_command(
             agent_workdir=agent_workdir,
             instruction_path=instruction_path,

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/envs/experimental/composable/harnesses/opencode.py

@@ -13,11 +13,10 @@ import json
 import shlex
 from pathlib import Path, PurePosixPath
 
-from harnesses.utils import split_versioned_agent_spec
-
 # ── Defaults ─────────────────────────────────────────────────────────────
 
-DEFAULT_RELEASE = "PrimeIntellect-ai/opencode@1.1.63-rl2"
+DEFAULT_RELEASE_REPO = "PrimeIntellect-ai/opencode"
+DEFAULT_RELEASE_VERSION = "1.1.63-rl2"
 DEFAULT_SYSTEM_PROMPT = (Path(__file__).parent / "prompt.txt").read_text()
 
 DEFAULT_DISABLED_TOOLS = [
@@ -47,7 +46,6 @@ DEFAULT_DISABLED_TOOLS = [
 
 
 def build_install_script(
-    release: str = DEFAULT_RELEASE,
     install_ripgrep: bool = True,
 ) -> str:
     """Build the shell script that installs OpenCode in a sandbox."""
@@ -56,15 +54,6 @@ def build_install_script(
         if install_ripgrep
         else ""
     )
-    release_repo, release_version = split_versioned_agent_spec(release)
-    release_path = "releases/latest/download"
-    if release_version and release_version != "latest":
-        release_tag = (
-            release_version
-            if release_version.startswith("v")
-            else f"v{release_version}"
-        )
-        release_path = f"releases/download/{release_tag}"
     # Acquire::Retries=3 mitigates transient archive.ubuntu.com CDN sync mismatches
     # (e.g. "File has unexpected size ... Mirror sync in progress?"). See launchpad
     # bug #1876035. apt's default retries is 0, so one bad fetch fails the rollout.
@@ -73,9 +62,6 @@ set -e
 apt-get -o Acquire::Retries=3 update -qq && apt-get -o Acquire::Retries=3 install -y -qq curl tar > /dev/null 2>&1
 {rg_install}
 
-OPENCODE_RELEASE_REPO={shlex.quote(release_repo)}
-OPENCODE_RELEASE_PATH={shlex.quote(release_path)}
-
 case "$(uname -m)" in
   x86_64) OPENCODE_ARCH=x64 ;;
   aarch64|arm64) OPENCODE_ARCH=arm64 ;;
@@ -83,7 +69,7 @@ case "$(uname -m)" in
 esac
 
 OPENCODE_ASSET="opencode-linux-$OPENCODE_ARCH.tar.gz"
-OPENCODE_RELEASE_URL="https://github.com/$OPENCODE_RELEASE_REPO/$OPENCODE_RELEASE_PATH/$OPENCODE_ASSET"
+OPENCODE_RELEASE_URL="https://github.com/{DEFAULT_RELEASE_REPO}/releases/download/v{DEFAULT_RELEASE_VERSION}/$OPENCODE_ASSET"
 
 mkdir -p "$HOME/.opencode/bin"
 if [ -x "$HOME/.opencode/bin/opencode" ]; then
@@ -248,7 +234,6 @@ def opencode_harness(
     agent_workdir: str = "/app",
     allow_git: bool = False,
     disable_compaction: bool = True,
-    release: str = DEFAULT_RELEASE,
     instruction_path: str = "/opencode/prompt.txt",
     system_prompt_path: str = "/opencode/system.txt",
     log_path: str = "/opencode/logs.txt",
@@ -275,9 +260,7 @@ def opencode_harness(
             system_prompt = task_system_prompt
 
     return Harness(
-        install_script=build_install_script(
-            release=release,
-        ),
+        install_script=build_install_script(),
         run_command=build_opencode_run_command(
             agent_workdir=agent_workdir,
             prompt_path=instruction_path,

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/types.py

@@ -17,6 +17,8 @@ from typing import (
     cast,
 )
 
+from anthropic import Anthropic, AsyncAnthropic
+from openai import AsyncOpenAI, OpenAI
 from pydantic import (
     AliasChoices,
     BaseModel,
@@ -26,6 +28,8 @@ from pydantic import (
     field_validator,
 )
 
+from verifiers.errors import Error
+
 if TYPE_CHECKING:
     from anthropic.types import RedactedThinkingBlock
     from anthropic.types import ThinkingBlock as AnthropicThinkingBlock
@@ -33,7 +37,6 @@ if TYPE_CHECKING:
     from renderers import RendererConfig
 
     from verifiers.clients import Client
-    from verifiers.errors import Error
 else:
     RedactedThinkingBlock = Any
     AnthropicThinkingBlock = Any
@@ -72,6 +75,7 @@ EndpointApi = Literal[
     "openai_responses",
     "anthropic_messages",
 ]
+EndpointClient: TypeAlias = AsyncOpenAI | OpenAI | AsyncAnthropic | Anthropic
 MessageType = Literal["chat", "completion"]  # deprecated
 
 
@@ -388,8 +392,9 @@ class RolloutTiming(CustomBaseModel):
         )
 
 
-class ErrorInfo(TypedDict):
+class ErrorData(TypedDict):
     error: str
+    message: str
     error_chain_repr: str
     error_chain_str: str
 
@@ -420,7 +425,7 @@ class RolloutOutput(dict):
     # Optional fields
     answer: str
     info: Info
-    error: ErrorInfo | None
+    error: ErrorData | None
     stop_condition: str | None
     trajectory: list["TrajectoryStep"]
     tool_defs: list[Tool]
@@ -489,7 +494,7 @@ class State(dict):
     advantage: float | None
     metrics: dict[str, float] | None
     timing: RolloutTiming | None
-    error: "Error | ErrorInfo | None"
+    error: Error | None
     usage: TokenUsage | None
     usage_tracker: object
     _vf_state_contract: Literal["legacy", "v1"]
@@ -589,7 +594,9 @@ class State(dict):
     def _set_completed(self, value: bool = True) -> None:
         self._set_internal("is_completed", value)
 
-    def _set_error(self, value: Any) -> None:
+    def _set_error(self, value: Error | None) -> None:
+        if value is not None and not isinstance(value, Error):
+            raise TypeError("state.error must be a vf.Error or None.")
         self._set_internal("error", value)
 
     def _set_stop_condition(
@@ -656,7 +663,7 @@ class State(dict):
         api: EndpointApi | ClientType = "chat_completions",
         *,
         sync: bool = False,
-    ) -> object:
+    ) -> EndpointClient:
         from verifiers.v1.utils.endpoint_utils import client_from_state
 
         return client_from_state(self, api, sync=sync)
@@ -848,9 +855,17 @@ class State(dict):
 
     def finalize(self) -> "State":
         self.strip_runtime_handles()
+        self.serialize_error()
         self.assert_serializable()
         return self
 
+    def serialize_error(self) -> None:
+        error = self.get("error")
+        if isinstance(error, Error):
+            from verifiers.utils.error_utils import error_data
+
+            self._set_internal("error", error_data(error))
+
     @classmethod
     def _legacy_for_task(cls, task: Mapping[str, Any]) -> "State":
         state = cls(

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/utils/async_utils.py

@@ -13,7 +13,7 @@ from pydantic import BaseModel
 
 import verifiers as vf
 from verifiers.utils.error_utils import ErrorChain
-from verifiers.utils.error_utils import error_info_to_exception
+from verifiers.utils.error_utils import error_data_to_exception
 from verifiers.utils.logging_utils import print_time
 
 logger = logging.getLogger(__name__)
@@ -168,7 +168,7 @@ def maybe_retry(
             if err and any(isinstance(err, err_type) for err_type in error_types):
                 raise err
             if isinstance(err, Mapping):
-                retry_error = error_info_to_exception(err, error_types)
+                retry_error = error_data_to_exception(err, error_types)
                 if retry_error is not None:
                     raise retry_error
         elif isinstance(result, list):
@@ -177,7 +177,7 @@ def maybe_retry(
                 if err and any(isinstance(err, err_type) for err_type in error_types):
                     raise err
                 if isinstance(err, Mapping):
-                    retry_error = error_info_to_exception(err, error_types)
+                    retry_error = error_data_to_exception(err, error_types)
                     if retry_error is not None:
                         raise retry_error
 

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/utils/env_utils.py

@@ -4,7 +4,15 @@ import logging
 import sys
 from collections.abc import Mapping
 from types import ModuleType, UnionType
-from typing import Callable, Union, cast, get_args, get_origin, get_type_hints
+from typing import (
+    Callable,
+    TypeAlias,
+    Union,
+    cast,
+    get_args,
+    get_origin,
+    get_type_hints,
+)
 
 from pydantic import BaseModel
 from verifiers.envs.environment import Environment
@@ -12,8 +20,13 @@ from verifiers.utils.config_utils import MissingKeyError
 from verifiers.v1.env import Env, EnvConfig
 from verifiers.v1.harness import Harness, HarnessConfig
 from verifiers.v1.taskset import Taskset, TasksetConfig
+from verifiers.v1.types import ConfigData, ConfigValue
 from verifiers.v1.utils.config_utils import coerce_config, explicit_config_data
 
+EnvConfigLoadData: TypeAlias = dict[str, ConfigValue | BaseModel]
+EnvConfigChildInput: TypeAlias = ConfigData | EnvConfigLoadData
+EnvConfigInput: TypeAlias = EnvConfig | ConfigData
+
 
 def load_environment(env_id: str, **env_args) -> Environment:
     logger = logging.getLogger("verifiers.utils.env_utils")
@@ -127,7 +140,7 @@ def caller_module() -> ModuleType:
 def load_taskset(
     env_id: str | None = None,
     *,
-    config: TasksetConfig | Mapping[str, object] | None = None,
+    config: TasksetConfig | ConfigData | None = None,
 ) -> Taskset:
     module = caller_module() if env_id is None else import_env_module(env_id)
     return load_taskset_from_module(module, config=config)
@@ -136,7 +149,7 @@ def load_taskset(
 def load_harness(
     env_id: str | None = None,
     *,
-    config: HarnessConfig | Mapping[str, object] | None = None,
+    config: HarnessConfig | ConfigData | None = None,
 ) -> Harness:
     module = caller_module() if env_id is None else import_env_module(env_id)
     return load_harness_from_module(module, config=config)
@@ -145,7 +158,7 @@ def load_harness(
 def load_taskset_from_module(
     module: ModuleType,
     *,
-    config: TasksetConfig | Mapping[str, object] | None = None,
+    config: TasksetConfig | ConfigData | None = None,
 ) -> Taskset:
     factory = getattr(module, "load_taskset", None)
     if factory is None:
@@ -170,7 +183,7 @@ def load_taskset_from_module(
 def load_harness_from_module(
     module: ModuleType,
     *,
-    config: HarnessConfig | Mapping[str, object] | None = None,
+    config: HarnessConfig | ConfigData | None = None,
 ) -> Harness:
     factory = getattr(module, "load_harness", None)
     if factory is None:
@@ -260,11 +273,11 @@ def env_config_type(annotation: object) -> type[EnvConfig] | None:
 def load_env_config(
     module: ModuleType,
     config_type: type[EnvConfig],
-    value: object,
+    value: EnvConfigInput,
     *,
     child_types: Mapping[str, type[BaseModel]] | None = None,
 ) -> EnvConfig:
-    data: dict[str, object]
+    data: EnvConfigLoadData
     if isinstance(value, config_type):
         data = dict(explicit_config_data(value))
     elif isinstance(value, BaseModel):
@@ -275,7 +288,7 @@ def load_env_config(
     elif not isinstance(value, Mapping):
         raise TypeError("load_environment config must be a mapping or EnvConfig.")
     else:
-        data = dict(explicit_config_data(value))
+        data = dict(value)
     resolved_child_types = (
         env_config_child_types(module, config_type, data)
         if child_types is None
@@ -293,6 +306,8 @@ def load_env_config(
             continue
         if child is None:
             raise TypeError(f"config.{field_name} cannot be None.")
+        if not isinstance(child, BaseModel | dict):
+            raise TypeError(f"config.{field_name} must be a mapping or config object.")
         data[field_name] = child_type.model_validate(explicit_config_data(child))
     config = config_type.model_validate(data)
     for field_name, child_type in resolved_child_types.items():
@@ -308,7 +323,7 @@ def load_env_config(
 def env_config_child_types(
     module: ModuleType,
     config_type: type[EnvConfig],
-    value: Mapping[str, object] | None = None,
+    value: EnvConfigChildInput | None = None,
 ) -> dict[str, type[BaseModel]]:
     child_types: dict[str, type[BaseModel]] = {}
     for field_name, id_field, factory_name, base_type in (

{verifiers-0.1.15.dev164 → verifiers-0.1.15.dev166}/verifiers/utils/error_utils.py

@@ -1,8 +1,7 @@
-from collections.abc import Mapping
-from typing import Callable, cast
+from typing import Callable, TypeGuard, cast
 
 import verifiers as vf
-from verifiers.types import ErrorInfo
+from verifiers.types import ErrorData
 
 
 def get_error_chain(
@@ -56,22 +55,72 @@ class ErrorChain:
         return " -> ".join([repr(e) for e in self.chain])
 
 
-def error_info(error: BaseException) -> ErrorInfo:
+def error_data(error: BaseException) -> ErrorData:
     error_chain = ErrorChain(error)
-    return ErrorInfo(
+    return ErrorData(
         error=type(error).__name__,
+        message=str(error) or type(error).__name__,
         error_chain_repr=repr(error_chain),
         error_chain_str=str(error_chain),
     )
 
 
-def error_info_to_exception(
-    error: Mapping[str, object],
+def is_error_data(value: object) -> TypeGuard[ErrorData]:
+    expected = {"error", "message", "error_chain_repr", "error_chain_str"}
+    if not isinstance(value, dict):
+        return False
+    match value:
+        case {
+            "error": str(),
+            "message": str(),
+            "error_chain_repr": str(),
+            "error_chain_str": str(),
+        }:
+            return set(value) == expected
+    return False
+
+
+def validate_error_data(value: object) -> ErrorData:
+    if not is_error_data(value):
+        raise TypeError(
+            "ErrorData must contain string error, message, error_chain_repr, "
+            "and error_chain_str fields."
+        )
+    return value
+
+
+def error_data_to_exception(
+    error: ErrorData,
     error_types: tuple[type[Exception], ...],
 ) -> Exception | None:
-    chain = str(error.get("error_chain_str") or error.get("error") or "")
-    detail = str(error.get("error_chain_repr") or error.get("error") or "")
+    chain = error["error_chain_str"] or error["error"]
+    detail = error["error_chain_repr"] or error["error"]
     for error_type in error_types:
         if error_type.__name__ in chain:
             return error_type(detail)
     return None
+
+
+def error_from_data(error: ErrorData) -> vf.Error:
+    exception = error_data_to_exception(error, vf_error_types())
+    if isinstance(exception, vf.Error):
+        return exception
+    detail = error["error_chain_repr"] or error["error"]
+    return vf.Error(detail)
+
+
+def vf_error_types() -> tuple[type[vf.Error], ...]:
+    return (
+        vf.BrowserSandboxError,
+        vf.SandboxError,
+        vf.TunnelError,
+        vf.InfraError,
+        vf.EmptyModelResponseError,
+        vf.InvalidModelResponseError,
+        vf.ModelError,
+        vf.ToolParseError,
+        vf.ToolCallError,
+        vf.ToolError,
+        vf.OverlongPromptError,
+        vf.Error,
+    )