renderers 0.1.10.dev11__tar.gz → 0.1.10.dev13__tar.gz

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: renderers
-Version: 0.1.10.dev11
+Version: 0.1.10.dev13
 Summary: Chat template renderers — deterministic message-to-token conversion for LLM training
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -56,7 +56,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
 
 ## API
 
@@ -159,7 +159,7 @@ renderer = create_renderer(
 
 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.
 
-When `chat_template_kwargs` is passed with `config=None` / `AutoRendererConfig`, renderers first resolves the concrete renderer from the model name, then validates those kwargs against that renderer's config. `Auto + unknown model + chat_template_kwargs` fails loudly; use an explicit typed config or explicit `DefaultRendererConfig` for opaque fallback templates.
+When `chat_template_kwargs` is passed with `config=None` / `AutoRendererConfig`, renderers first resolves the concrete renderer from the model name, then validates each key against that renderer's explicit template-kwarg allowlist. Renderer-only fields such as `image_cache_max` must be passed through the typed config instead. `Auto + unknown model + chat_template_kwargs` fails loudly; use an explicit typed config or explicit `DefaultRendererConfig` for opaque fallback templates.
 
 One shared behaviour flag lives on typed renderer configs: `thinking_retention`, an optional bridge-policy override. Leave it unset to derive bridge behaviour from the chat template and its renderer-exposed kwargs.
 

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/README.md

@@ -40,7 +40,7 @@ next_prompt_ids = r.bridge_to_next_turn(
 )
 ```
 
-Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper.
+Hand-coded renderers ship for `qwen3`, `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `glm-5`, `glm-5.1`, `glm-4.5`, `minimax-m2`, `deepseek-v3`, `deepseek-r1`, `kimi-k2`, `kimi-k2.5` / `kimi-k2.6`, `laguna-xs.2`, `laguna-xs-2.1`, `laguna-s-2.1`, `laguna-m.1`, `nemotron-3`, `nemotron-3-ultra`, `nemotron-3.5`, `llama-3`, `gpt-oss`, `hy3`, `inkling` / `inkling-small`, and `prime-qwen3`. Anything else falls back to `DefaultRenderer`, a generic `apply_chat_template` wrapper. `qwen3-vl`, `qwen3.5`, `qwen3.6`, `gemma4`, `kimi-k2.5` / `kimi-k2.6`, and the Inkling checkpoints are multimodal (Inkling handles both image **and** audio).
 
 ## API
 
@@ -143,7 +143,7 @@ renderer = create_renderer(
 
 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.
 
-When `chat_template_kwargs` is passed with `config=None` / `AutoRendererConfig`, renderers first resolves the concrete renderer from the model name, then validates those kwargs against that renderer's config. `Auto + unknown model + chat_template_kwargs` fails loudly; use an explicit typed config or explicit `DefaultRendererConfig` for opaque fallback templates.
+When `chat_template_kwargs` is passed with `config=None` / `AutoRendererConfig`, renderers first resolves the concrete renderer from the model name, then validates each key against that renderer's explicit template-kwarg allowlist. Renderer-only fields such as `image_cache_max` must be passed through the typed config instead. `Auto + unknown model + chat_template_kwargs` fails loudly; use an explicit typed config or explicit `DefaultRendererConfig` for opaque fallback templates.
 
 One shared behaviour flag lives on typed renderer configs: `thinking_retention`, an optional bridge-policy override. Leave it unset to derive bridge behaviour from the chat template and its renderer-exposed kwargs.
 

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/docs/renderer-config.md

@@ -19,8 +19,10 @@ construction.
 
 ## Per-renderer configs
 
-Use `type(config).template_field_names()` to inspect the fields that mirror
-chat-template kwargs. Those fields are covered by parity tests against
+Use `type(config).template_field_names()` to inspect the explicit allowlist of
+fields accepted through `chat_template_kwargs`. Every renderer-specific field
+is classified as either a template field or a renderer-only field at class
+definition time. Template fields are covered by parity tests against
 `apply_chat_template` in `tests/test_renderer_config_parity.py`.
 
 | Renderer | Config class | Template fields | Renderer-only fields |
@@ -37,6 +39,7 @@ chat-template kwargs. Those fields are covered by parity tests against
 | Hy3 | `Hy3RendererConfig` | `reasoning_effort`, `preserved_thinking`, `is_training`, `raw_last_assistant`, `fallback_strategy` | - |
 | Kimi K2 | `KimiK2RendererConfig` | - | `enable_thinking` |
 | Kimi K2.5 / 2.6 | `KimiK25RendererConfig` | `thinking` | `image_cache_max` |
+| Inkling / Inkling-Small | `InklingRendererConfig` | `reasoning_effort` | `image_cache_max`, `audio_cache_max` |
 | Laguna XS.2 | `LagunaXS2RendererConfig` | `enable_thinking`, `render_assistant_messages_raw` | - |
 | Laguna M.1 | `LagunaM1RendererConfig` | `enable_thinking`, `render_assistant_messages_raw` | - |
 | Laguna XS-2.1 | `LagunaXS21RendererConfig` | `enable_thinking` | - |
@@ -80,8 +83,10 @@ pool = create_renderer_pool(
 ```
 
 Renderers resolves auto configs before applying `chat_template_kwargs`, so the
-kwargs validate against the concrete renderer config. Unknown kwargs, or kwargs
-that conflict with an explicit `thinking_retention`, fail at construction.
+kwargs validate against the concrete renderer's template-field allowlist.
+Unknown kwargs, renderer-only fields, or kwargs that conflict with an explicit
+`thinking_retention` fail at construction. Renderer-only options remain valid
+when supplied through the typed config itself.
 
 Auto-resolution fails loudly for VLMs without an exact registered renderer.
 Text-only unknown models fall back to `DefaultRenderer`, unless
@@ -90,7 +95,10 @@ cannot implement selective bridge retention, so that combination raises.
 `AutoRendererConfig` with `chat_template_kwargs` also raises for unknown models,
 because renderers cannot validate those kwargs without a concrete renderer.
 Use an explicit model-specific config, or `DefaultRendererConfig(...)` when you
-intentionally want opaque `apply_chat_template` kwargs.
+intentionally want opaque `apply_chat_template` kwargs. Even for the default
+renderer, typed fields such as `tool_parser`, `reasoning_parser`, and
+`thinking_retention` must be passed through the config rather than through the
+opaque kwargs mapping.
 
 ## `thinking_retention`
 
@@ -141,7 +149,7 @@ the knobs its template actually exposes:
 | Nemotron-3 / 3.5 | `truncate_history_thinking=False -> all`; else `enable_thinking=False -> all`; else `tool_cycle` |
 | DeepSeek R1 | `template` |
 | MiniMax M2 | `tool_cycle` |
-| DeepSeek V3, Qwen3-VL, Kimi K2, Laguna XS.2 / M.1 / XS-2.1 / S-2.1, Llama 3 | `all` |
+| DeepSeek V3, Qwen3-VL, Kimi K2, Laguna XS.2 / M.1 / XS-2.1 / S-2.1, Llama 3, Inkling | `all` |
 | PrimeIntellect Qwen3 | `all` |
 
 Config construction raises when an explicit template knob directly contradicts

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/pyproject.toml

@@ -19,6 +19,10 @@ dependencies = [
     "openai>=1.108.1",
     "tiktoken",
     "jinja2",
+    # Keep this floor compatible with prime-rl's transformers pin. Inkling's
+    # tokenizer and text-only renderer work on older releases; image/audio
+    # processing fails lazily with an upgrade message when InklingProcessor is
+    # unavailable (native support starts in transformers 5.14).
     "transformers>=4.50.0",
     # Used by GptOssRenderer to render and parse harmony tokens. Vendoring
     # OpenAI's reference implementation keeps us byte-identical with vLLM

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/renderers/__init__.py

@@ -53,6 +53,7 @@ from renderers.configs import (
     Gemma4RendererConfig,
     GptOssRendererConfig,
     Hy3RendererConfig,
+    InklingRendererConfig,
     KimiK25RendererConfig,
     KimiK2RendererConfig,
     LagunaM1RendererConfig,
@@ -93,6 +94,7 @@ _LAZY_RENDERERS: dict[str, str] = {
     "GptOssRenderer": "renderers.gpt_oss",
     "Gemma4Renderer": "renderers.gemma4",
     "Hy3Renderer": "renderers.hy3",
+    "InklingRenderer": "renderers.inkling",
     "KimiK25Renderer": "renderers.kimi_k25",
     "KimiK2Renderer": "renderers.kimi_k2",
     "LagunaM1Renderer": "renderers.laguna_xs2",
@@ -151,6 +153,8 @@ __all__ = [
     "Hy3Renderer",
     "Hy3RendererConfig",
     "ImagePart",
+    "InklingRenderer",
+    "InklingRendererConfig",
     "KimiK25Renderer",
     "KimiK25RendererConfig",
     "KimiK2Renderer",

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/renderers/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.10.dev11'
-__version_tuple__ = version_tuple = (0, 1, 10, 'dev11')
+__version__ = version = '0.1.10.dev13'
+__version_tuple__ = version_tuple = (0, 1, 10, 'dev13')
 
 __commit_id__ = commit_id = None

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/renderers/base.py

@@ -1093,6 +1093,10 @@ MODEL_RENDERER_MAP: dict[str, str] = {
     # GPT-OSS.
     "openai/gpt-oss-20b": "gpt-oss",
     "openai/gpt-oss-120b": "gpt-oss",
+    # Thinking Machines Inkling checkpoints share byte-identical tokenizer,
+    # chat-template, and processor assets (vision + audio; transformers >= 5.14).
+    "thinkingmachines/Inkling": "inkling",
+    "thinkingmachines/Inkling-Small": "inkling",
     # Tencent Hunyuan Hy3 (295B-A21B MoE). The FP8 checkpoint shares the same
     # tokenizer and chat template. Hy3-preview is deliberately unmapped: it
     # ships an older, incompatible template (un-suffixed special tokens,
@@ -1141,6 +1145,8 @@ MULTIMODAL_MODELS: dict[str, set[str]] = {
     # ``grid_thws``.
     "moonshotai/Kimi-K2.5": {"image"},
     "moonshotai/Kimi-K2.6": {"image"},
+    "thinkingmachines/Inkling": {"image", "audio"},
+    "thinkingmachines/Inkling-Small": {"image", "audio"},
 }
 
 
@@ -1340,6 +1346,7 @@ def _populate_registry():
     from renderers.gpt_oss import GptOssRenderer
     from renderers.gemma4 import Gemma4Renderer
     from renderers.hy3 import Hy3Renderer
+    from renderers.inkling import InklingRenderer
     from renderers.kimi_k2 import KimiK2Renderer
     from renderers.kimi_k25 import KimiK25Renderer
     from renderers.laguna_s21 import LagunaS21Renderer
@@ -1377,6 +1384,7 @@ def _populate_registry():
             "deepseek-v3": DeepSeekV3Renderer,
             "deepseek-r1": DeepSeekR1Renderer,
             "hy3": Hy3Renderer,
+            "inkling": InklingRenderer,
             "kimi-k2": KimiK2Renderer,
             "kimi-k2.5": KimiK25Renderer,
             "laguna-xs.2": LagunaXS2Renderer,
@@ -1483,12 +1491,31 @@ def _merge_chat_template_kwargs(
         return config
     if not isinstance(chat_template_kwargs, Mapping):
         raise TypeError("chat_template_kwargs must be a mapping.")
+    kwargs = dict(chat_template_kwargs)
+    config_cls = type(config)
+    allowed = config_cls.template_field_names()
+    if config_cls._allow_opaque_template_kwargs:
+        reserved = frozenset(config_cls.model_fields) - allowed - {"name"}
+        unsupported = frozenset(kwargs) & reserved
+    else:
+        unsupported = frozenset(kwargs) - allowed
+    if unsupported:
+        allowed_text = (
+            "opaque Jinja kwargs"
+            if config_cls._allow_opaque_template_kwargs
+            else ", ".join(sorted(allowed)) or "(none)"
+        )
+        raise ValueError(
+            f"Unsupported chat_template_kwargs for {config.name!r}: "
+            f"{sorted(unsupported)}. Allowed: {allowed_text}. Pass "
+            "renderer-internal options through the typed config instead."
+        )
     data: dict[str, Any] = {"name": config.name}
     for field_name in config.__pydantic_fields_set__:
         data[field_name] = getattr(config, field_name)
     data.update(getattr(config, "model_extra", None) or {})
-    data.update(dict(chat_template_kwargs))
-    return type(config).model_validate(data)
+    data.update(kwargs)
+    return config_cls.model_validate(data)
 
 
 def _resolve_renderer_config(

{renderers-0.1.10.dev11 → renderers-0.1.10.dev13}/renderers/configs.py

@@ -1,10 +1,11 @@
 """Typed renderer configs — one pydantic model per renderer, unified by a
 discriminated union (``RendererConfig``).
 
-Each renderer accepts its own typed config; bad combinations (e.g.
-``add_vision_id`` under ``name="qwen3"``) fail at config-load time with a
-pydantic ``ValidationError`` rather than at runtime via an allowlist
-check. The shared ``thinking_retention`` flag is optional: ``None`` means
+Each renderer accepts its own typed config and declares an explicit
+``_template_fields`` allowlist for fields that may arrive through
+``chat_template_kwargs``. Bad combinations (e.g. ``add_vision_id`` under
+``name="qwen3"``) fail before renderer construction. The shared
+``thinking_retention`` flag is optional: ``None`` means
 "derive bridge policy from this renderer's chat-template knobs"; an
 explicit value is a bridge-policy override.
 
@@ -87,31 +88,36 @@ class BaseRendererConfig(BaseConfig):
     to the Python chat-template implementation and its explicit template
     kwargs."""
 
-    # Fields that are renderer-internal — not forwarded to (or mirrored
-    # by) ``apply_chat_template``. Override in subclasses that hold
-    # non-template config (e.g. ``image_cache_max``, GptOss's
-    # ``use_system_prompt`` / ``knowledge_cutoff`` / ``model_identity``,
-    # or fields that exist as renderer conventions without a Jinja
-    # analogue like DeepSeek V3 / Kimi K2 ``enable_thinking``).
-    #
-    # Used by parity tests to compute the field subset that, when
-    # changed, must produce token streams matching
-    # ``apply_chat_template`` — see :meth:`template_field_names`. The
-    # renderer is the only end-to-end consumer of these fields, so this
-    # is a renderer-side bookkeeping concern rather than a public API.
+    # Every renderer-specific field must be classified exactly once: either
+    # as a chat-template kwarg or as renderer-internal configuration.
+    _template_fields: ClassVar[frozenset[str]] = frozenset()
     _internal_fields: ClassVar[frozenset[str]] = frozenset()
+    _allow_opaque_template_kwargs: ClassVar[bool] = False
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs) -> None:
+        super().__pydantic_init_subclass__(**kwargs)
+        base_fields = frozenset(BaseRendererConfig.model_fields)
+        renderer_fields = frozenset(cls.model_fields) - base_fields - {"name"}
+        overlap = cls._template_fields & cls._internal_fields
+        missing = renderer_fields - cls._template_fields - cls._internal_fields
+        unknown = (cls._template_fields | cls._internal_fields) - renderer_fields
+        if overlap or missing or unknown:
+            raise TypeError(
+                f"{cls.__name__} has an invalid renderer-field classification: "
+                f"overlap={sorted(overlap)}, missing={sorted(missing)}, "
+                f"unknown={sorted(unknown)}"
+            )
 
     @classmethod
     def template_field_names(cls) -> frozenset[str]:
         """Subset of fields that mirror Jinja chat-template kwargs.
 
-        Default: every non-base field except ``name`` and any field
-        listed in ``_internal_fields``. Used by the parity test matrix
-        (``tests/test_renderer_config_parity.py``) to discover the
-        cells that must agree with ``apply_chat_template``.
+        Used both as the runtime allowlist for ``chat_template_kwargs`` and
+        by parity tests to discover the cells that must agree with
+        ``apply_chat_template``.
         """
-        base = frozenset(BaseRendererConfig.model_fields)
-        return frozenset(cls.model_fields) - base - {"name"} - cls._internal_fields
+        return cls._template_fields
 
 
 class AutoRendererConfig(BaseRendererConfig):
@@ -122,6 +128,7 @@ class AutoRendererConfig(BaseRendererConfig):
     at the call site."""
 
     name: Literal["auto"] = "auto"
+    _template_fields = frozenset()
 
 
 class DefaultRendererConfig(BaseRendererConfig):
@@ -148,6 +155,8 @@ class DefaultRendererConfig(BaseRendererConfig):
     # DefaultRenderer's parsing pipeline, not the underlying Jinja
     # template. Jinja kwargs live in ``model_extra`` (extra="allow").
     _internal_fields = frozenset({"tool_parser", "reasoning_parser"})
+    _template_fields = frozenset()
+    _allow_opaque_template_kwargs = True
 
     @model_validator(mode="after")
     def _reject_legacy_preserve_flags(self):
@@ -174,6 +183,7 @@ class Qwen3RendererConfig(BaseRendererConfig):
     """Qwen3 (text-only) renderer config."""
 
     name: Literal["qwen3"] = "qwen3"
+    _template_fields = frozenset({"enable_thinking"})
 
     enable_thinking: bool = True
     """When ``True``, the generation prompt includes ``<think>`` so the
@@ -191,12 +201,14 @@ class PrimeQwen3RendererConfig(BaseRendererConfig):
     """PrimeIntellect Qwen3 renderer config."""
 
     name: Literal["prime-qwen3"] = "prime-qwen3"
+    _template_fields = frozenset()
 
 
 class Qwen35RendererConfig(BaseRendererConfig):
     """Qwen3.5 renderer config."""
 
     name: Literal["qwen3.5"] = "qwen3.5"
+    _template_fields = frozenset({"enable_thinking", "add_vision_id"})
 
     enable_thinking: bool | None = None
     """When ``True``, the generation prompt includes ``<think>``. ``None``
@@ -228,6 +240,9 @@ class Qwen36RendererConfig(BaseRendererConfig):
     """Qwen3.6 renderer config. Inherits Qwen3.5's template surface."""
 
     name: Literal["qwen3.6"] = "qwen3.6"
+    _template_fields = frozenset(
+        {"enable_thinking", "add_vision_id", "preserve_thinking"}
+    )
 
     enable_thinking: bool | None = None
     """See :class:`Qwen35RendererConfig.enable_thinking`."""
@@ -260,6 +275,7 @@ class Qwen3VLRendererConfig(BaseRendererConfig):
     """Qwen3-VL renderer config."""
 
     name: Literal["qwen3-vl"] = "qwen3-vl"
+    _template_fields = frozenset({"add_vision_id"})
 
     add_vision_id: bool = False
     """See :class:`Qwen35RendererConfig.add_vision_id`."""
@@ -274,6 +290,7 @@ class Gemma4RendererConfig(BaseRendererConfig):
     """Gemma 4 renderer config."""
 
     name: Literal["gemma4"] = "gemma4"
+    _template_fields = frozenset({"enable_thinking", "preserve_thinking"})
 
     enable_thinking: bool = False
     """Enable Gemma 4's thinking mode. Mirrors the canonical template kwarg."""
@@ -301,6 +318,7 @@ class GLM5RendererConfig(BaseRendererConfig):
     """GLM-5 renderer config."""
 
     name: Literal["glm-5"] = "glm-5"
+    _template_fields = frozenset({"enable_thinking", "clear_thinking"})
 
     enable_thinking: bool = True
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
@@ -328,6 +346,7 @@ class GLM51RendererConfig(BaseRendererConfig):
     discriminator so the registry can route to ``GLM51Renderer``."""
 
     name: Literal["glm-5.1"] = "glm-5.1"
+    _template_fields = frozenset({"enable_thinking", "clear_thinking"})
 
     enable_thinking: bool = True
     """See :class:`GLM5RendererConfig.enable_thinking`."""
@@ -350,6 +369,7 @@ class GLM45RendererConfig(BaseRendererConfig):
     """GLM-4.5 Air renderer config."""
 
     name: Literal["glm-4.5"] = "glm-4.5"
+    _template_fields = frozenset({"enable_thinking"})
 
     enable_thinking: bool = True
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
@@ -377,6 +397,15 @@ class Hy3RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["hy3"] = "hy3"
+    _template_fields = frozenset(
+        {
+            "reasoning_effort",
+            "preserved_thinking",
+            "is_training",
+            "raw_last_assistant",
+            "fallback_strategy",
+        }
+    )
 
     reasoning_effort: Literal["no_think", "low", "high"] = "no_think"
     """Reasoning gate. Mirrors the chat template's ``reasoning_effort`` kwarg.
@@ -420,6 +449,69 @@ class Hy3RendererConfig(BaseRendererConfig):
         return self
 
 
+# Inkling ``reasoning_effort`` label → float (the template's own effort_map).
+INKLING_EFFORT_MAP: dict[str, float] = {
+    "none": 0.0,
+    "minimal": 0.1,
+    "low": 0.2,
+    "medium": 0.7,
+    "high": 0.9,
+    "max": 0.99,
+}
+
+
+class InklingRendererConfig(BaseRendererConfig):
+    """Renderer config for Inkling and Inkling-Small.
+
+    Inkling gates reasoning depth via a ``reasoning_effort`` knob rather
+    than a boolean ``enable_thinking``. It accepts either a string label
+    from :data:`INKLING_EFFORT_MAP` (``none`` … ``max``) or a raw float in
+    ``[0.0, 0.99]``; the renderer emits ``Thinking effort level: {N}`` in a
+    leading system message exactly as the chat template does (label mapped
+    to its float, ``0.0`` printed as ``"0"``). The template default —
+    applied when no ``reasoning_effort`` is passed — is ``0.9``, which this
+    config mirrors.
+
+    Reasoning is preserved on every historical assistant turn (the template
+    has no history-dropping knob), so the effective bridge policy is
+    ``"all"``.
+    """
+
+    name: Literal["inkling"] = "inkling"
+    _template_fields = frozenset({"reasoning_effort"})
+
+    reasoning_effort: str | float = 0.9
+    """Reasoning-effort gate. Mirrors the chat template's ``reasoning_effort``
+    kwarg: a label in :data:`INKLING_EFFORT_MAP` or a float in ``[0.0, 0.99]``.
+    Default ``0.9`` matches the template's own default (equivalent to
+    ``"high"``)."""
+
+    image_cache_max: int = 256
+    """FIFO bound on the per-renderer image-processor cache. Renderer-
+    internal — not a Jinja chat-template kwarg."""
+
+    audio_cache_max: int = 256
+    """FIFO bound on the per-renderer audio-processor cache. Renderer-
+    internal — not a Jinja chat-template kwarg."""
+
+    _internal_fields = frozenset({"image_cache_max", "audio_cache_max"})
+
+    @model_validator(mode="after")
+    def _check_reasoning_effort(self):
+        eff = self.reasoning_effort
+        if isinstance(eff, str):
+            if eff.strip() not in INKLING_EFFORT_MAP:
+                raise ValueError(
+                    f"reasoning_effort={eff!r} is not a known label. "
+                    f"Use one of {sorted(INKLING_EFFORT_MAP)} or a float in [0.0, 0.99]."
+                )
+        else:
+            num = float(eff)
+            if num < 0.0 or num > 0.99:
+                raise ValueError(f"reasoning_effort={eff!r} must be in [0.0, 0.99].")
+        return self
+
+
 class GptOssRendererConfig(BaseRendererConfig):
     """OpenAI gpt-oss (harmony) renderer config.
 
@@ -433,6 +525,7 @@ class GptOssRendererConfig(BaseRendererConfig):
     """
 
     name: Literal["gpt-oss"] = "gpt-oss"
+    _template_fields = frozenset({"reasoning_effort", "conversation_start_date"})
 
     reasoning_effort: Literal["low", "medium", "high"] = "medium"
     """Harmony reasoning-effort tag. Mirrors the ``apply_chat_template``
@@ -489,6 +582,7 @@ class KimiK2RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["kimi-k2"] = "kimi-k2"
+    _template_fields = frozenset()
 
     enable_thinking: bool = True
     """No-op for Kimi K2 (template doesn't gate on it). Stored for
@@ -501,6 +595,7 @@ class KimiK25RendererConfig(BaseRendererConfig):
     """Kimi K2.5 renderer config."""
 
     name: Literal["kimi-k2.5"] = "kimi-k2.5"
+    _template_fields = frozenset({"thinking"})
 
     thinking: bool = True
     """When ``True``, the generation prompt prefills ``<think>``; when
@@ -518,6 +613,7 @@ class LagunaXS2RendererConfig(BaseRendererConfig):
     """Laguna XS.2 renderer config."""
 
     name: Literal["laguna-xs.2"] = "laguna-xs.2"
+    _template_fields = frozenset({"enable_thinking", "render_assistant_messages_raw"})
 
     enable_thinking: bool = False
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
@@ -543,6 +639,7 @@ class LagunaM1RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["laguna-m.1"] = "laguna-m.1"
+    _template_fields = frozenset({"enable_thinking", "render_assistant_messages_raw"})
 
     enable_thinking: bool = False
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
@@ -564,6 +661,7 @@ class LagunaXS21RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["laguna-xs-2.1"] = "laguna-xs-2.1"
+    _template_fields = frozenset({"enable_thinking"})
 
     enable_thinking: bool = False
     """When ``True``, the generation prompt ends with ``<think>`` and
@@ -587,6 +685,7 @@ class LagunaS21RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["laguna-s-2.1"] = "laguna-s-2.1"
+    _template_fields = frozenset({"enable_thinking", "preserve_thinking"})
 
     enable_thinking: bool = True
     """When ``True``, the generation prompt ends with ``<think>`` and every
@@ -616,6 +715,7 @@ class Llama3RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["llama-3"] = "llama-3"
+    _template_fields = frozenset({"date_string", "tools_in_user_message"})
 
     date_string: str = "26 Jul 2024"
     """``Today Date`` value injected into the system preamble. Pinned to
@@ -634,6 +734,7 @@ class MiniMaxM2RendererConfig(BaseRendererConfig):
     """MiniMax M2 / M2.5 renderer config."""
 
     name: Literal["minimax-m2"] = "minimax-m2"
+    _template_fields = frozenset({"model_identity"})
 
     model_identity: str = "You are a helpful assistant. Your name is MiniMax-M2.5 and is built by MiniMax."
     """Fallback persona used when no system message is supplied. Mirrors
@@ -651,6 +752,9 @@ class Nemotron3RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["nemotron-3"] = "nemotron-3"
+    _template_fields = frozenset(
+        {"enable_thinking", "truncate_history_thinking", "low_effort"}
+    )
 
     enable_thinking: bool = True
     """When ``True``, the generation prompt includes ``<think>``. Mirrors
@@ -693,6 +797,9 @@ class Nemotron3UltraRendererConfig(BaseRendererConfig):
     """
 
     name: Literal["nemotron-3-ultra"] = "nemotron-3-ultra"
+    _template_fields = frozenset(
+        {"enable_thinking", "truncate_history_thinking", "medium_effort"}
+    )
 
     enable_thinking: bool = True
     """See :class:`Nemotron3RendererConfig.enable_thinking`."""
@@ -728,6 +835,7 @@ class Nemotron35RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["nemotron-3.5"] = "nemotron-3.5"
+    _template_fields = frozenset({"enable_thinking", "truncate_history_thinking"})
 
     enable_thinking: bool = True
     """See :class:`Nemotron3RendererConfig.enable_thinking`."""
@@ -755,6 +863,7 @@ class DeepSeekV3RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["deepseek-v3"] = "deepseek-v3"
+    _template_fields = frozenset()
 
 
 class DeepSeekR1RendererConfig(BaseRendererConfig):
@@ -772,6 +881,7 @@ class DeepSeekR1RendererConfig(BaseRendererConfig):
     """
 
     name: Literal["deepseek-r1"] = "deepseek-r1"
+    _template_fields = frozenset()
 
 
 RendererConfig = Annotated[
@@ -789,6 +899,7 @@ RendererConfig = Annotated[
         GLM45RendererConfig,
         GptOssRendererConfig,
         Hy3RendererConfig,
+        InklingRendererConfig,
         KimiK2RendererConfig,
         KimiK25RendererConfig,
         LagunaXS2RendererConfig,
@@ -833,6 +944,7 @@ _CONFIG_BY_NAME: dict[str, type[BaseRendererConfig]] = {
     "glm-4.5": GLM45RendererConfig,
     "gpt-oss": GptOssRendererConfig,
     "hy3": Hy3RendererConfig,
+    "inkling": InklingRendererConfig,
     "kimi-k2": KimiK2RendererConfig,
     "kimi-k2.5": KimiK25RendererConfig,
     "laguna-xs.2": LagunaXS2RendererConfig,
@@ -885,6 +997,8 @@ __all__ = [
     "Gemma4RendererConfig",
     "GptOssRendererConfig",
     "Hy3RendererConfig",
+    "INKLING_EFFORT_MAP",
+    "InklingRendererConfig",
     "KimiK25RendererConfig",
     "KimiK2RendererConfig",
     "LagunaM1RendererConfig",