verifiers 0.1.15.dev179__tar.gz → 0.1.15.dev185__tar.gz

{verifiers-0.1.15.dev179 → verifiers-0.1.15.dev185}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: verifiers
-Version: 0.1.15.dev179
+Version: 0.1.15.dev185
 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.dev179 → verifiers-0.1.15.dev185}/pyproject.toml

@@ -225,6 +225,11 @@ vf-vllm = "verifiers.scripts.vllm:main"
 # hatchling configuration
 [tool.hatch.version]
 source = "vcs"
+# Resolve a version when building without VCS metadata (e.g. the prime-rl
+# Docker build copies the source but not a usable .git for the submodule).
+# Mirrors renderers; without it hatch-vcs raises LookupError and the editable
+# build fails.
+fallback-version = "0.0.0"
 
 [tool.hatch.version.raw-options]
 local_scheme = "no-local-version"

{verifiers-0.1.15.dev179 → verifiers-0.1.15.dev185}/verifiers/v1/harness.py

@@ -220,6 +220,18 @@ class Harness(RuntimeOwnerMixin[ConfigT], Generic[ConfigT]):
     def load_system_prompt(self, config: ConfigT) -> SystemPrompt:
         return config.system_prompt
 
+    def prepare_prompt(self, prompt: Messages, state: State) -> Messages:
+        """Hook to prepare the prompt before each model request.
+
+        Default identity — vf applies no transform of its own. Override in a
+        subclass to return a modified prompt. Applied at the single point every
+        model request passes through (``Runtime.submit_model_request``), so it
+        covers base-program, fn-mode, and host-loop rollouts uniformly. May be
+        sync or async. The returned messages are what the host tokenizes, sends
+        to the model, and records as the trajectory step.
+        """
+        return prompt
+
     def load_program_config(self, config: ConfigT) -> ProgramConfig:
         return config.program.resolve()
 
@@ -521,6 +533,20 @@ class Harness(RuntimeOwnerMixin[ConfigT], Generic[ConfigT]):
                 tool_defs=self.runtime.tool_defs(state),
             )
             turn += 1
+            # Align the local host-loop thread with the exact prompt sent to the model
+            # (which may have been modified by the harness's prepare_prompt hook).
+            trajectory = state.get("trajectory")
+            if isinstance(trajectory, list) and trajectory:
+                last_step = trajectory[-1]
+                if isinstance(last_step, dict):
+                    used_prompt = last_step.get("prompt")
+                    if isinstance(used_prompt, list):
+                        messages = normalize_messages(
+                            cast(Messages, used_prompt), field_name="used_prompt"
+                        )
+                        prompt_messages = [
+                            m.model_dump(exclude_none=True) for m in messages
+                        ]
             messages.extend(await parse_response_message(response))
             rendered_messages = sync_completion()
             tool_calls = list(response.message.tool_calls or [])

{verifiers-0.1.15.dev179 → verifiers-0.1.15.dev185}/verifiers/v1/runtime.py

@@ -883,6 +883,7 @@ class Runtime:
             return self._completed_model_response(state)
         released = False
         try:
+            prompt = await self._prepare_prompt(prompt, state)
             client = self.model_client(state)
             request_start = time.time()
             response = await client.get_response(
@@ -925,6 +926,21 @@ class Runtime:
             if not released:
                 self._release_model_request(state, context)
 
+    async def _prepare_prompt(self, prompt: Messages, state: State) -> Messages:
+        """Apply the harness ``prepare_prompt`` hook (default identity).
+
+        The single point every model request passes through, so a subclass's
+        prompt preparation applies uniformly across base-program, fn-mode, and
+        host-loop rollouts. Tolerates sync or async hooks.
+        """
+        harness = self.harness
+        if harness is None:
+            return prompt
+        result = harness.prepare_prompt(prompt, state)
+        if inspect.isawaitable(result):
+            result = await cast(Awaitable[Messages], result)
+        return result if result is not None else prompt
+
     async def _reserve_model_request(
         self, task: Task, state: State, context: ModelRequestContext
     ) -> bool: