verifiers 0.3.2.dev119__tar.gz → 0.3.2.dev121__tar.gz

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: verifiers
-Version: 0.3.2.dev119
+Version: 0.3.2.dev121
 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.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/dialects/anthropic.py

@@ -22,7 +22,7 @@ from verifiers.v1.dialects.base import (
     append_user_notice,
     blocked_url,
     parse_sse_event,
-    provider_allowed_domains,
+    provider_domains,
 )
 from verifiers.v1.types import (
     AssistantMessage,
@@ -128,10 +128,14 @@ def parse_content(content) -> str | list[ContentPart]:
     return parts
 
 
-def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str | None:
+def blocked_content_path(
+    value, path: str, policy: NetworkPolicyConfig, blocked_urls: list[str]
+) -> str | None:
     if isinstance(value, list):
         for index, item in enumerate(value):
-            if blocked := blocked_content_path(item, f"{path}[{index}]", policy):
+            if blocked := blocked_content_path(
+                item, f"{path}[{index}]", policy, blocked_urls
+            ):
                 return blocked
         return None
     if not isinstance(value, dict):
@@ -151,11 +155,11 @@ def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str |
         source_kind = source.get("type")
         if source_kind == "content":
             return blocked_content_path(
-                source.get("content"), f"{source_path}.content", policy
+                source.get("content"), f"{source_path}.content", policy, blocked_urls
             )
         if source_kind == "url":
             url = source.get("url")
-            if not isinstance(url, str) or blocked_url(url, policy):
+            if not isinstance(url, str) or blocked_url(url, policy, blocked_urls):
                 return f"{source_path}.url"
         if source_kind == "file":
             return (
@@ -173,13 +177,17 @@ def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str |
     ) and value.get("file_id"):
         return f"{path}.file_id"
     if kind in _CONTENT_WRAPPERS:
-        return blocked_content_path(value.get("content"), f"{path}.content", policy)
+        return blocked_content_path(
+            value.get("content"), f"{path}.content", policy, blocked_urls
+        )
     return None if kind in _SAFE_CONTENT_TYPES else f"{path}.type"
 
 
-def mediate_content(value, path: str, policy: NetworkPolicyConfig):
+def mediate_content(
+    value, path: str, policy: NetworkPolicyConfig, blocked_urls: list[str]
+):
     if not isinstance(value, list):
-        blocked = blocked_content_path(value, path, policy)
+        blocked = blocked_content_path(value, path, policy, blocked_urls)
         return ("", [blocked]) if blocked else (value, [])
 
     mediated = []
@@ -188,17 +196,17 @@ def mediate_content(value, path: str, policy: NetworkPolicyConfig):
         item_path = f"{path}[{index}]"
         if isinstance(block, dict) and block.get("type") in _CONTENT_WRAPPERS:
             if blocked := blocked_content_path(
-                {**block, "content": []}, item_path, policy
+                {**block, "content": []}, item_path, policy, blocked_urls
             ):
                 capabilities.append(blocked)
                 continue
             content, removed = mediate_content(
-                block.get("content"), f"{item_path}.content", policy
+                block.get("content"), f"{item_path}.content", policy, blocked_urls
             )
             if removed:
                 block["content"] = content or ""
                 capabilities.extend(removed)
-        elif blocked := blocked_content_path(block, item_path, policy):
+        elif blocked := blocked_content_path(block, item_path, policy, blocked_urls):
             capabilities.append(blocked)
             continue
         mediated.append(block)
@@ -451,12 +459,15 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
     ) -> tuple[RawRequest, list[str]]:
         mediated = body
         capabilities: list[str] = []
+        blocked_urls: list[str] = []
 
         for key in ("container", "mcp_servers"):
             if mediated.pop(key, None):
                 capabilities.append(key)
 
-        system, removed = mediate_content(mediated.get("system"), "system", policy)
+        system, removed = mediate_content(
+            mediated.get("system"), "system", policy, blocked_urls
+        )
         capabilities.extend(removed)
         if removed:
             if system:
@@ -471,6 +482,7 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
                 message.get("content"),
                 f"messages[{message_index}].content",
                 policy,
+                blocked_urls,
             )
             capabilities.extend(removed)
             if removed:
