selectools 0.25.0__tar.gz → 0.26.0__tar.gz

{selectools-0.25.0/src/selectools.egg-info → selectools-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: selectools
-Version: 0.25.0
+Version: 0.26.0
 Summary: Production-ready Python framework for AI agents with multi-agent graphs, hybrid RAG, guardrails, audit logging, 50 evaluators, and a visual builder. Supports OpenAI, Anthropic, Gemini, Ollama. By NichevLabs.
 Author-email: John Nichev <johnnichev@gmail.com>
 Maintainer-email: NichevLabs <support@nichevlabs.com>
@@ -108,6 +108,19 @@ result = AgentGraph.chain(planner, writer, reviewer).run("Write a blog post")
 # selectools serve agent.yaml
 ```
 
+## What's New in v0.26
+
+### v0.26.0 — Safety Patch & Verified Registry
+
+A mid-bake safety patch plus a fully source-verified model registry.
+
+- **Confirm parser safety fix** — `RegexConfirmParser` treated replies like "se você não pode apagar, tudo bem" / "tú no puedes borrar" as confirmations: the restated-verb branch matched the action verb without checking for negation elsewhere in the reply. A negation token anywhere now vetoes that branch; bare confirms are unaffected. **All `selectools.pending` consumers should upgrade immediately.**
+- **Model registry refresh** — 152 → 115 models, every entry source-verified: claude-fable-5 / opus-4-8 / opus-4-7, the gpt-5.5 family, and the gemini-3.5 line added; retired and shut-down models removed (**BREAKING** if you referenced their registry constants — e.g. `AnthropicModels.CLAUDE_3_5_SONNET` — but those IDs 404 at their providers regardless); `claude-opus-4-1` mispricing corrected ($5/$25 → $15/$75); gpt-5 family context specs fixed (400k/128k); `GeminiEmbeddingProvider` default moved off the retired `text-embedding-004` to `gemini-embedding-001`.
+- **Cache-aware cost calculation** — `calculate_cost(..., cache_read_input_tokens=..., cache_creation_input_tokens=...)` prices prompt-cache traffic at Anthropic's published rates (reads 0.1×, 5-min writes 1.25×); `AnthropicProvider`'s `UsageStats.cost_usd` is now cache-accurate.
+- **Fixes** — A2A returns JSON-RPC -32602 (not HTTP 500) for non-dict `message.parts` elements; Gemini embedding dimension constant corrected to the actual 3072 for `gemini-embedding-001`/`-2` (vectors themselves unchanged); bake-hunt test module no longer requires optional extras in CI.
+
+See `CHANGELOG.md` for the full entry (7,420 tests, 111 examples, 115 models).
+
 ## What's New in v0.25
 
 ### v0.25.0 — Hardening & v1.0 Prep
@@ -659,7 +672,7 @@ report.to_html("report.html")
 - **Advanced Chunking**: Semantic + contextual chunking for better retrieval
 - **Dynamic Tool Loading**: Plugin system with hot-reload support
 - **Response Caching**: InMemoryCache and RedisCache with stats tracking
-- **152 Model Registry**: Type-safe constants with pricing and metadata
+- **115 Model Registry**: Type-safe constants with pricing and metadata
 - **Pre-built Toolbox**: 48 tools for files, data, text, datetime, web, code, search, GitHub, DB, calculator, email, PDF, Slack, Notion, Linear
 - **Persistent Sessions**: 4 backends (JSON file, SQLite, Redis, Supabase) with TTL and cross-session search
 - **Entity Memory**: LLM-based named entity extraction and tracking
@@ -1035,7 +1048,7 @@ See [docs/modules/STREAMING.md](https://github.com/johnnichev/selectools/blob/ma
 ```python
 from selectools.models import OpenAI, Anthropic, Gemini, Ollama
 
-# IDE autocomplete for all 152 models with pricing metadata
+# IDE autocomplete for all 115 models with pricing metadata
 model = OpenAI.GPT_4O_MINI
 print(f"Cost: ${model.prompt_cost}/${model.completion_cost} per 1M tokens")
 print(f"Context: {model.context_window:,} tokens")

{selectools-0.25.0 → selectools-0.26.0}/README.md

@@ -30,6 +30,19 @@ result = AgentGraph.chain(planner, writer, reviewer).run("Write a blog post")
 # selectools serve agent.yaml
 ```
 
+## What's New in v0.26
+
+### v0.26.0 — Safety Patch & Verified Registry
+
+A mid-bake safety patch plus a fully source-verified model registry.
+
+- **Confirm parser safety fix** — `RegexConfirmParser` treated replies like "se você não pode apagar, tudo bem" / "tú no puedes borrar" as confirmations: the restated-verb branch matched the action verb without checking for negation elsewhere in the reply. A negation token anywhere now vetoes that branch; bare confirms are unaffected. **All `selectools.pending` consumers should upgrade immediately.**
+- **Model registry refresh** — 152 → 115 models, every entry source-verified: claude-fable-5 / opus-4-8 / opus-4-7, the gpt-5.5 family, and the gemini-3.5 line added; retired and shut-down models removed (**BREAKING** if you referenced their registry constants — e.g. `AnthropicModels.CLAUDE_3_5_SONNET` — but those IDs 404 at their providers regardless); `claude-opus-4-1` mispricing corrected ($5/$25 → $15/$75); gpt-5 family context specs fixed (400k/128k); `GeminiEmbeddingProvider` default moved off the retired `text-embedding-004` to `gemini-embedding-001`.
+- **Cache-aware cost calculation** — `calculate_cost(..., cache_read_input_tokens=..., cache_creation_input_tokens=...)` prices prompt-cache traffic at Anthropic's published rates (reads 0.1×, 5-min writes 1.25×); `AnthropicProvider`'s `UsageStats.cost_usd` is now cache-accurate.
+- **Fixes** — A2A returns JSON-RPC -32602 (not HTTP 500) for non-dict `message.parts` elements; Gemini embedding dimension constant corrected to the actual 3072 for `gemini-embedding-001`/`-2` (vectors themselves unchanged); bake-hunt test module no longer requires optional extras in CI.
+
+See `CHANGELOG.md` for the full entry (7,420 tests, 111 examples, 115 models).
+
 ## What's New in v0.25
 
 ### v0.25.0 — Hardening & v1.0 Prep
@@ -581,7 +594,7 @@ report.to_html("report.html")
 - **Advanced Chunking**: Semantic + contextual chunking for better retrieval
 - **Dynamic Tool Loading**: Plugin system with hot-reload support
 - **Response Caching**: InMemoryCache and RedisCache with stats tracking
-- **152 Model Registry**: Type-safe constants with pricing and metadata
+- **115 Model Registry**: Type-safe constants with pricing and metadata
 - **Pre-built Toolbox**: 48 tools for files, data, text, datetime, web, code, search, GitHub, DB, calculator, email, PDF, Slack, Notion, Linear
 - **Persistent Sessions**: 4 backends (JSON file, SQLite, Redis, Supabase) with TTL and cross-session search
 - **Entity Memory**: LLM-based named entity extraction and tracking
@@ -957,7 +970,7 @@ See [docs/modules/STREAMING.md](https://github.com/johnnichev/selectools/blob/ma
 ```python
 from selectools.models import OpenAI, Anthropic, Gemini, Ollama
 
-# IDE autocomplete for all 152 models with pricing metadata
+# IDE autocomplete for all 115 models with pricing metadata
 model = OpenAI.GPT_4O_MINI
 print(f"Cost: ${model.prompt_cost}/${model.completion_cost} per 1M tokens")
 print(f"Context: {model.context_window:,} tokens")

{selectools-0.25.0 → selectools-0.26.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "selectools"
-version = "0.25.0"
+version = "0.26.0"
 description = "Production-ready Python framework for AI agents with multi-agent graphs, hybrid RAG, guardrails, audit logging, 50 evaluators, and a visual builder. Supports OpenAI, Anthropic, Gemini, Ollama. By NichevLabs."
 readme = "README.md"
 requires-python = ">=3.9"

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/__init__.py

@@ -1,6 +1,6 @@
 """Public exports for the selectools package."""
 
-__version__ = "0.25.0"
+__version__ = "0.26.0"
 
 # Import submodules (lazy loading for optional dependencies)
 from . import embeddings, evals, guardrails, models, observe, patterns, rag, toolbox

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/a2a/server.py

@@ -94,6 +94,10 @@ def _extract_prompt(parts: List[Dict[str, Any]]) -> str:
     """
     chunks: List[str] = []
     for part in parts:
+        if not isinstance(part, dict):
+            # Defensive: validation rejects non-dict parts up front, but a
+            # stray list element must never crash prompt assembly.
+            continue
         kind = part.get("kind")
         if kind == "text" and isinstance(part.get("text"), str):
             chunks.append(part["text"])
@@ -300,6 +304,8 @@ class A2AServer:
         parts = message.get("parts")
         if not isinstance(parts, list) or not parts:
             return None, "'message.parts' must be a non-empty array"
+        if not all(isinstance(p, dict) for p in parts):
+            return None, "every entry in 'message.parts' must be an object"
         if not any(
             isinstance(p, dict) and p.get("kind") == "text" and isinstance(p.get("text"), str)
             for p in parts

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/embeddings/gemini.py

@@ -16,14 +16,19 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
     """
     Google Gemini embedding provider.
 
-    Supports models: text-embedding-001, text-embedding-004
+    Supports models: gemini-embedding-001, gemini-embedding-2
+
+    Requests do not set ``output_dimensionality``, so vectors come back at
+    each model's default dimensionality (3072 for gemini-embedding-001 and
+    gemini-embedding-2, which support MRL truncation but are not truncated
+    here). See ``_get_model_dimension`` for the full dimension/MRL story.
 
     Example:
         >>> from selectools.embeddings import GeminiEmbeddingProvider
         >>> from selectools.models import Gemini
         >>>
         >>> embedder = GeminiEmbeddingProvider(
-        ...     model=Gemini.Embeddings.EMBEDDING_004.id
+        ...     model=Gemini.Embeddings.EMBEDDING_001.id
         ... )
         >>> embedding = embedder.embed_text("Hello, world!")
         >>> print(f"Dimension: {len(embedding)}")
@@ -31,7 +36,9 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
 
     def __init__(
         self,
-        model: str = "text-embedding-004",
+        # Default changed from text-embedding-004 (retired by Google) to its
+        # documented replacement gemini-embedding-001.
+        model: str = "gemini-embedding-001",
         api_key: Optional[str] = None,
         task_type: str = "retrieval_document",
     ):
@@ -39,7 +46,7 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
         Initialize Gemini embedding provider.
 
         Args:
-            model: Model name (default: text-embedding-004)
+            model: Model name (default: gemini-embedding-001)
             api_key: Google API key (defaults to GEMINI_API_KEY or GOOGLE_API_KEY env var)
             task_type: Task type for embeddings (retrieval_document, retrieval_query,
                       semantic_similarity, classification, clustering)
@@ -64,12 +71,31 @@ class GeminiEmbeddingProvider(EmbeddingProvider):
         self._dimension = self._get_model_dimension()
 
     def _get_model_dimension(self) -> int:
-        """Get the embedding dimension for the model."""
-        if "embedding-004" in self.model or "embedding-001" in self.model:
-            return 768
-        else:
-            logger.warning(f"Unknown Gemini embedding model '{self.model}', assuming dimension 768")
+        """Get the embedding dimension for the model.
+
+        The declared dimension must match what the API actually returns. This
+        provider never passes ``output_dimensionality`` in its requests (see
+        ``embed_text``/``embed_texts``/``embed_query``), so the API returns
+        each model's default, full-size vector:
+
+        - ``gemini-embedding-001`` and ``gemini-embedding-2``: 3072 by
+          default. Both are trained with Matryoshka Representation Learning
+          (MRL), so vectors *can* be truncated server-side (Google recommends
+          768, 1536, or 3072) by passing ``output_dimensionality`` — but this
+          provider does not request truncation, and existing vector store
+          indexes built with it hold 3072-dim vectors. Note that
+          ``gemini-embedding-001`` only normalizes the full 3072-dim output;
+          truncated outputs would need manual re-normalization.
+        - ``text-embedding-004`` (retired by Google): natively 768.
+
+        Source: https://ai.google.dev/gemini-api/docs/embeddings
+        """
+        if "embedding-004" in self.model:
             return 768
+        if "embedding-001" in self.model or "embedding-2" in self.model:
+            return 3072
+        logger.warning(f"Unknown Gemini embedding model '{self.model}', assuming dimension 3072")
+        return 3072
 
     def embed_text(self, text: str) -> List[float]:
         """

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/exceptions.py

@@ -9,7 +9,7 @@ These exceptions provide PyTorch-style error messages with:
 
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any, Dict, Tuple
 
 from .stability import beta, stable
 
@@ -42,6 +42,13 @@ class ToolValidationError(SelectoolsError):
 
         super().__init__(message)
 
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # Exception's default __reduce__ replays ``self.args`` (the rendered
+        # message) into __init__, which raises TypeError for the multi-arg
+        # signature above. Replay the original constructor args instead so
+        # instances survive pickle (multiprocessing, concurrent.futures).
+        return (self.__class__, (self.tool_name, self.param_name, self.issue, self.suggestion))
+
 
 @stable
 class ToolExecutionError(SelectoolsError):
@@ -65,6 +72,11 @@ class ToolExecutionError(SelectoolsError):
 
         super().__init__(message)
 
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # See ToolValidationError.__reduce__ — requires ``error`` itself to
+        # be picklable, which holds for built-in and well-behaved exceptions.
+        return (self.__class__, (self.tool_name, self.error, self.params))
+
 
 @stable
 class ProviderConfigurationError(SelectoolsError):
@@ -89,6 +101,10 @@ class ProviderConfigurationError(SelectoolsError):
 
         super().__init__(message)
 
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # See ToolValidationError.__reduce__.
+        return (self.__class__, (self.provider_name, self.missing_config, self.env_var))
+
 
 @stable
 class MemoryLimitExceededError(SelectoolsError):
@@ -117,6 +133,10 @@ class MemoryLimitExceededError(SelectoolsError):
 
         super().__init__(message)
 
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # See ToolValidationError.__reduce__.
+        return (self.__class__, (self.current, self.limit, self.limit_type))
+
 
 @stable
 class GraphExecutionError(SelectoolsError):
@@ -147,6 +167,11 @@ class GraphExecutionError(SelectoolsError):
 
         super().__init__(message)
 
+    def __reduce__(self) -> Tuple[Any, ...]:
+        # See ToolValidationError.__reduce__ — requires ``error`` itself to
+        # be picklable, which holds for built-in and well-behaved exceptions.
+        return (self.__class__, (self.graph_name, self.node_name, self.error, self.step))
+
 
 @stable
 class BudgetExceededError(SelectoolsError):

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/guardrails/base.py

@@ -87,6 +87,12 @@ class GuardrailError(Exception):
         self.reason = reason
         super().__init__(f"Guardrail '{guardrail_name}' blocked: {reason}")
 
+    def __reduce__(self) -> "tuple[type, tuple[str, str]]":
+        # Default exception pickling replays the rendered message into the
+        # two-arg __init__ and fails; reconstruct from the original args
+        # (same fix family as selectools.exceptions, PR #100).
+        return (self.__class__, (self.guardrail_name, self.reason))
+
 
 __stability__ = "stable"
 

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/knowledge_backends.py

@@ -30,6 +30,8 @@ from .stability import beta
 
 _B64_MARKER = "b64:"
 
+_WRITE_MODES = ("upsert", "update")
+
 
 def _validate_key(key: str) -> None:
     """Reject keys that could cause collisions or storage problems."""
@@ -86,6 +88,12 @@ class SupabaseKnowledgeBackend:
         table_name: Postgres table to use.  Default: ``"selectools_knowledge"``.
         key_column: Primary-key column name.  Default: ``"key"``.
         data_column: Text column holding the blob.  Default: ``"data"``.
+        write_mode: How ``save_bytes`` writes the row.  ``"upsert"`` (default)
+            issues ``INSERT ... ON CONFLICT DO UPDATE`` and is right for the
+            dedicated table below.  ``"update"`` issues a plain
+            ``UPDATE ... WHERE key_column = key`` and requires the row to
+            already exist — use it when reusing a table you don't fully
+            control (see the warning below).
 
     Required table DDL (run once in your Supabase project)::
 
@@ -95,7 +103,10 @@ class SupabaseKnowledgeBackend:
             updated_at timestamptz not null default now()
         );
 
-    To reuse an existing table (e.g. Sheriff's ``users.memory_text``)::
+    To reuse an existing table (e.g. Sheriff's ``users.memory_text``), pass
+    ``write_mode="update"`` — the row must already exist (Sheriff's auth
+    trigger guarantees it; sheriff#302 ships exactly this update-by-key
+    pattern in production)::
 
         SupabaseKnowledgeBackend(
             client,
@@ -103,7 +114,20 @@ class SupabaseKnowledgeBackend:
             table_name="users",
             key_column="user_id",
             data_column="memory_text",
+            write_mode="update",
         )
+
+    .. warning::
+
+        Do **not** use the default ``write_mode="upsert"`` against a table
+        that has NOT NULL columns without defaults beyond the key and data
+        columns (e.g. ``users.email``).  PostgREST translates the upsert to
+        ``INSERT ... ON CONFLICT DO UPDATE``, and Postgres validates NOT NULL
+        constraints on the *proposed insert tuple* **before** conflict
+        arbitration — so the partial-column payload raises
+        ``not_null_violation`` (error 23502) on every save, even when the
+        row already exists and the ``DO UPDATE`` half would never touch the
+        offending column.  ``write_mode="update"`` sidesteps this entirely.
     """
 
     def __init__(
@@ -113,6 +137,7 @@ class SupabaseKnowledgeBackend:
         table_name: str = "selectools_knowledge",
         key_column: str = "key",
         data_column: str = "data",
+        write_mode: str = "upsert",
     ) -> None:
         try:
             import supabase as supabase_lib  # type: ignore[import-untyped]  # noqa: F401
@@ -123,11 +148,14 @@ class SupabaseKnowledgeBackend:
             ) from exc
 
         _validate_key(key)
