renderers 0.1.8.dev4__tar.gz → 0.1.8.dev27__tar.gz

renderers-0.1.8.dev27/.github/workflows/publish-dev.yml

@@ -0,0 +1,104 @@
+name: Publish Dev
+
+# Tag every commit on main as ``renderers-v<next>.dev<N>`` and publish the
+# wheel to PyPI as a pre-release. ``<next>`` is the latest release tag with
+# its patch bumped; ``<N>`` is the number of commits since that release so
+# each main commit maps to a unique PEP 440 dev version.
+#
+# Building from the freshly-created tag means hatch-vcs resolves the version
+# cleanly (no ``+gHASH`` local segment), which PyPI requires.
+
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: publish-dev-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  tag:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      tag: ${{ steps.compute.outputs.tag }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Compute next dev tag
+        id: compute
+        run: |
+          set -euo pipefail
+          LATEST_RELEASE=$(git tag --list 'renderers-v*' --sort=-v:refname \
+            | grep -Ev '(dev|rc|a[0-9]|b[0-9])' \
+            | head -1)
+          if [ -z "$LATEST_RELEASE" ]; then
+            echo "No release tag matching 'renderers-v<MAJOR.MINOR.PATCH>' found" >&2
+            exit 1
+          fi
+          BASE=${LATEST_RELEASE#renderers-v}
+          MAJOR=$(echo "$BASE" | cut -d. -f1)
+          MINOR=$(echo "$BASE" | cut -d. -f2)
+          PATCH=$(echo "$BASE" | cut -d. -f3)
+          NEXT="${MAJOR}.${MINOR}.$((PATCH + 1))"
+          N=$(git rev-list --count "${LATEST_RELEASE}..HEAD")
+          TAG="renderers-v${NEXT}.dev${N}"
+          echo "tag=${TAG}" >> "$GITHUB_OUTPUT"
+          echo "Computed tag: ${TAG} (base=${LATEST_RELEASE}, commits=${N})"
+
+      - name: Create and push tag
+        env:
+          TAG: ${{ steps.compute.outputs.tag }}
+        run: |
+          set -euo pipefail
+          if git ls-remote --exit-code --tags origin "refs/tags/${TAG}" >/dev/null 2>&1; then
+            echo "Tag ${TAG} already exists on origin — nothing to do" >&2
+            exit 0
+          fi
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git tag -a "$TAG" -m "Automated dev release ${TAG}"
+          git push origin "$TAG"
+
+  build:
+    needs: tag
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: refs/tags/${{ needs.tag.outputs.tag }}
+
+      - uses: astral-sh/setup-uv@v7
+
+      - name: Build renderers
+        run: uv build
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-dev
+          path: dist/
+          if-no-files-found: error
+          retention-days: 7
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi-prod
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist-dev
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b # v1.14.0

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/.gitignore

@@ -31,3 +31,6 @@ coverage.xml
 .idea/
 .vscode/
 *.swp
+
+# agent harness state
+.claude/

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.8.dev4
+Version: 0.1.8.dev27
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
 Requires-Python: <3.14,>=3.10
-Requires-Dist: fastokens>=0.1.1
+Requires-Dist: fastokens>=0.2.0
 Requires-Dist: jinja2
 Requires-Dist: numpy
 Requires-Dist: openai-harmony>=0.0.8
 Requires-Dist: openai>=1.108.1
+Requires-Dist: prime-pydantic-config>=0.3.0.dev83
 Requires-Dist: tiktoken
 Requires-Dist: transformers>=4.50.0
 Description-Content-Type: text/markdown
@@ -33,7 +34,7 @@ from transformers import AutoTokenizer
 from renderers import create_renderer
 
 tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-8B")
-r = create_renderer(tok, renderer="auto")           # → Qwen3Renderer
+r = create_renderer(tok)                            # → Qwen3Renderer (auto-resolved)
 
 prompt_ids = r.render_ids(
     [{"role": "user", "content": "hi"}],
@@ -87,17 +88,17 @@ Each hand-coded bridge:
 ### Picking a renderer
 
 ```python
-r = create_renderer(tok, renderer="auto")
+r = create_renderer(tok)                # AutoRendererConfig is the implicit default
 ```
 
-Auto-detect matches `tokenizer.name_or_path` against `MODEL_RENDERER_MAP` by **exact match**. Prefix matching is intentionally off — same architecture can ship different chat templates (base vs instruct, fine-tune renames). Fine-tunes must pass `renderer=<name>` explicitly; unknown names fall back to `DefaultRenderer`.
+Auto-detect matches `tokenizer.name_or_path` against `MODEL_RENDERER_MAP` by **exact match**. Prefix matching is intentionally off — same architecture can ship different chat templates (base vs instruct, fine-tune renames). Fine-tunes must pass an explicit typed config (e.g. `Qwen3RendererConfig()`); unknown names fall back to `DefaultRenderer`.
 
 ### Pools
 
 ```python
 from renderers import create_renderer_pool
 
-pool = create_renderer_pool("Qwen/Qwen3-8B", renderer="auto", size=16)
+pool = create_renderer_pool("Qwen/Qwen3-8B", size=16)
 with pool.checkout() as r:
     ids = r.render_ids(messages)
 ```
@@ -124,25 +125,50 @@ Empirical delta on Qwen3.5-35B-A3B + mini-swe-agent-plus, step 0:
 
 Each break fragments a rollout into multiple training samples — every fragment re-encodes its prefix, inflating compute roughly linearly with the number of breaks.
 
-## Compaction overrides
+## Typed renderer configs
 
-`create_renderer` and `create_renderer_pool` accept two constructor-only flags:
+Each renderer accepts a typed pydantic config that pins its template-control kwargs at construction. `create_renderer` and `create_renderer_pool` take one positional `config` argument:
 
 ```python
-preserve_all_thinking: bool = False
-preserve_thinking_between_tool_calls: bool = False
+from renderers import (
+    create_renderer,
+    AutoRendererConfig,
+    Qwen3RendererConfig,
+    GLM5RendererConfig,
+    DefaultRendererConfig,
+)
+
+# Auto-resolve renderer from the tokenizer's model name. Carries the
+# shared preserve_* flags; template kwargs require an explicit choice.
+renderer = create_renderer(tokenizer)
+renderer = create_renderer(tokenizer, AutoRendererConfig(preserve_all_thinking=True))
+
+# Explicit choice — the typed config exposes exactly the fields that
+# renderer's chat template honours.
+renderer = create_renderer(tokenizer, Qwen3RendererConfig(enable_thinking=False))
+renderer = create_renderer(tokenizer, GLM5RendererConfig(clear_thinking=False))
+
+# Default renderer (apply_chat_template fallback) — extra fields are
+# captured via pydantic ``extra="allow"`` and forwarded to the Jinja
+# template; tool / reasoning parsers are typed.
+renderer = create_renderer(
+    tokenizer,
+    DefaultRendererConfig(tool_parser="qwen3", reasoning_parser="think"),
+)
 ```
 
-Defaults preserve byte-identity with the model's chat template. Flipping a flag at construction restores `reasoning_content` the template would otherwise drop:
+Discriminated union: every per-renderer config is a variant of `RendererConfig`, dispatched on the `name` field. Bogus combinations (e.g. `add_vision_id` under `name="qwen3"`) error at construction with a `pydantic.ValidationError`. Downstream pydantic configs (prime-rl orchestrator, verifiers `ClientConfig`) hold a single field typed as `RendererConfig` and inherit the same strict-per-variant validation.
+
+Two shared behaviour flags live on every variant via `_BaseRendererConfig`:
 
-- `preserve_all_thinking=True` — every past assistant's reasoning is kept.
-- `preserve_thinking_between_tool_calls=True` — reasoning is kept on assistants in the in-flight tool cycle (no-op for current renderers; reserved for future templates that drop it).
+- `preserve_all_thinking=True` — every past assistant's `reasoning_content` is kept, even when the chat template would drop it.
+- `preserve_thinking_between_tool_calls=True` — reasoning is kept on assistants in the in-flight tool cycle (post-last-user A-T-…-A block when it contains a tool response). A new user turn closes the block and drops its thinking.
 
-The canonical use case is **compaction**. Injecting a `user` turn like *"summarize the work so far"* puts every prior assistant in a "past cycle", so template-default rules drop their `reasoning_content` before the summarizer sees it. Build the renderer with `preserve_all_thinking=True` to keep reasoning visible end-to-end on those flows. Both flags only ever *add* tokens vs the template default.
+These OR-compose with template-level toggles (e.g. GLM-5 `clear_thinking`, Nemotron-3 `truncate_history_thinking`): either flag saying "keep" wins. preserve_* can only ever *extend* retention — never override a template kwarg into a "drop" decision. The canonical use case is **compaction**: injecting a `user` turn like *"summarize the work so far"* puts every prior assistant in a past cycle, and `preserve_all_thinking=True` keeps reasoning visible end-to-end.
 
 ## `DefaultRenderer`
 
-Fallback for unsupported models. Wraps `apply_chat_template` and accepts `tool_parser` / `reasoning_parser` kwargs (vLLM convention). `bridge_to_next_turn` returns `None` because the template's close is unknown, so multi-turn rollouts fall back to full re-render. Implementing a hand-coded renderer is a few hundred lines of Python (`render_ids` + `parse_response` + `bridge_to_next_turn`) and is the only path that closes the failure modes above by construction.
+Fallback for unsupported models. Wraps `apply_chat_template` and accepts `tool_parser` / `reasoning_parser` (vLLM convention) plus arbitrary Jinja kwargs via `DefaultRendererConfig`'s `extra="allow"`. `bridge_to_next_turn` returns `None` because the template's close is unknown, so multi-turn rollouts fall back to full re-render. Implementing a hand-coded renderer is a few hundred lines of Python (`render_ids` + `parse_response` + `bridge_to_next_turn`) and is the only path that closes the failure modes above by construction.
 
 ## Roadmap
 

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/README.md

@@ -17,7 +17,7 @@ from transformers import AutoTokenizer
 from renderers import create_renderer
 
 tok = AutoTokenizer.from_pretrained("Qwen/Qwen3-8B")
-r = create_renderer(tok, renderer="auto")           # → Qwen3Renderer
+r = create_renderer(tok)                            # → Qwen3Renderer (auto-resolved)
 
 prompt_ids = r.render_ids(
     [{"role": "user", "content": "hi"}],
@@ -71,17 +71,17 @@ Each hand-coded bridge:
 ### Picking a renderer
 
 ```python
-r = create_renderer(tok, renderer="auto")
+r = create_renderer(tok)                # AutoRendererConfig is the implicit default
 ```
 
-Auto-detect matches `tokenizer.name_or_path` against `MODEL_RENDERER_MAP` by **exact match**. Prefix matching is intentionally off — same architecture can ship different chat templates (base vs instruct, fine-tune renames). Fine-tunes must pass `renderer=<name>` explicitly; unknown names fall back to `DefaultRenderer`.
+Auto-detect matches `tokenizer.name_or_path` against `MODEL_RENDERER_MAP` by **exact match**. Prefix matching is intentionally off — same architecture can ship different chat templates (base vs instruct, fine-tune renames). Fine-tunes must pass an explicit typed config (e.g. `Qwen3RendererConfig()`); unknown names fall back to `DefaultRenderer`.
 
 ### Pools
 
 ```python
 from renderers import create_renderer_pool
 
-pool = create_renderer_pool("Qwen/Qwen3-8B", renderer="auto", size=16)
+pool = create_renderer_pool("Qwen/Qwen3-8B", size=16)
 with pool.checkout() as r:
     ids = r.render_ids(messages)
 ```
@@ -108,25 +108,50 @@ Empirical delta on Qwen3.5-35B-A3B + mini-swe-agent-plus, step 0:
 
 Each break fragments a rollout into multiple training samples — every fragment re-encodes its prefix, inflating compute roughly linearly with the number of breaks.
 
-## Compaction overrides
+## Typed renderer configs
 
-`create_renderer` and `create_renderer_pool` accept two constructor-only flags:
+Each renderer accepts a typed pydantic config that pins its template-control kwargs at construction. `create_renderer` and `create_renderer_pool` take one positional `config` argument:
 
 ```python
-preserve_all_thinking: bool = False
-preserve_thinking_between_tool_calls: bool = False
+from renderers import (
+    create_renderer,
+    AutoRendererConfig,
+    Qwen3RendererConfig,
+    GLM5RendererConfig,
+    DefaultRendererConfig,
+)
+
+# Auto-resolve renderer from the tokenizer's model name. Carries the
+# shared preserve_* flags; template kwargs require an explicit choice.
+renderer = create_renderer(tokenizer)
+renderer = create_renderer(tokenizer, AutoRendererConfig(preserve_all_thinking=True))
+
+# Explicit choice — the typed config exposes exactly the fields that
+# renderer's chat template honours.
+renderer = create_renderer(tokenizer, Qwen3RendererConfig(enable_thinking=False))
+renderer = create_renderer(tokenizer, GLM5RendererConfig(clear_thinking=False))
+
+# Default renderer (apply_chat_template fallback) — extra fields are
+# captured via pydantic ``extra="allow"`` and forwarded to the Jinja
+# template; tool / reasoning parsers are typed.
+renderer = create_renderer(
+    tokenizer,
+    DefaultRendererConfig(tool_parser="qwen3", reasoning_parser="think"),
+)
 ```
 
-Defaults preserve byte-identity with the model's chat template. Flipping a flag at construction restores `reasoning_content` the template would otherwise drop:
+Discriminated union: every per-renderer config is a variant of `RendererConfig`, dispatched on the `name` field. Bogus combinations (e.g. `add_vision_id` under `name="qwen3"`) error at construction with a `pydantic.ValidationError`. Downstream pydantic configs (prime-rl orchestrator, verifiers `ClientConfig`) hold a single field typed as `RendererConfig` and inherit the same strict-per-variant validation.
+
+Two shared behaviour flags live on every variant via `_BaseRendererConfig`:
 
-- `preserve_all_thinking=True` — every past assistant's reasoning is kept.
-- `preserve_thinking_between_tool_calls=True` — reasoning is kept on assistants in the in-flight tool cycle (no-op for current renderers; reserved for future templates that drop it).
+- `preserve_all_thinking=True` — every past assistant's `reasoning_content` is kept, even when the chat template would drop it.
+- `preserve_thinking_between_tool_calls=True` — reasoning is kept on assistants in the in-flight tool cycle (post-last-user A-T-…-A block when it contains a tool response). A new user turn closes the block and drops its thinking.
 
-The canonical use case is **compaction**. Injecting a `user` turn like *"summarize the work so far"* puts every prior assistant in a "past cycle", so template-default rules drop their `reasoning_content` before the summarizer sees it. Build the renderer with `preserve_all_thinking=True` to keep reasoning visible end-to-end on those flows. Both flags only ever *add* tokens vs the template default.
+These OR-compose with template-level toggles (e.g. GLM-5 `clear_thinking`, Nemotron-3 `truncate_history_thinking`): either flag saying "keep" wins. preserve_* can only ever *extend* retention — never override a template kwarg into a "drop" decision. The canonical use case is **compaction**: injecting a `user` turn like *"summarize the work so far"* puts every prior assistant in a past cycle, and `preserve_all_thinking=True` keeps reasoning visible end-to-end.
 
 ## `DefaultRenderer`
 
-Fallback for unsupported models. Wraps `apply_chat_template` and accepts `tool_parser` / `reasoning_parser` kwargs (vLLM convention). `bridge_to_next_turn` returns `None` because the template's close is unknown, so multi-turn rollouts fall back to full re-render. Implementing a hand-coded renderer is a few hundred lines of Python (`render_ids` + `parse_response` + `bridge_to_next_turn`) and is the only path that closes the failure modes above by construction.
+Fallback for unsupported models. Wraps `apply_chat_template` and accepts `tool_parser` / `reasoning_parser` (vLLM convention) plus arbitrary Jinja kwargs via `DefaultRendererConfig`'s `extra="allow"`. `bridge_to_next_turn` returns `None` because the template's close is unknown, so multi-turn rollouts fall back to full re-render. Implementing a hand-coded renderer is a few hundred lines of Python (`render_ids` + `parse_response` + `bridge_to_next_turn`) and is the only path that closes the failure modes above by construction.
 
 ## Roadmap
 

renderers-0.1.8.dev27/docs/renderer-config.md

@@ -0,0 +1,163 @@
+# Renderer config
+
+`renderers.RendererConfig` is the typed input to `create_renderer` and
+`create_renderer_pool`. It pins the renderer choice and its template-control
+kwargs at construction.
+
+```python
+from renderers import create_renderer, Qwen35RendererConfig
+
+r = create_renderer(tokenizer, Qwen35RendererConfig(enable_thinking=False))
+```
+
+`RendererConfig` is a pydantic discriminated union (one variant per renderer,
+dispatched on the `name` field). Selecting a variant exposes exactly the
+fields that renderer's chat template honours; anything else raises a
+`pydantic.ValidationError` at construction.
+
+## Per-renderer configs
+
+Each hand-coded renderer has a typed config class with the template kwargs
+its Jinja chat template reads. For example:
+
+| Renderer       | Config class             | Template fields                                                |
+|----------------|--------------------------|----------------------------------------------------------------|
+| Qwen3          | `Qwen3RendererConfig`    | `enable_thinking`                                              |
+| Qwen3.5 / 3.6  | `Qwen35RendererConfig`   | `enable_thinking`, `add_vision_id`                             |
+| Qwen3-VL       | `Qwen3VLRendererConfig`  | `add_vision_id`                                                |
+| GLM-5 / 5.1    | `GLM5RendererConfig`     | `enable_thinking`, `clear_thinking`                            |
+| GLM-4.5        | `GLM45RendererConfig`    | `enable_thinking`                                              |
+| Nemotron-3     | `Nemotron3RendererConfig`| `enable_thinking`, `truncate_history_thinking`                 |
+| Kimi K2.5      | `KimiK25RendererConfig`  | `thinking`                                                     |
+| MiniMax-M2     | `MiniMaxM2RendererConfig`| `model_identity`                                               |
+| Laguna-XS.2    | `LagunaXS2RendererConfig`| `enable_thinking`, `render_assistant_messages_raw`             |
+| gpt-oss        | `GptOssRendererConfig`   | `reasoning_effort`, `conversation_start_date`                  |
+
+Field names mirror the upstream Jinja variable names. Passing
+`Qwen3RendererConfig(add_vision_id=True)` raises — Qwen3 is text-only, so
+the field doesn't exist on its config. Use
+`type(config).template_field_names()` to introspect the fields that mirror
+chat-template kwargs (parity is verified against `apply_chat_template` in
+`tests/test_renderer_config_parity.py`).
+
+Configs are frozen. To override a field, construct a new instance or call
+`config.model_copy(update={...})`.
+
+## Auto-resolution
+
+`create_renderer(tokenizer)` (no config) resolves the renderer from
+`tokenizer.name_or_path` via `MODEL_RENDERER_MAP`:
+
+```python
+r = create_renderer(tokenizer)                                 # AutoRendererConfig() is the default
+r = create_renderer(tokenizer, AutoRendererConfig(preserve_all_thinking=True))
+```
+
+`AutoRendererConfig` carries only the shared `preserve_*` flags. Template
+kwargs depend on the renderer, so overriding them requires naming the
+renderer explicitly:
+
+```python
+r = create_renderer(tokenizer, GLM5RendererConfig(clear_thinking=False))
+```
+
+Auto-resolution fails loudly for VLMs that miss the exact-match lookup —
+`DefaultRenderer` only knows `apply_chat_template` + text tokens, so silently
+falling back for a VLM would produce token streams the trainer can't
+reconstruct. Text-only fine-tunes without a registered renderer fall back to
+`DefaultRenderer` and log the choice at INFO.
+
+## `preserve_*` flags
+
+Every variant carries two renderer-agnostic flags on `_BaseRendererConfig`:
+
+- `preserve_all_thinking: bool = False` — re-emit `reasoning_content` on
+  every past assistant turn, even when the chat template would drop it.
+- `preserve_thinking_between_tool_calls: bool = False` — re-emit
+  `reasoning_content` only inside the in-flight tool cycle (the contiguous
+  A-T-…-A block after the most recent `user` message, when it contains at
+  least one `tool` response). A new user turn closes the block and drops
+  its thinking.
+
+These OR-compose with template-level toggles. GLM-5's `clear_thinking` and
+Nemotron-3's `truncate_history_thinking` already gate past thinking; the
+`preserve_*` flags add to that:
+
+| `clear_thinking` | `preserve_all_thinking` | past thinking? |
+|------------------|-------------------------|----------------|
+| `True` (default — drop) | `False` (default) | dropped |
+| `True`           | `True`                  | kept           |
+| `False` (keep)   | `False`                 | kept           |
+| `False`          | `True`                  | kept           |
+
+`preserve_*` can only extend retention, never force a drop. The canonical
+use case is **compaction**: injecting a `user` turn like *"summarize the work
+so far"* puts every prior assistant in a past cycle, and
+`preserve_all_thinking=True` keeps reasoning visible end-to-end.
+
+## `DefaultRendererConfig` accepts arbitrary Jinja kwargs
+
+`DefaultRenderer` wraps `tokenizer.apply_chat_template` for any model that
+doesn't have a hand-coded renderer. Its config sets `extra="allow"`:
+
+```python
+from renderers import create_renderer, DefaultRendererConfig
+
+r = create_renderer(
+    tokenizer,
+    DefaultRendererConfig(
+        tool_parser="qwen3",                # registered in renderers.parsers
+        reasoning_parser="think",
+        enable_thinking=False,              # forwarded to apply_chat_template
+        custom_jinja_kwarg=True,            # ditto
+    ),
+)
+```
+
+`tool_parser` and `reasoning_parser` are typed because they configure
+`DefaultRenderer`'s own parsing pipeline. Every other field lands in
+`model_extra` and `DefaultRenderer._apply` forwards `model_extra` verbatim
+to `apply_chat_template`.
+
+## Downstream integration
+
+Downstream pydantic configs (`prime-rl` orchestrator, `verifiers`
+`ClientConfig`) hold a single field typed as `RendererConfig`:
+
+```python
+from pydantic import BaseModel, Field
+from renderers import AutoRendererConfig, RendererConfig
+
+class ClientConfig(BaseModel):
+    renderer: RendererConfig = Field(default_factory=AutoRendererConfig)
+```
+
+In TOML / YAML, the discriminator routes deserialization:
+
+```toml
+[client.renderer]
+name = "qwen3.5"
+enable_thinking = false
+add_vision_id = true
+preserve_all_thinking = true
+```
+
+Pydantic dispatches on `name = "qwen3.5"` to `Qwen35RendererConfig`. Bogus
+combinations (e.g. `add_vision_id` under `name = "qwen3"`) raise at
+config-load with a clear message naming the offending field and the variant
+that rejected it.
+
+To construct a config from a renderer name string (e.g. from a CLI flag):
+
+```python
+from renderers import config_from_name
+
+cfg = config_from_name("glm-5")           # → GLM5RendererConfig() with defaults
+cfg = config_from_name("auto")            # → None, the implicit "auto" form
+```
+
+## Renaming a renderer is a breaking change
+
+The discriminator key is the renderer name string. Renaming `"qwen3.5"` to
+something else would break any downstream config that references it by
+name. Add new renderers; don't rename existing ones.

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/pyproject.toml

@@ -26,10 +26,15 @@ dependencies = [
     "openai-harmony>=0.0.8",
     # Crusoe's Rust BPE tokenizer; ~10x faster encode vs HF's tokenizers.
     # ``load_tokenizer`` patches it in by default for every supported model
-    # except a small denylist (DeepSeek-V3 family, MiniMax-M2 family). The
-    # patch is bracketed around ``from_pretrained``, so subsequent
-    # ``AutoTokenizer`` calls outside the renderers package stay vanilla.
-    "fastokens>=0.1.1",
+    # except a small denylist (DeepSeek-V3 family). The patch is bracketed
+    # around ``from_pretrained``, so subsequent ``AutoTokenizer`` calls
+    # outside the renderers package stay vanilla.
+    "fastokens>=0.2.0",
+    # ``BaseRendererConfig`` inherits from ``pydantic_config.BaseConfig`` so
+    # the typed-config surface stays uniform with prime-rl / verifiers config
+    # bases. Transitively brings pydantic, which ``renderers.configs`` also
+    # imports directly.
+    "prime-pydantic-config>=0.3.0.dev83",
 ]
 
 [tool.hatch.version]
@@ -68,6 +73,12 @@ dev = [
 
 [tool.uv]
 exclude-newer = "7 days"
+# fastokens 0.2.0 was published on 2026-05-17 and contains the
+# ``unpatch_transformers`` fix (crusoecloud/fastokens#32) needed for
+# MiniMax-M2's slow→fast tokenizer conversion path. Exempting it from
+# the project-wide 7-day cutoff lets the lockfile pick it up immediately
+# while the rest of the dependency graph stays gated.
+exclude-newer-package = { fastokens = false, "prime-pydantic-config" = false }
 
 [tool.ty.environment]
 python-version = "3.13"

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/renderers/__init__.py

@@ -28,6 +28,7 @@ from renderers.base import (
     ToolCallParseStatus,
     ToolSpec,
     VideoPart,
+    attribute_text_segments,
     build_training_sample,
     build_trajectory_step,
     create_renderer,
@@ -37,9 +38,30 @@ from renderers.base import (
     trim_to_turn_close,
 )
 from renderers.client import OverlongPromptError
+from renderers.configs import (
+    AutoRendererConfig,
+    BaseRendererConfig,
+    config_from_name,
+    DefaultRendererConfig,
+    DeepSeekV3RendererConfig,
+    GLM45RendererConfig,
+    GLM51RendererConfig,
+    GLM5RendererConfig,
+    GptOssRendererConfig,
+    KimiK25RendererConfig,
+    KimiK2RendererConfig,
+    LagunaXS2RendererConfig,
+    MiniMaxM2RendererConfig,
+    Nemotron3RendererConfig,
+    Qwen35RendererConfig,
+    Qwen36RendererConfig,
+    Qwen3RendererConfig,
+    Qwen3VLRendererConfig,
+    RendererConfig,
+)
 from renderers.deepseek_v3 import DeepSeekV3Renderer
 from renderers.default import DefaultRenderer
-from renderers.glm5 import GLM5Renderer
+from renderers.glm5 import GLM5Renderer, GLM51Renderer
 from renderers.glm45 import GLM45Renderer
 from renderers.gpt_oss import GptOssRenderer
 from renderers.kimi_k2 import KimiK2Renderer
@@ -53,34 +75,53 @@ from renderers.qwen35 import Qwen35Renderer
 from renderers.qwen36 import Qwen36Renderer
 
 __all__ = [
+    "AutoRendererConfig",
+    "BaseRendererConfig",
     "Content",
     "ContentPart",
     "DeepSeekV3Renderer",
+    "DeepSeekV3RendererConfig",
     "DefaultRenderer",
+    "DefaultRendererConfig",
     "GLM45Renderer",
+    "GLM45RendererConfig",
+    "GLM51Renderer",
+    "GLM51RendererConfig",
     "GLM5Renderer",
+    "GLM5RendererConfig",
     "GptOssRenderer",
+    "GptOssRendererConfig",
     "ImagePart",
-    "KimiK2Renderer",
     "KimiK25Renderer",
+    "KimiK25RendererConfig",
+    "KimiK2Renderer",
+    "KimiK2RendererConfig",
     "LagunaXS2Renderer",
+    "LagunaXS2RendererConfig",
     "MULTIMODAL_MODELS",
     "Message",
     "MiniMaxM2Renderer",
+    "MiniMaxM2RendererConfig",
     "MultiModalData",
     "MultimodalRenderer",
     "Nemotron3Renderer",
+    "Nemotron3RendererConfig",
     "OverlongPromptError",
     "ParsedResponse",
     "ParsedToolCall",
     "PlaceholderRange",
-    "Qwen3Renderer",
-    "Qwen3VLRenderer",
     "Qwen35Renderer",
+    "Qwen35RendererConfig",
     "Qwen36Renderer",
+    "Qwen36RendererConfig",
+    "Qwen3Renderer",
+    "Qwen3RendererConfig",
+    "Qwen3VLRenderer",
+    "Qwen3VLRendererConfig",
     "RenderedConversation",
     "RenderedTokens",
     "Renderer",
+    "RendererConfig",
     "RendererPool",
     "TextPart",
     "ThinkingPart",
@@ -90,8 +131,10 @@ __all__ = [
     "ToolSpec",
     "VideoPart",
     "__version__",
+    "attribute_text_segments",
     "build_training_sample",
     "build_trajectory_step",
+    "config_from_name",
     "create_renderer",
     "create_renderer_pool",
     "is_multimodal",

{renderers-0.1.8.dev4 → renderers-0.1.8.dev27}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.8.dev4'
-__version_tuple__ = version_tuple = (0, 1, 8, 'dev4')
+__version__ = version = '0.1.8.dev27'
+__version_tuple__ = version_tuple = (0, 1, 8, 'dev27')
 
 __commit_id__ = commit_id = None