verifiers 0.2.2.dev67__tar.gz → 0.2.2.dev69__tar.gz

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.2.2.dev67
+Version: 0.2.2.dev69
 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.2.2.dev67 → verifiers-0.2.2.dev69}/tests/v1/test_e2e.py

@@ -104,6 +104,7 @@ async def test_single_turn(run_v1, harness, harness_runtime, tmp_path):
         "echo-v1",
         harness=harness,
         runtime={"type": harness_runtime},
+        env={"agent": {"sampling": {"temperature": 0.0}}},
         output_dir=tmp_path,
         max_turns=2,
     )
@@ -112,7 +113,9 @@ async def test_single_turn(run_v1, harness, harness_runtime, tmp_path):
     assert trace.stop_condition == "agent_completed"
     assert trace.reward == 1.0
     # The seat's resolved identity rides the trace (policy metadata for trainers).
-    assert trace.agent is not None and trace.agent.config.sampling.max_tokens == 2048
+    assert trace.agent is not None
+    assert trace.agent.config.sampling.max_tokens == 2048
+    assert trace.agent.config.sampling.temperature == 0.0
     # Every sampled turn has one per-call record, linked to its assistant node.
     sampled = [i for i, n in enumerate(trace.nodes) if n.sampled]
     assert [c.node for c in trace.calls if c.error is None] == sampled

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/configs/agent.py

@@ -35,7 +35,7 @@ class AgentConfig(BaseConfig):
     client: ClientConfig | None = None
     """Endpoint override (None = the run's client)."""
     sampling: SamplingConfig | None = None
-    """Sampling override (None = the run's sampling)."""
+    """Sampling values merged onto the run's sampling."""
 
     max_turns: int | None = None
     """Max model turns per run (None = no limit)."""

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/env.py

@@ -32,7 +32,7 @@ from verifiers.v1.mcp import SharedToolServer, serve_shared
 from verifiers.v1.runtimes import SubprocessConfig, runtime_is_local
 from verifiers.v1.task import Task
 from verifiers.v1.trace import Error, Trace
-from verifiers.v1.utils.generic import concrete_type
+from verifiers.v1.utils.generic import concrete_type, deep_merge
 from verifiers.v1.utils.memory import trim_memory_periodically
 from verifiers.v1.utils.retries import run_episode_with_retry
 
@@ -204,15 +204,21 @@ class Env(ABC, Generic[ConfigT]):
 
         def make(name: str, spec: AgentConfig) -> Agent:
             # Unpinned fields fall back to the run's ctx / the taskset's harness.
+            sampling = ctx.sampling
+            if spec.sampling is not None:
+                sampling = sampling.model_copy(
+                    update=deep_merge(
+                        sampling.model_dump(exclude_unset=True),
+                        spec.sampling.model_dump(exclude_unset=True),
+                    )
+                )
             resolved = spec.model_copy(
                 update={
                     "harness": spec.harness
                     if spec.harness is not None
                     else self._default_harness,
                     "model": spec.model if spec.model is not None else ctx.model,
-                    "sampling": spec.sampling
-                    if spec.sampling is not None
-                    else ctx.sampling,
+                    "sampling": sampling,
                 }
             )
             return _EpisodeAgent(

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/envs/agentic_judge/env.py

@@ -143,7 +143,7 @@ class JudgeTask(vf.Task):
         self,
         data: vf.TaskData,
         files: dict[str, bytes],
-        artifacts: dict[str, bytes],
+        artifacts: dict[str, bytes | None],
     ) -> None:
         super().__init__(data)
         self.files = files

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/state.py

@@ -9,7 +9,7 @@ from verifiers.v1.utils.generic import concrete_type
 class State(BaseModel):
     model_config = ConfigDict(ser_json_inf_nan="constants")
 
-    artifacts: dict[str, bytes] = Field(default_factory=dict)
+    artifacts: dict[str, bytes | None] = Field(default_factory=dict)
 
 
 StateT = TypeVar("StateT", bound=State, default=State)

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/tasksets/harbor/taskset.py

@@ -396,7 +396,11 @@ def parse_verifier_extras(
         # no such directory (the trace is the record) and Harbor never lets destination
         # affect verifier-side placement, so it cannot change any grading outcome.
         artifacts.append(
-            Artifact(source=entry.source, exclude=list(entry.exclude or []))
+            Artifact(
+                source=entry.source,
+                exclude=list(entry.exclude or []),
+                required=False,
+            )
         )
 
     hooks: list[CollectHook] = []

{verifiers-0.2.2.dev67 → verifiers-0.2.2.dev69}/verifiers/v1/utils/artifacts.py

@@ -29,11 +29,12 @@ class Artifact(BaseModel):
     source: str
     exclude: list[str] = Field(default_factory=list)
     """`tar --exclude` patterns, applied when `source` is a directory."""
+    required: bool = True
 
 
 async def collect(
     runtime: Runtime, artifacts: list[Artifact] | None = None
-) -> dict[str, bytes]:
+) -> dict[str, bytes | None]:
     """Tar the convention dir and every declared path out of `runtime`.
 
     Keyed by source path; the values are tar archives. Insertion order is the order
@@ -54,20 +55,42 @@ async def collect(
         for a in artifacts or []
     ]
     convention = PurePosixPath(ARTIFACTS_DIR)
-    sweep = not any(
-        (p := PurePosixPath(a.source)) == convention
-        or p.is_relative_to(convention)
-        or convention.is_relative_to(p)
-        for a in declared
-    )
-    entries = ([Artifact(source=ARTIFACTS_DIR)] if sweep else []) + declared
-
-    collected: dict[str, bytes] = {}
+    declared_paths = [PurePosixPath(artifact.source) for artifact in declared]
+    if convention in declared_paths:
+        entries = declared
+    else:
+        sweep_excludes = [
+            str(path).lstrip("/")
+            for path in declared_paths
+            if path.is_relative_to(convention)
+        ]
+        entries = [
+            Artifact(
+                source=ARTIFACTS_DIR,
+                exclude=sweep_excludes,
+                required=False,
+            )
+        ]
+        for artifact, path in zip(declared, declared_paths, strict=True):
+            if convention.is_relative_to(path):
+                artifact = artifact.model_copy(
+                    update={
+                        "exclude": [
+                            *artifact.exclude,
+                            str(convention).lstrip("/"),
+                        ]
+                    }
+                )
+            entries.append(artifact)
+
+    collected: dict[str, bytes | None] = {}
     budget = MAX_ARTIFACT_BYTES
     for artifact in entries:
         source = artifact.source
-        if (await runtime.run(["test", "-e", source], {})).exit_code != 0:
-            if sweep and source == ARTIFACTS_DIR:
+        exists = f"test -e {shlex.quote(source)} || test -L {shlex.quote(source)}"
+        if (await runtime.run(["sh", "-c", exists], {})).exit_code != 0:
+            if not artifact.required:
+                collected[source] = None
                 continue
             raise RuntimeError(
                 f"declared artifact {source!r} does not exist in the runtime"
@@ -80,7 +103,7 @@ async def collect(
     return collected
 
 
-async def restore(runtime: Runtime, collected: dict[str, bytes]) -> None:
+async def restore(runtime: Runtime, collected: dict[str, bytes | None]) -> None:
     """Extract `collected` in `runtime` at the original absolute paths."""
     if not collected:
         return
@@ -97,6 +120,8 @@ async def restore(runtime: Runtime, collected: dict[str, bytes]) -> None:
     roots = " ".join(shlex.quote(root) for root in collected)
     await _run(runtime, f"rm -rf -- {roots}", "clear artifact roots")
     for root, archive in collected.items():
+        if archive is None:
+            continue
         path = f"/tmp/vf-artifact-{uuid.uuid4().hex}.tar"
         await runtime.write(path, archive)
         await _run(