+        if write_mode not in _WRITE_MODES:
+            raise ValueError(f"write_mode must be one of {_WRITE_MODES}, got {write_mode!r}")
         self._client = client
         self._key = key
         self._table = table_name
         self._key_column = key_column
         self._data_column = data_column
+        self._write_mode = write_mode
 
     def load_bytes(self) -> Optional[bytes]:
         """Return the stored blob for this key, or ``None`` if absent."""
@@ -146,13 +174,37 @@ class SupabaseKnowledgeBackend:
         return _decode_text(str(value))
 
     def save_bytes(self, data: bytes) -> None:
-        """Upsert *data* under this key (idempotent on repeated saves)."""
+        """Write *data* under this key (idempotent on repeated saves).
+
+        ``write_mode="upsert"`` inserts-or-updates the row;
+        ``write_mode="update"`` updates an existing row and raises
+        ``RuntimeError`` when no row matches the key.
+        """
         from datetime import datetime, timezone
 
+        encoded = _encode_text(data)
+        updated_at = datetime.now(timezone.utc).isoformat()
+
+        if self._write_mode == "update":
+            response = (
+                self._client.table(self._table)
+                .update({self._data_column: encoded, "updated_at": updated_at})
+                .eq(self._key_column, self._key)
+                .execute()
+            )
+            if not response.data:
+                raise RuntimeError(
+                    f"write_mode='update' matched no row in {self._table!r} for "
+                    f"{self._key_column}={self._key!r} — the row must pre-exist "
+                    "in update mode (create it first, or use write_mode='upsert' "
+                    "with a dedicated table)"
+                )
+            return
+
         payload = {
             self._key_column: self._key,
-            self._data_column: _encode_text(data),
-            "updated_at": datetime.now(timezone.utc).isoformat(),
+            self._data_column: encoded,
+            "updated_at": updated_at,
         }
         self._client.table(self._table).upsert(payload, on_conflict=self._key_column).execute()
 

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/knowledge_sanitizers.py

@@ -60,12 +60,14 @@ _ROLE_MARKER_RE = re.compile(
 
 # Speaker-label prefix at line start (``Assistant: I'll wire the money``).
 # Inside a remembered-context block this reads as a forged conversation turn.
-# Matches ASCII and fullwidth (U+FF1A) colons.  Indentation is unbounded
+# Matches ASCII and fullwidth (U+FF1A) colons.  Covers English and
+# Brazilian-Portuguese labels (Usuário/Sistema/Assistente/Humano) so
+# pt-BR consumers (Sheriff) need no supplement.  Indentation is unbounded
 # (speaker labels are not markdown structure, so no 0-3 cap) but restricted
 # to same-line whitespace (`[ \t]`, not `\s`) so a match never spans
 # newlines (review finding PR #84).
 _SPEAKER_LABEL_RE = re.compile(
-    r"^([ \t]*)(User|Assistant|System|Human)([ \t]*)([:：])",
+    r"^([ \t]*)(User|Assistant|System|Human|Usu[aá]rio|Sistema|Assistente|Humano)([ \t]*)([:：])",
     re.MULTILINE | re.IGNORECASE,
 )
 
@@ -81,6 +83,25 @@ _FENCE_RE = re.compile(r"^([ \t]{0,3})(`{3,}|~{3,})", re.MULTILINE)
 # backtick, U+02DC SMALL TILDE for the tilde.
 _FENCE_SUBSTITUTES = {"`": "ˋ", "~": "˜"}
 
+# Whitespace already sitting after an opening bracket inside a matched role
+# marker. Collapsed before the defang space is inserted so the rewrite is
+# canonical: ``[INST]`` and ``[  INST]`` both become ``[ INST]``, and
+# re-running the sanitizer is a no-op (idempotency — see _defang_role_marker).
+_POST_BRACKET_WS_RE = re.compile(r"(?<=[\[<])[ \t]+")
+
+
+def _defang_role_marker(match: "re.Match[str]") -> str:
+    """Rewrite a role marker into its canonical defanged form.
+
+    Canonical means a fixed point: applying ``defang_delimiters`` to its own
+    output must change nothing (sheriff#302 review note 9 — the previous
+    naive ``replace("[", "[ ")`` added one more space per pass because
+    ``_ROLE_MARKER_RE``'s ``\\s*`` also matches the already-defanged form,
+    causing per-turn churn in any pipeline that re-sanitizes stored text).
+    """
+    collapsed = _POST_BRACKET_WS_RE.sub("", match.group(0))
+    return collapsed.replace("[", "[ ").replace("<", "< ")
+
 
 @beta
 def defang_delimiters(text: str) -> str:
@@ -89,6 +110,12 @@ def defang_delimiters(text: str) -> str:
     Conservative by design: every rewrite keeps the content human-readable
     and meaning-preserving; only the *structural* interpretation is broken.
 
+    Idempotent: every rewrite produces a fixed point, so
+    ``defang_delimiters(defang_delimiters(x)) == defang_delimiters(x)``.
+    Pipelines that re-sanitize already-stored text on every turn (e.g.
+    Sheriff's per-message knowledge pass) must not churn entries with one
+    extra space per pass (sheriff#302 review note 9).
+
     What is defanged, and why:
 
     1. ``--- Label ---`` and ``--- Label`` lines become ``— Label —`` /
@@ -136,8 +163,12 @@ def defang_delimiters(text: str) -> str:
     s = text or ""
     s = _DELIMITER_RE.sub(r"\1— \2 —", s)
     s = _HALF_DELIMITER_RE.sub(r"\1— \2", s)
-    s = _ROLE_MARKER_RE.sub(lambda m: m.group(0).replace("[", "[ ").replace("<", "< "), s)
-    s = _SPEAKER_LABEL_RE.sub(r"\1\2\3 \4", s)
+    s = _ROLE_MARKER_RE.sub(_defang_role_marker, s)
+    # Canonical single space before the colon (``\3``, any pre-existing
+    # whitespace, is dropped rather than kept): ``User:`` and ``User  :``
+    # both become ``User :``, so re-sanitizing is a no-op (sheriff#302
+    # review note 9 — keeping ``\3`` added one space per pass).
+    s = _SPEAKER_LABEL_RE.sub(r"\1\2 \4", s)
     s = _FENCE_RE.sub(lambda m: m.group(1) + _FENCE_SUBSTITUTES[m.group(2)[0]] * len(m.group(2)), s)
     return s
 

{selectools-0.25.0 → selectools-0.26.0}/src/selectools/loop_detection.py

@@ -50,6 +50,21 @@ class LoopDetectedError(SelectoolsError):
         self.details = details
         super().__init__(message)
 
+    def __reduce__(self) -> "tuple[Any, ...]":
+        # Keyword-only args defeat default exception pickling; rebuild via a
+        # partial-style tuple (same fix family as selectools.exceptions).
+        return (
+            _rebuild_loop_detected_error,
+            (self.args[0] if self.args else "", self.detector, self.details),
+        )
+
+
+def _rebuild_loop_detected_error(
+    message: str, detector: str, details: Dict[str, Any]
+) -> "LoopDetectedError":
+    """Unpickle helper for :class:`LoopDetectedError` (kw-only ctor)."""
+    return LoopDetectedError(message, detector=detector, details=details)
+
 
 @beta
 @dataclass