@@ -489,9 +501,12 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
                 and _WEB_TOOL_TYPE(kind)
             ):
                 callers = tool.get("allowed_callers")
+                filter_key = "blocked_domains" if policy.block else "allowed_domains"
+                other_key = "allowed_domains" if policy.block else "blocked_domains"
                 domains = (
-                    provider_allowed_domains(policy, tool.get("allowed_domains"))
-                    if tool.get("blocked_domains") in (None, [])
+                    provider_domains(policy, tool.get(filter_key))
+                    # Anthropic does not support combining allow and block filters.
+                    if tool.get(other_key) in (None, [])
                     and (
                         callers is None
                         or isinstance(callers, list)
@@ -502,10 +517,10 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
                 if domains:
                     web_tool = {
                         **tool,
-                        "allowed_domains": domains,
+                        filter_key: domains,
                         "allowed_callers": ["direct"],
                     }
-                    web_tool.pop("blocked_domains", None)
+                    web_tool.pop(other_key, None)
                     tools.append(web_tool)
                     continue
                 capabilities.append(f"tools[{index}].type")
@@ -539,7 +554,10 @@ class AnthropicDialect(Dialect[AnthropicMessage]):
             )
             mediated.pop("tool_choice", None)
 
-        append_user_notice(mediated.setdefault("messages", []))
+        if capabilities:
+            append_user_notice(
+                mediated.setdefault("messages", []), blocked_urls=blocked_urls
+            )
         return mediated, capabilities
 
     def is_terminal_event(self, chunk: bytes) -> bool:

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/dialects/base.py

@@ -31,13 +31,14 @@ logger = logging.getLogger(__name__)
 
 PROVIDER_CAPABILITY_POLICY_CODE = "provider_capability_unavailable"
 CAPABILITY_NOTICE = (
-    "Network protocol blocked fetching a resource. Continue without those capabilities; "
-    "use local tools or inline data already present in the conversation, and do not retry "
-    "the blocked provider-side operation."
+    "Some request content or provider-side capabilities were omitted because they are "
+    "blocked by the network policy or cannot enforce it."
 )
 
 
-def blocked_url(value: str, policy: NetworkPolicyConfig) -> bool:
+def blocked_url(
+    value: str, policy: NetworkPolicyConfig, blocked_urls: list[str] | None = None
+) -> bool:
     """Whether a provider-resolved resource is neither inline nor policy-permitted."""
     if value.lower().startswith("data:"):
         return False
@@ -46,17 +47,26 @@ def blocked_url(value: str, policy: NetworkPolicyConfig) -> bool:
     except ValidationError:
         return True
     host = url.host.lower().rstrip(".").strip("[]")
-    return not policy.permits(url.scheme, host, url.port)
+    blocked = not policy.permits(url.scheme, host, url.port)
+    if blocked and blocked_urls is not None:
+        blocked_urls.append(value)
+    return blocked
 
 
-def provider_allowed_domains(
+def provider_domains(
     policy: NetworkPolicyConfig, requested: object = None
 ) -> list[str]:
-    """Translate a network policy to provider domain-filter semantics without widening it."""
-    if policy.block or not policy.allow or "*" in policy.allow:
+    """Translate allow/block rules to provider filters without changing their scope.
+
+    Provider filters include subdomains, so exact hosts need a covering wildcard rule.
+    Empty results mean the policy cannot be represented; never send an empty filter.
+    """
+    rules = policy.block or policy.allow
+    if not rules or "*" in rules:
         return []
     domains = []
-    for rule in policy.allow:
+    hosts = []
+    for rule in rules:
         try:
             url = urlsplit(rule if "://" in rule else f"//{rule}")
             port = url.port
@@ -67,13 +77,23 @@ def provider_allowed_domains(
         if (
             url.scheme
             or port is not None
-            or not host.startswith("*.")
             or not domain
-            or "*" in domain
+            or any(char in domain for char in "*?[]")
             or not domain.isascii()
         ):
             return []
+        hosts.append(host)
         domains.append(domain)
+    for host in hosts:
+        if not host.startswith("*.") and not (
+            policy.block
+            and any(
+                wildcard.startswith("*.")
+                and (host == wildcard[2:] or host.endswith(wildcard[1:]))
+                for wildcard in hosts
+            )
+        ):
+            return []
     domains = list(dict.fromkeys(domains))
     if requested is None:
         return domains
@@ -97,11 +117,13 @@ def provider_allowed_domains(
             or url.query
             or url.fragment
             or not host
-            or "*" in host
+            or any(char in host for char in "*?[]")
             or not host.isascii()
         ):
             return []
         requested_domains.append(host)
+    if policy.block:
+        return list(dict.fromkeys([*domains, *requested_domains]))
     intersection = []
     for allowed in domains:
         for requested_domain in requested_domains:
@@ -115,11 +137,18 @@ def provider_allowed_domains(
 def append_user_notice(
     messages: list,
     *,
+    blocked_urls: list[str],
     text_type: str = "text",
     message_type: str | None = None,
 ) -> None:
-    """Add stable restricted-network context to the earliest user input."""
-    part = {"type": text_type, "text": CAPABILITY_NOTICE}
+    """Explain an actual policy-driven omission in the earliest user input."""
+    notice = CAPABILITY_NOTICE
+    if blocked_urls:
+        notice += "\nBlocked URLs: " + ", ".join(
+            json.dumps(url) for url in dict.fromkeys(blocked_urls)
+        )
+        notice += "\nCircumventing this block is forbidden."
+    part = {"type": text_type, "text": notice}
     for message in messages:
         if not isinstance(message, dict) or message.get("role") != "user":
             continue
@@ -127,9 +156,7 @@ def append_user_notice(
         if isinstance(content, list):
             message["content"] = [*content, part]
         elif isinstance(content, str):
-            message["content"] = (
-                f"{content}\n\n{CAPABILITY_NOTICE}" if content else CAPABILITY_NOTICE
-            )
+            message["content"] = f"{content}\n\n{notice}" if content else notice
         else:
             message["content"] = [part]
         return
@@ -242,9 +269,12 @@ class Dialect(ABC, Generic[RespT]):
     def mediate_external_capabilities(
         self, body: RawRequest, policy: NetworkPolicyConfig
     ) -> tuple[RawRequest, list[str]]:
-        """Remove provider-side capabilities during restricted execution. Implementations add
-        the same policy context on every call because the agent does not retain injected request
-        content. Returned paths never contain request values."""
+        """Filter blocked content and constrain provider tools to the network policy.
+
+        Provider tools execute outside runtime egress controls; remove them when their
+        filters cannot express the policy. Add context only when something is removed.
+        Returned paths never contain request values.
+        """
 
     @abstractmethod
     def parse_request(self, body: RawRequest) -> Request:

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/dialects/chat.py

@@ -383,6 +383,7 @@ class ChatDialect(Dialect[ChatCompletion]):
     ) -> tuple[RawRequest, list[str]]:
         mediated = body
         capabilities: list[str] = []
+        blocked_urls: list[str] = []
 
         if mediated.pop("web_search_options", None) is not None:
             capabilities.append("web_search_options")
@@ -469,7 +470,9 @@ class ChatDialect(Dialect[ChatCompletion]):
                 elif kind == "image_url":
                     image = part.get("image_url") or {}
                     url = image.get("url") if isinstance(image, dict) else image
-                    if not isinstance(url, str) or blocked_url(url, policy):
+                    if not isinstance(url, str) or blocked_url(
+                        url, policy, blocked_urls
+                    ):
                         capability = f"{path}.image_url.url"
                 elif kind == "file":
                     file = part.get("file")
@@ -488,7 +491,7 @@ class ChatDialect(Dialect[ChatCompletion]):
                                 capability = f"{path}.file.file_data"
                             else:
                                 if (parsed.scheme or parsed.netloc) and blocked_url(
-                                    file_data, policy
+                                    file_data, policy, blocked_urls
                                 ):
                                     capability = f"{path}.file.file_data"
                 if capability is None:
@@ -497,7 +500,10 @@ class ChatDialect(Dialect[ChatCompletion]):
                     capabilities.append(capability)
             message["content"] = safe_content or ""
 
-        append_user_notice(mediated.setdefault("messages", []))
+        if capabilities:
+            append_user_notice(
+                mediated.setdefault("messages", []), blocked_urls=blocked_urls
+            )
         return mediated, capabilities
 
     def parse_request(self, body: RawRequest) -> Request:

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/dialects/responses.py

@@ -26,7 +26,7 @@ from verifiers.v1.dialects.base import (
     append_user_notice,
     blocked_url,
     parse_sse_event,
-    provider_allowed_domains,
+    provider_domains,
 )
 from verifiers.v1.errors import model_error
 from verifiers.v1.types import (
@@ -159,15 +159,16 @@ def mediate_tools(
             continue
         kind = tool.get("type")
         if isinstance(kind, str) and _WEB_SEARCH_TOOL_TYPE(kind):
+            filter_key = "blocked_domains" if policy.block else "allowed_domains"
             raw_filters = tool.get("filters")
             if raw_filters is None or isinstance(raw_filters, dict):
-                requested = raw_filters.get("allowed_domains") if raw_filters else None
-                domains = provider_allowed_domains(policy, requested)
+                requested = raw_filters.get(filter_key) if raw_filters else None
+                domains = provider_domains(policy, requested)
             else:
                 domains = []
-            if domains:
+            if domains and len(domains) <= 100:
                 filters = dict(raw_filters) if isinstance(raw_filters, dict) else {}
-                filters["allowed_domains"] = domains
+                filters[filter_key] = domains
                 mediated.append({**tool, "filters": filters})
                 continue
             capabilities.append(f"{item_path}.type")
@@ -198,10 +199,14 @@ def mediate_tools(
     return mediated, capabilities
 
 
-def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str | None:
+def blocked_content_path(
+    value, path: str, policy: NetworkPolicyConfig, blocked_urls: list[str]
+) -> str | None:
     if isinstance(value, list):
         for index, item in enumerate(value):
-            if blocked := blocked_content_path(item, f"{path}[{index}]", policy):
+            if blocked := blocked_content_path(
+                item, f"{path}[{index}]", policy, blocked_urls
+            ):
                 return blocked
         return None
     if not isinstance(value, dict):
@@ -218,7 +223,7 @@ def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str |
             return f"{path}.file_id"
         if "file_url" in value:
             if not isinstance(value["file_url"], str) or blocked_url(
-                value["file_url"], policy
+                value["file_url"], policy, blocked_urls
             ):
                 return f"{path}.file_url"
         elif not isinstance(value.get("file_data"), str):
@@ -227,7 +232,7 @@ def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str |
         if value.get("file_id"):
             return f"{path}.file_id"
         if not isinstance(value.get("image_url"), str) or blocked_url(
-            value["image_url"], policy
+            value["image_url"], policy, blocked_urls
         ):
             return f"{path}.image_url"
 
@@ -253,21 +258,29 @@ def blocked_content_path(value, path: str, policy: NetworkPolicyConfig) -> str |
         "function_call_output",
         "custom_tool_call_output",
     ):
-        return blocked_content_path(value.get("output"), f"{path}.output", policy)
+        return blocked_content_path(
+            value.get("output"), f"{path}.output", policy, blocked_urls
+        )
     if kind in (None, "message") and "role" in value and "content" in value:
-        return blocked_content_path(value["content"], f"{path}.content", policy)
+        return blocked_content_path(
+            value["content"], f"{path}.content", policy, blocked_urls
+        )
     return None if kind in _SAFE_INPUT_TYPES else f"{path}.type"
 
 
-def mediate_content(value, path: str, policy: NetworkPolicyConfig):
+def mediate_content(
+    value, path: str, policy: NetworkPolicyConfig, blocked_urls: list[str]
+):
     if not isinstance(value, list):
-        blocked = blocked_content_path(value, path, policy)
+        blocked = blocked_content_path(value, path, policy, blocked_urls)
         return ("", [blocked]) if blocked else (value, [])
 
     mediated = []
     capabilities = []
     for index, part in enumerate(value):
-        if blocked := blocked_content_path(part, f"{path}[{index}]", policy):
+        if blocked := blocked_content_path(
+            part, f"{path}[{index}]", policy, blocked_urls
+        ):
             capabilities.append(blocked)
             continue
         mediated.append(part)
@@ -418,6 +431,7 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
     ) -> tuple[RawRequest, list[str]]:
         mediated = body
         capabilities: list[str] = []
+        blocked_urls: list[str] = []
 
         for field in ("previous_response_id", "conversation"):
             if mediated.pop(field, None) is not None:
@@ -439,7 +453,7 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                 kind = item.get("type")
                 if kind in ("additional_tools", "tool_search_output"):
                     if blocked := blocked_content_path(
-                        {**item, "tools": []}, item_path, policy
+                        {**item, "tools": []}, item_path, policy, blocked_urls
                     ):
                         capabilities.append(blocked)
                         continue
@@ -461,13 +475,14 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                         item.get(content_field),
                         f"{item_path}.{content_field}",
                         policy,
+                        blocked_urls,
                     )
                     capabilities.extend(removed)
                     if removed:
                         item[content_field] = content or ""
 
                 scan = {**item, content_field: []} if content_field else item
-                blocked = blocked_content_path(scan, item_path, policy)
+                blocked = blocked_content_path(scan, item_path, policy, blocked_urls)
                 if blocked is None:
                     safe_input.append(item)
                 else:
@@ -481,7 +496,7 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                         }
                         safe_input.append(item)
             mediated["input"] = safe_input
-        elif blocked := blocked_content_path(raw_input, "input", policy):
+        elif blocked := blocked_content_path(raw_input, "input", policy, blocked_urls):
             capabilities.append(blocked)
             mediated["input"] = []
 
@@ -517,6 +532,9 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
             capabilities.append("tool_choice")
             mediated.pop("tool_choice")
 
+        if not capabilities:
+            return mediated, capabilities
+
         input_items = mediated.get("input")
         if not isinstance(input_items, list):
             input_items = (
@@ -524,7 +542,12 @@ class ResponsesDialect(Dialect[OpenAIResponse]):
                 if input_items is None
                 else [{"role": "user", "content": input_items}]
             )
-        append_user_notice(input_items, text_type="input_text", message_type="message")
+        append_user_notice(
+            input_items,
+            blocked_urls=blocked_urls,
+            text_type="input_text",
+            message_type="message",
+        )
         mediated["input"] = input_items
         return mediated, capabilities
 

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/harnesses/rlm/harness.py

@@ -69,7 +69,7 @@ class CompactionConfig(BaseConfig):
 
 class RLMHarnessConfig(HarnessConfig):
     version: str = Field(
-        default="fc5734d20c5fe74f6ab527ecb7ab10299f3bb965", min_length=1
+        default="a42cc61ae3356bef82b301c01c6de1cdf302613e", min_length=1
     )
     """Git ref (branch, tag, or commit) of nano-rlm to install. Must know every
     field this harness puts on the wire, i.e. be at least the default ref."""
@@ -92,6 +92,10 @@ class RLMHarnessConfig(HarnessConfig):
     raised to an explicit `max_depth` when needed to keep the policy valid."""
     max_subagent_calls: PositiveInt | None = None
     """Tree-total recursive call cap; `None` uses nano-rlm's default (uncapped)."""
+    delegation_prompt: bool | None = None
+    """Append nano-rlm's delegation guidance (when to spawn children, how to brief,
+    watch, collect and reconcile them) for every agent that can still delegate; `None`
+    uses nano-rlm's default (off)."""
     exec_timeout: PositiveInt | None = None
     """IPython/native tool execution timeout in seconds; `None` uses nano-rlm's
     default (300). Separate from `tool_timeout`, which controls MCP calls."""
@@ -197,6 +201,7 @@ class RLMHarness(ACPHarness[RLMHarnessConfig]):
             "max_depth": self.config.max_depth,
             "max_concurrent_subagents": max_concurrent_subagents,
             "max_subagent_calls": self.config.max_subagent_calls,
+            "delegation_prompt": self.config.delegation_prompt,
             "exec_timeout": self.config.exec_timeout,
             "allow_git": self.config.allow_git,
             "max_total_turns": self.config.max_total_turns,

{verifiers-0.3.2.dev119 → verifiers-0.3.2.dev121}/verifiers/v1/interception/server.py

@@ -392,7 +392,8 @@ class InterceptionServer(Interception):
         capabilities = list(dict.fromkeys(capabilities))
         if capabilities:
             logger.warning(
-                "interception removed provider capabilities: id=%s paths=%s",
+                "interception removed provider content/capabilities blocked by the network "
+                "policy or unable to enforce it: id=%s paths=%s",
                 session.trace.id,
                 ",".join(capabilities),
             )