EXL3 weights

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+model.safetensors.index.json filter=lfs diff=lfs merge=lfs -text
+quantization_config.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 DeepSeek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

config.json

@@ -0,0 +1,184 @@
+{
+  "architectures": [
+    "DeepseekV41ForCausalLM"
+  ],
+  "model_type": "deepseek_v41",
+  "dtype": "bfloat16",
+  "transformers_version": "5.6.0",
+  "bos_token_id": 0,
+  "eos_token_id": 1,
+  "pad_token_id": 2,
+  "image_token_id": 129264,
+  "engram_table_dir": null,
+  "quantization_config": {
+    "quant_method": "exl3",
+    "version": "1.6.2",
+    "avg_bits": 3.5,
+    "head_bits": 6,
+    "calibration": {
+      "rows": 250,
+      "cols": 2048
+    },
+    "out_scales": "always",
+    "codebook": "mul1",
+    "original_quantization_config": {
+      "quant_method": "fp8",
+      "activation_scheme": "dynamic",
+      "weight_block_size": [
+        32,
+        32
+      ],
+      "scale_fmt": "ue8m0",
+      "expert_dtype": "fp4"
+    },
+    "mtp_bits": 6
+  },
+  "text_config": {
+    "model_type": "deepseek_v41_text",
+    "vocab_size": 129280,
+    "hidden_size": 5120,
+    "moe_intermediate_size": 2304,
+    "num_hidden_layers": 40,
+    "num_attention_heads": 64,
+    "num_key_value_heads": 1,
+    "head_dim": 512,
+    "qk_rope_head_dim": 64,
+    "q_lora_rank": 1280,
+    "o_lora_rank": 1024,
+    "o_groups": 8,
+    "hidden_act": "silu",
+    "swiglu_limit": 10.0,
+    "rms_norm_eps": 1e-20,
+    "attention_bias": false,
+    "attention_dropout": 0.0,
+    "initializer_range": 0.02,
+    "use_cache": true,
+    "tie_word_embeddings": false,
+    "max_position_embeddings": 1048576,
+    "rope_theta": 10000,
+    "rope_scaling": {
+      "rope_type": "yarn",
+      "factor": 16,
+      "beta_fast": 32,
+      "beta_slow": 1,
+      "original_max_position_embeddings": 65536
+    },
+    "n_routed_experts": 384,
+    "n_shared_experts": 1,
+    "num_experts_per_tok": 6,
+    "scoring_func": "sqrtsoftplus",
+    "topk_method": "noaux_tc",
+    "norm_topk_prob": true,
+    "routed_scaling_factor": 1.5,
+    "sliding_window": 128,
+    "compress_ratios": [
+      0,
+      0,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      2,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      1,
+      0,
+      0,
+      0
+    ],
+    "compress_rope_theta": 160000,
+    "kv_source_layer_ids": [
+      2,
+      8,
+      14,
+      20
+    ],
+    "index_source_layer_ids": [
+      2,
+      8,
+      14,
+      20,
+      24,
+      28,
+      32,
+      36
+    ],
+    "index_n_heads": 32,
+    "index_head_dim": 128,
+    "index_topk": 512,
+    "candidate_source_layer_id": 20,
+    "candidate_topk_blocks": 2048,
+    "candidate_block_size": 8,
+    "hc_mult": 4,
+    "hc_sinkhorn_iters": 20,
+    "hc_eps": 1e-06,
+    "engram_layer_ids": [
+      1,
+      14
+    ],
+    "engram_num_embeddings": [
+      384006168,
+      384016682
+    ],
+    "engram_max_ngram_size": 4,
+    "engram_vocab_size": 16000000,
+    "engram_n_heads": 8,
+    "engram_head_dim": 256,
+    "engram_pad_token_id": 2,
+    "engram_compressed_vocab_size": 99092,
+    "num_nextn_predict_layers": 3,
+    "dspark_block_size": 5,
+    "dspark_noise_token_id": 128799,
+    "dspark_target_layer_ids": [
+      37,
+      38,
+      39
+    ],
+    "dspark_markov_rank": 256,
+    "dspark_n_routed_experts": 128,
+    "dspark_num_experts_per_tok": 3
+  },
+  "vision_config": {
+    "model_type": "deepseek_v41_vision",
+    "num_hidden_layers": 32,
+    "hidden_size": 1024,
+    "num_attention_heads": 16,
+    "intermediate_size": 2816,
+    "patch_size": 14,
+    "rope_theta": 10000,
+    "downsample_ratio": 3,
+    "max_image_tokens": 1024,
+    "min_pixels": 295936,
+    "max_wh_ratio": null
+  }
+}

encoding/README.md

@@ -0,0 +1,305 @@
+# DeepSeek-V4.1 text and vision encoding
+
+`encoding.py` is the standalone prompt-format reference for DeepSeek-V4.1. It
+supports multi-turn conversations, tool calls, thinking modes, numeric reasoning
+effort, mid-conversation system messages, and interleaved image content blocks,
+without importing the inference implementation.
+
+## V4.1 changes relative to V4
+
+Three prompt-format changes distinguish V4.1 from V4:
+
+1. **DSML tag names use a leading space.** Tool calls are wrapped in
+   `<｜DSML｜ calls>` blocks with `<｜DSML｜ invoke>` / `<｜DSML｜ parameter>` tags
+   (note the space before `calls`, `invoke`, and `parameter`). The V4 format used
+   `<｜DSML｜tool_calls>` without a space.
+
+2. **Reasoning effort is a numeric budget (1–100).** The effort prefix is
+   rendered as `Reasoning Effort: {budget} (range 1-100, ...)` rather than the
+   verbose natural-language descriptions used in V4. String aliases map as
+   follows: `"low"` → 50, `"high"` → 75, `"max"` → 100. The
+   default is `"high"` (75). The effort prefix is only rendered in
+   `thinking_mode="thinking"` and only at the beginning of the conversation
+   (index 0).
+
+3. **Mid-conversation system messages** are supported via the `<｜System｜>` token.
+   A mid-conversation system message behaves like a user message for the purpose
+   of appending the assistant generation header.
+
+## Quick start
+
+```python
+from encoding import encode_messages, parse_message_from_completion_text
+
+# Text-only conversation
+messages = [
+    {"role": "system", "content": "You are a helpful assistant."},
+    {"role": "user", "content": "What is 2+2?"},
+]
+prompt, media = encode_messages(
+    messages,
+    thinking_mode="thinking",
+    reasoning_effort=75,           # integer 1–100, or "low"/"high"/"max"
+    return_multi_modal_data=True,
+)
+# prompt:
+# '<｜begin▁of▁sentence｜><｜System｜>Reasoning Effort: 75 (range 1-100, the higher the
+#  value, the more thorough the reasoning)\n\nYou are a helpful assistant.
+#  <｜User｜>What is 2+2?<｜Assistant｜><think>'
+
+# Parse model output back to a structured message
+completion = "Simple arithmetic.</think>2 + 2 = 4.<｜end▁of▁sentence｜>"
+parsed = parse_message_from_completion_text(completion, thinking_mode="thinking")
+# => {"role": "assistant", "reasoning_content": "Simple arithmetic.",
+#     "content": "2 + 2 = 4.", "tool_calls": []}
+```
+
+> **Note:** `parse_message_from_completion_text` is designed to handle
+> well-formatted model output only. It does not attempt to correct or recover
+> from malformed output that the model might occasionally generate. For
+> production use, additional error handling is recommended.
+
+## OpenAI-style messages
+
+```python
+from encoding import encode_messages
+
+messages = [{
+    "role": "user",
+    "content": [
+        {"type": "text", "text": "第一张图"},
+        {
+            "type": "image_url",
+            "image_url": {"url": "examples/images/image_1.jpeg"},
+        },
+        {"type": "text", "text": "有什么内容？"},
+    ],
+}]
+
+prompt, media = encode_messages(
+    messages,
+    thinking_mode="chat",
+    return_multi_modal_data=True,
+)
+# prompt:
+# '<｜begin▁of▁sentence｜><｜User｜>第一张图\n\n<｜deepseek_image｜>\n\n有什么内容？<｜Assistant｜></think>'
+# media["images"] contains the image records in prompt order
+```
+
+Images are represented in the prompt by `<｜deepseek_image｜>`. `media["images"]`
+contains the corresponding image records in exactly the same order they appear in
+the prompt. Pixel loading and expansion into model image tokens are handled by
+`inference/image_processor.py`.
+
+## Compact TXT notation
+
+`parse_tagged_text()` converts a compact prompt such as
+
+```text
+第一张图<image>examples/images/image_1.jpeg</image>有什么内容？
+```
+
+into the same standard content blocks. It is an input convenience layer, not a
+second encoding implementation.
+
+## Message format
+
+### Special tokens
+
+| Token | Purpose |
+| :--- | :--- |
+| `<｜begin▁of▁sentence｜>` | Beginning of sequence (BOS) |
+| `<｜end▁of▁sentence｜>` | End of assistant turn (EOS) |
+| `<｜User｜>` | User turn prefix |
+| `<｜Assistant｜>` | Assistant turn prefix |
+| `<｜System｜>` | Mid-conversation system message prefix |
+| `<｜latest_reminder｜>` | Latest reminder (date, locale, etc.) |
+| `<think>` / `</think>` | Reasoning block delimiters |
+| `｜DSML｜` | DSML markup token |
+| `<｜deepseek_image｜>` | Image placeholder in the prompt string |
+
+### Roles
+
+The encoding supports the following message roles: `system`, `user`, `assistant`,
+`tool`, and `latest_reminder`.
+
+A `tool` message is not rendered directly: `merge_tool_messages()` converts it
+into a `<tool_result>` block inside the preceding user message. When multiple
+tool results are present, they are sorted by the order of the corresponding
+`tool_calls` in the preceding assistant message.
+
+### Basic chat
+
+A simple multi-turn conversation is encoded as:
+
+```
+<｜begin▁of▁sentence｜>{system_prompt}
+<｜User｜>{user_message}<｜Assistant｜></think>{response}<｜end▁of▁sentence｜>
+<｜User｜>{user_message_2}<｜Assistant｜></think>{response_2}<｜end▁of▁sentence｜>
+```
+
+- The BOS token is prepended at the very beginning of the conversation.
+- In **chat mode** (`thinking_mode="chat"`), `</think>` is placed right after
+  `<｜Assistant｜>` to immediately close the thinking block, so the model generates
+  content directly.
+
+### Thinking mode
+
+In **thinking mode** (`thinking_mode="thinking"`), the model produces explicit
+reasoning inside `<think>...</think>` blocks before responding.
+
+```
+<｜begin▁of▁sentence｜><｜System｜>{reasoning_effort_prefix}{system_prompt}
+<｜User｜>{message}<｜Assistant｜><think>{reasoning}</think>{response}<｜end▁of▁sentence｜>
+```
+
+The reasoning effort prefix is injected once, before the system message, as a
+`<｜System｜>` block:
+
+```
+<｜System｜>Reasoning Effort: {budget} (range 1-100, the higher the value, the more thorough the reasoning)
+```
+
+The `drop_thinking` parameter (default `True`) controls whether reasoning from
+earlier turns is preserved:
+
+- **Without a tools declaration**: reasoning before the latest user request is
+  stripped. Tool results alone do not start a new user turn, so reasoning within
+  the current turn is retained across tool calls.
+- **With a tools declaration**: `drop_thinking` is automatically disabled. All
+  turns retain their reasoning, because tool-calling conversations require full
+  context for the model to track multi-step reasoning across tool calls.
+
+### Tool calling (DSML format)
+
+Tools are defined on the `system` message via the `tools` field
+(OpenAI-compatible format). When tools are present, the following schema block is
+injected into the system prompt:
+
+```
+## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<｜DSML｜ calls>" block like the following:
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="$TOOL_NAME">
+<｜DSML｜ parameter name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</｜DSML｜ parameter>
+...
+</｜DSML｜ invoke>
+<｜DSML｜ invoke name="$TOOL_NAME2">
+...
+</｜DSML｜ invoke>
+</｜DSML｜ calls>
+
+String parameters should be specified as is and set `string="true"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string="false"`.
+
+If thinking_mode is enabled (triggered by <think>), you MUST output your complete reasoning inside <think>...</think> BEFORE any tool calls or final response.
+
+Otherwise, output directly after </think> with tool calls or final response.
+
+### Available Tool Schemas
+
+{tool_definitions_json}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.
+```
+
+An actual tool call in the assistant turn looks like:
+
+```xml
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="function_name">
+<｜DSML｜ parameter name="param" string="true">string_value</｜DSML｜ parameter>
+<｜DSML｜ parameter name="count" string="false">5</｜DSML｜ parameter>
+</｜DSML｜ invoke>
+</｜DSML｜ calls><｜end▁of▁sentence｜>
+```
+
+- `string="true"`: the parameter value is a raw string.
+- `string="false"`: the parameter value is JSON (number, boolean, array, object).
+
+Tool execution results are wrapped in `<tool_result>` tags within user messages:
+
+```
+<｜User｜><tool_result>{result_json}</tool_result><｜Assistant｜><think>...
+```
+
+### Tool namespaces
+
+Tool definitions may include a `namespace` alongside `function`, either as a
+string or as an object with `name` and an optional `description`:
+
+```python
+tool = {
+    "type": "function",
+    "namespace": {"name": "search", "description": "Search tools."},
+    "function": {
+        "name": "lookup",
+        "description": "Look up a value",
+        "parameters": {"type": "object", "properties": {"query": {"type": "string"}}},
+    },
+}
+tool_call = {
+    "type": "function",
+    "namespace": "search",
+    "function": {"name": "lookup", "arguments": '{"query": "value"}'},
+}
+```
+
+The tool schema and DSML invocation both use `search::lookup`. The namespace
+description is prepended to the tool description, separated by a newline.
+The parser returns `function.name="lookup"` and `namespace="search"` on the
+tool call, so its output can be passed back to `encode_messages()` directly.
+
+Input also accepts `namespace` inside `function`, or a qualified function name
+such as `search::lookup`. A qualified name must agree with any explicit
+namespace; `::` separates exactly one namespace from the tool name. Tools
+without a namespace retain their original names and output format.
+
+### Reasoning effort
+
+Pass `reasoning_effort` as an integer in `[1, 100]` or as one of `"low"` (50),
+`"high"` (75), or `"max"` (100). The default is `"high"` (75).
+The setting only affects `thinking_mode="thinking"` and is only rendered at the
+start of the conversation (index 0). Intermediate values may be used to elicit
+interpolated reasoning behavior.
+
+### Quick instruction special tokens
+
+Quick instruction tokens are used for auxiliary classification and generation
+tasks. They are appended to messages via the `"task"` field to trigger
+specialized model behavior for a single-token or short-form output.
+
+| Special Token | Description | Format |
+|:---|:---|:---|
+| `<｜action｜>` | Determines whether the user prompt requires a web search or can be answered directly. | `...<｜User｜>{prompt}<｜Assistant｜><think><｜action｜>` |
+| `<｜title｜>` | Generates a concise conversation title after the first assistant response. | `...<｜Assistant｜>{response}<｜end▁of▁sentence｜><｜title｜>` |
+| `<｜query｜>` | Generates search queries for the user prompt. | `...<｜User｜>{prompt}<｜query｜>` |
+| `<｜authority｜>` | Classifies the user prompt's demand for source authoritativeness. | `...<｜User｜>{prompt}<｜authority｜>` |
+| `<｜domain｜>` | Identifies the domain of the user prompt. | `...<｜User｜>{prompt}<｜domain｜>` |
+| `<｜read_url｜>` | Determines whether each URL in the user prompt should be fetched and read. | `...<｜User｜>{prompt}<｜read_url｜>` |
+
+Usage in message format:
+
+- **`action`** on a user message: the `<｜action｜>` token is placed after the
+  assistant prefix and thinking token, triggering a routing decision (e.g.,
+  "Search" or "Answer").
+- **Other tasks** (`query`, `authority`, `domain`, `read_url`) on a user message:
+  the task token is appended directly after the user content.
+- **`title`** on an assistant message: the `<｜title｜>` token is appended after
+  the assistant's EOS. The next assistant message provides the generated title.
+
+## Tests
+
+From this directory:
+
+```bash
+python -m pytest -q test_encoding.py
+```
+
+Test cases are stored as paired JSON input / TXT expected-output files under
+`tests/`. The tests cover multi-turn conversations, tool calling, thinking mode,
+numeric reasoning effort, mid-conversation system messages, and multimodal image
+ordering. They include a check that the TXT and JSON examples encode to the same
+prompt and preserve the same image ordering.

encoding/encoding.py

@@ -0,0 +1,990 @@
+"""
+DeepSeek-V4.1 Text and Vision Encoding
+
+A fully self-contained implementation for encoding/decoding DeepSeek-V4.1 chat
+messages with tool calling, thinking mode, quick instruction tasks, and image
+content blocks. No dependency on encoding_dsv4.
+
+V4.1 changes relative to V4:
+
+1. DSML tag names: tool calls are wrapped in "<｜DSML｜ calls>" blocks with
+   "<｜DSML｜ invoke>" / "<｜DSML｜ parameter>" tags (leading-space tag names).
+2. Numeric reasoning effort: "Reasoning Effort: {budget} (range 1-100, ...)".
+   Accepts an int in [1, 100] or one of "low"/"high"/"max"
+   (mapped to 50/75/100). Defaults to "high". Only rendered in thinking mode.
+3. Mid-conversation system messages are supported via the "<｜System｜>" token.
+   A mid-conversation system message behaves like a user message for the purpose
+   of appending the assistant generation header.
+"""
+
+from typing import Any, Dict, List, Union, Optional, Tuple
+import copy
+import json
+import re
+
+# ============================================================
+# Special Tokens
+# ============================================================
+
+bos_token: str = "<｜begin▁of▁sentence｜>"
+eos_token: str = "<｜end▁of▁sentence｜>"
+thinking_start_token: str = "<think>"
+thinking_end_token: str = "</think>"
+dsml_token: str = "｜DSML｜"
+
+USER_SP_TOKEN = "<｜User｜>"
+ASSISTANT_SP_TOKEN = "<｜Assistant｜>"
+LATEST_REMINDER_SP_TOKEN = "<｜latest_reminder｜>"
+
+IMAGE_PLACEHOLDER = "<｜deepseek_image｜>"
+IMAGE_TAG_PATTERN = re.compile(r"<image>(.*?)</image>", re.DOTALL)
+
+# Task special tokens for internal classification tasks
+DS_TASK_SP_TOKENS = {
+    "action": "<｜action｜>",
+    "query": "<｜query｜>",
+    "authority": "<｜authority｜>",
+    "domain": "<｜domain｜>",
+    "title": "<｜title｜>",
+    "read_url": "<｜read_url｜>",
+}
+VALID_TASKS = set(DS_TASK_SP_TOKENS.keys())
+
+# ============================================================
+# Templates
+# ============================================================
+
+system_msg_template: str = "{content}"
+user_msg_template: str = "{content}"
+latest_reminder_msg_template: str = "{content}"
+assistant_msg_template: str = "{reasoning}{content}{tool_calls}" + eos_token
+assistant_msg_wo_eos_template: str = "{reasoning}{content}{tool_calls}"
+thinking_template: str = "{reasoning_content}"
+
+response_format_template: str = (
+    "## Response Format:\n\nYou MUST strictly adhere to the following schema to reply:\n{schema}"
+)
+
+tool_output_template: str = (
+    "<tool_result>{content}</tool_result>"
+)
+
+# ============================================================
+# Utility Functions
+# ============================================================
+
+def to_json(value: Any) -> str:
+    """Serialize a value to JSON string."""
+    try:
+        return json.dumps(value, ensure_ascii=False)
+    except:
+        return json.dumps(value, ensure_ascii=True)
+
+
+def tools_from_openai_format(tools):
+    """Extract function definitions with namespace-qualified names."""
+    functions = []
+    for tool in tools:
+        function = dict(tool["function"])
+        if tool.get("namespace") is not None:
+            function["namespace"] = tool["namespace"]
+        function["name"] = _tool_name_for_encoding(function)
+        namespace = function.pop("namespace", None)
+        if isinstance(namespace, dict) and namespace.get("description"):
+            function["description"] = (
+                namespace["description"] + "\n" + (function.get("description") or "")
+            )
+        functions.append(function)
+    return functions
+
+
+def _split_tool_name(name: str, namespace: Optional[str] = None) -> Tuple[Optional[str], str]:
+    """Split a qualified name and validate any explicit namespace."""
+    prefix, separator, bare_name = name.partition("::")
+    if separator:
+        assert namespace in (None, prefix), (
+            f"Conflicting tool namespaces: {namespace} != {prefix}"
+        )
+        namespace, name = prefix, bare_name
+    assert "::" not in name, f"Tool name must not contain '::': {name}"
+    assert namespace is None or "::" not in namespace, (
+        f"Tool namespace must not contain '::': {namespace}"
+    )
+    return namespace, name
+
+
+def _tool_name_for_encoding(tool: Dict[str, Any]) -> str:
+    namespace = tool.get("namespace")
+    if isinstance(namespace, dict):
+        namespace = namespace["name"]
+    namespace, name = _split_tool_name(tool["name"], namespace)
+    return name if namespace is None else f"{namespace}::{name}"
+
+
+def tool_calls_from_openai_format(tool_calls):
+    """Convert OpenAI-format tool calls to internal format."""
+    calls = []
+    for tool_call in tool_calls:
+        function = tool_call["function"]
+        namespace, name = _split_tool_name(
+            function["name"], tool_call.get("namespace") or function.get("namespace")
+        )
+        call = {"name": name, "arguments": function["arguments"]}
+        if namespace is not None:
+            call["namespace"] = namespace
+        calls.append(call)
+    return calls
+
+
+def tool_calls_to_openai_format(tool_calls):
+    """Convert internal tool calls to OpenAI format."""
+    calls = []
+    for tool_call in tool_calls:
+        call = {
+            "type": "function",
+            "function": {
+                "name": tool_call["name"],
+                "arguments": tool_call["arguments"],
+            }
+        }
+        if tool_call.get("namespace") is not None:
+            call["namespace"] = tool_call["namespace"]
+        calls.append(call)
+    return calls
+
+
+def decode_dsml_to_arguments(tool_name: str, tool_args: Dict[str, Tuple[str, str]]) -> Dict[str, str]:
+    """
+    Decode DSML parameters back to a tool call dict.
+
+    Args:
+        tool_name: Name of the tool.
+        tool_args: Dict mapping param_name -> (value, is_string_flag).
+
+    Returns:
+        Dict with "name", "arguments" (JSON string), and optional "namespace".
+    """
+    def _decode_value(key: str, value: str, string: str):
+        if string == "true":
+            value = to_json(value)
+        return f"{to_json(key)}: {value}"
+
+    tool_args_json = "{" + ", ".join([_decode_value(k, v, string=is_str) for k, (v, is_str) in tool_args.items()]) + "}"
+    namespace, name = _split_tool_name(tool_name)
+    tool_call = dict(name=name, arguments=tool_args_json)
+    if namespace is not None:
+        tool_call["namespace"] = namespace
+    return tool_call
+
+
+# ============================================================
+# Preprocessing
+# ============================================================
+
+def merge_tool_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Merge tool messages into the preceding user message using content_blocks format.
+
+    DeepSeek-V4.1 does not have a standalone "tool" role; instead, tool results
+    are encoded as <tool_result> blocks within user messages.
+    """
+    merged: List[Dict[str, Any]] = []
+
+    for msg in messages:
+        msg = copy.deepcopy(msg)
+        role = msg.get("role")
+
+        if role == "tool":
+            # Convert tool message to a user message with tool_result block
+            content = msg.get("content", "")
+            if msg.get("content_blocks") and not isinstance(msg.get("content"), str):
+                content = msg["content_blocks"]
+            tool_block = {
+                "type": "tool_result",
+                "tool_use_id": msg.get("tool_call_id", ""),
+                "content": content,
+            }
+            # Merge into previous message if it's already a user (merged tool)
+            if merged and merged[-1].get("role") == "user" and "content_blocks" in merged[-1]:
+                merged[-1]["content_blocks"].append(tool_block)
+            else:
+                merged.append({
+                    "role": "user",
+                    "content_blocks": [tool_block],
+                })
+        elif role == "user":
+            content_blocks = msg.get("content_blocks")
+            if content_blocks is None:
+                content = msg.get("content", "")
+                content_blocks = content if isinstance(content, list) else [{"type": "text", "text": content}]
+            if merged and merged[-1].get("role") == "user" and "content_blocks" in merged[-1] and merged[-1].get("task") is None:
+                merged[-1]["content_blocks"].extend(content_blocks)
+            else:
+                # Preserve structured content and all message-level metadata.
+                new_msg = msg
+                new_msg["content_blocks"] = content_blocks
+                merged.append(new_msg)
+        else:
+            merged.append(msg)
+
+    return merged
+
+
+def sort_tool_results_by_call_order(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Sort tool_result blocks within user messages by the order of tool_calls
+    in the preceding assistant message.
+    """
+    last_tool_call_order: Dict[str, int] = {}
+
+    for msg in messages:
+        role = msg.get("role")
+        if role == "assistant" and msg.get("tool_calls"):
+            last_tool_call_order = {}
+            for idx, tc in enumerate(msg["tool_calls"]):
+                tc_id = tc.get("id") or tc.get("function", {}).get("id", "")
+                if tc_id:
+                    last_tool_call_order[tc_id] = idx
+
+        elif role == "user" and msg.get("content_blocks"):
+            tool_blocks = [b for b in msg["content_blocks"] if b.get("type") == "tool_result"]
+            if len(tool_blocks) > 1 and last_tool_call_order:
+                sorted_blocks = sorted(
+                    tool_blocks,
+                    key=lambda b: last_tool_call_order.get(b.get("tool_use_id", ""), 0)
+                )
+                sorted_idx = 0
+                new_blocks = []
+                for block in msg["content_blocks"]:
+                    if block.get("type") == "tool_result":
+                        new_blocks.append(sorted_blocks[sorted_idx])
+                        sorted_idx += 1
+                    else:
+                        new_blocks.append(block)
+                msg["content_blocks"] = new_blocks
+
+    return messages
+
+
+# ============================================================
+# Vision Message Preprocessing
+# ============================================================
+
+def parse_tagged_text(text: str) -> Union[str, List[Dict[str, Any]]]:
+    """Convert ``<image>path</image>`` text into standard content blocks."""
+    matches = list(IMAGE_TAG_PATTERN.finditer(text))
+    remaining = IMAGE_TAG_PATTERN.sub("", text)
+    if "<image>" in remaining or "</image>" in remaining:
+        raise ValueError("Malformed <image>path</image> tag")
+    if not matches:
+        return text
+
+    blocks: List[Dict[str, Any]] = []
+    cursor = 0
+    for match in matches:
+        if match.start() > cursor:
+            blocks.append({"type": "text", "text": text[cursor:match.start()]})
+        path = match.group(1)
+        if not path:
+            raise ValueError("Image path must not be empty")
+        blocks.append({
+            "type": "image_url",
+            "image_url": {"url": path},
+        })
+        cursor = match.end()
+    if cursor < len(text):
+        blocks.append({"type": "text", "text": text[cursor:]})
+    return blocks
+
+
+def _is_image_block(block: Dict[str, Any]) -> bool:
+    """Return whether a content block is an OpenAI/Anthropic/internal image."""
+    return isinstance(block, dict) and block.get("type") in ("image", "image_url")
+
+
+def _extract_image(block: Dict[str, Any]) -> Dict[str, Any]:
+    """Normalize a supported image block into an internal image record."""
+    record: Dict[str, Any] = {"type": "image"}
+    if block.get("type") == "image_url":
+        image_url = block.get("image_url")
+        if isinstance(image_url, str):
+            record["url"] = image_url
+        else:
+            record["url"] = (image_url or {}).get("url", "")
+    else:
+        for key in ("source", "url", "data"):
+            if key in block:
+                record[key] = block[key]
+    if not any(record.get(key) for key in ("source", "url", "data")):
+        raise ValueError("Image block does not contain a valid source")
+    return record
+
+
+def _process_image_blocks(
+    blocks: List[Any], image_placeholder: str = IMAGE_PLACEHOLDER
+) -> Tuple[List[Any], List[Dict[str, Any]]]:
+    """Replace image blocks and collect their records in one ordered traversal."""
+    new_blocks: List[Any] = []
+    images: List[Dict[str, Any]] = []
+    for block in blocks:
+        if not isinstance(block, dict):
+            new_blocks.append(block)
+            continue
+        if _is_image_block(block):
+            new_blocks.append({"type": "text", "text": image_placeholder})
+            images.append(_extract_image(block))
+        elif block.get("type") == "tool_result" and isinstance(block.get("content"), list):
+            block = copy.copy(block)
+            block["content"], nested_images = _process_image_blocks(
+                block["content"], image_placeholder)
+            new_blocks.append(block)
+            images.extend(nested_images)
+        elif block.get("type") == "text":
+            text = block.get("text") or ""
+            if IMAGE_PLACEHOLDER in text:
+                raise ValueError(
+                    f"Text block contains image placeholder '{IMAGE_PLACEHOLDER}': "
+                    f"'{text[:100]}'. Images should be separate content blocks."
+                )
+            new_blocks.append(block)
+        else:
+            new_blocks.append(block)
+    return new_blocks, images
+
+
+def _validate_no_image_sp_tokens(msg: Dict[str, Any]) -> None:
+    """Reject user-supplied image placeholder tokens in textual fields."""
+    content = msg.get("content")
+    if isinstance(content, str) and IMAGE_PLACEHOLDER in content:
+        raise ValueError(
+            f"Message content contains image special token '{IMAGE_PLACEHOLDER}'. "
+            "Images should be provided as image content blocks."
+        )
+    reasoning_content = msg.get("reasoning_content")
+    if isinstance(reasoning_content, str) and IMAGE_PLACEHOLDER in reasoning_content:
+        raise ValueError(
+            f"reasoning_content contains image special token '{IMAGE_PLACEHOLDER}'"
+        )
+
+
+def process_image_messages(
+    messages: List[Dict[str, Any]],
+) -> Tuple[List[Dict[str, Any]], List[Dict[str, Any]]]:
+    """Normalize image blocks and return their records in prompt order."""
+    processed: List[Dict[str, Any]] = []
+    images: List[Dict[str, Any]] = []
+    for msg in messages:
+        msg = copy.deepcopy(msg)
+        _validate_no_image_sp_tokens(msg)
+
+        if isinstance(msg.get("content"), list) and "content_blocks" not in msg:
+            msg["content_blocks"] = msg.pop("content")
+
+        if msg.get("content_blocks"):
+            msg["content_blocks"], message_images = _process_image_blocks(
+                msg["content_blocks"])
+            images.extend(message_images)
+            if not isinstance(msg.get("content"), str):
+                texts = [
+                    block.get("text", "")
+                    for block in msg["content_blocks"]
+                    if isinstance(block, dict) and block.get("type") == "text"
+                ]
+                msg["content"] = "\n\n".join(texts)
+
+        processed.append(msg)
+    return processed, images
+
+
+def _read_until_stop(index: int, text: str, stop: List[str]) -> Tuple[int, str, Optional[str]]:
+    """
+    Read text from index until one of the stop strings is found.
+
+    Returns:
+        Tuple of (new_index, content_before_stop, matched_stop_string_or_None).
+    """
+    min_pos = len(text)
+    matched_stop = None
+
+    for s in stop:
+        pos = text.find(s, index)
+        if pos != -1 and pos < min_pos:
+            min_pos = pos
+            matched_stop = s
+
+    if matched_stop:
+        content = text[index:min_pos]
+        return min_pos + len(matched_stop), content, matched_stop
+    else:
+        content = text[index:]
+        return len(text), content, None
+
+# ============================================================
+# V4.1 Special Tokens and DSML Tag Names
+# ============================================================
+
+SYSTEM_SP_TOKEN = "<｜System｜>"
+
+tool_calls_block_name: str = " calls"
+tool_call_tag_name: str = " invoke"
+tool_parameter_tag_name: str = " parameter"
+
+tool_call_template: str = (
+    "<{dsml_token}{tool_call_tag_name} name=\"{name}\">\n{arguments}\n</{dsml_token}{tool_call_tag_name}>"
+)
+tool_calls_template = (
+    "<{dsml_token}{tc_block_name}>\n{tool_calls}\n</{dsml_token}{tc_block_name}>"
+)
+
+# ============================================================
+# Reasoning Effort (numeric budget)
+# ============================================================
+
+REASONING_EFFORT_TEMPLATE = (
+    "Reasoning Effort: {budget} "
+    "(range 1-100, the higher the value, the more thorough the reasoning)\n\n"
+)
+
+REASONING_EFFORT_MAPPINGS: Dict[str, int] = {
+    "low": 50,
+    "high": 75,
+    "max": 100,
+}
+DEFAULT_REASONING_EFFORT = "high"
+
+
+def render_reasoning_effort(
+    index: int,
+    thinking_mode: str,
+    effort: Union[str, int, None],
+) -> str:
+    """Render the V4.1 numeric reasoning effort prefix (thinking mode, index 0 only)."""
+    if effort is None:
+        effort = DEFAULT_REASONING_EFFORT
+    assert (
+        type(effort) is int and 1 <= effort <= 100
+    ) or effort in REASONING_EFFORT_MAPPINGS, (
+        "Invalid reasoning effort for deepseek_v41: "
+        f"{effort}, should be int within [1,100] or {list(REASONING_EFFORT_MAPPINGS)}"
+    )
+    if type(effort) is str:
+        effort = REASONING_EFFORT_MAPPINGS[effort]
+    if index == 0 and thinking_mode == "thinking":
+        return REASONING_EFFORT_TEMPLATE.format(budget=effort)
+    return ""
+
+
+# ============================================================
+# Tools rendering
+# ============================================================
+
+TOOLS_TEMPLATE = """## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<{dsml_token}{tc_block_name}>" block like the following:
+
+<{dsml_token}{tc_block_name}>
+<{dsml_token}{tool_call_tag_name} name="$TOOL_NAME">
+<{dsml_token}{tool_parameter_tag_name} name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</{dsml_token}{tool_parameter_tag_name}>
+...
+</{dsml_token}{tool_call_tag_name}>
+<{dsml_token}{tool_call_tag_name} name="$TOOL_NAME2">
+...
+</{dsml_token}{tool_call_tag_name}>
+</{dsml_token}{tc_block_name}>
+
+String parameters should be specified as is and set `string="true"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string="false"`.
+
+If thinking_mode is enabled (triggered by {thinking_start_token}), you MUST output your complete reasoning inside {thinking_start_token}...{thinking_end_token} BEFORE any tool calls or final response.
+
+Otherwise, output directly after {thinking_end_token} with tool calls or final response.
+
+### Available Tool Schemas
+
+{tool_schemas}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.
+"""
+
+
+def render_tools(tools: List[Dict[str, Union[str, Dict[str, Any]]]]) -> str:
+    """Render tool schemas into the V4.1 system prompt format."""
+    tools_json = [to_json(t) for t in tools]
+
+    return TOOLS_TEMPLATE.format(
+        tool_schemas="\n".join(tools_json),
+        dsml_token=dsml_token,
+        tc_block_name=tool_calls_block_name,
+        tool_call_tag_name=tool_call_tag_name,
+        tool_parameter_tag_name=tool_parameter_tag_name,
+        thinking_start_token=thinking_start_token,
+        thinking_end_token=thinking_end_token,
+    )
+
+
+def encode_arguments_to_dsml(tool_call: Dict[str, Any]) -> str:
+    """Encode tool call arguments into V4.1 DSML parameter format."""
+    p_dsml_template = (
+        '<{dsml_token}{tool_parameter_tag_name} name="{key}" string="{is_str}">'
+        '{value}</{dsml_token}{tool_parameter_tag_name}>'
+    )
+    P_dsml_strs = []
+
+    arguments = tool_call["arguments"]
+    if not isinstance(arguments, dict):
+        # Tolerate JSON strings, including double-encoded ones.
+        for _ in range(2):
+            if isinstance(arguments, str):
+                try:
+                    arguments = json.loads(arguments)
+                except Exception:
+                    break
+            else:
+                break
+        if not isinstance(arguments, dict):
+            arguments = {"arguments": tool_call["arguments"]}
+
+    for k, v in arguments.items():
+        P_dsml_strs.append(p_dsml_template.format(
+            dsml_token=dsml_token,
+            tool_parameter_tag_name=tool_parameter_tag_name,
+            key=k,
+            is_str="true" if isinstance(v, str) else "false",
+            value=v if isinstance(v, str) else to_json(v),
+        ))
+
+    return "\n".join(P_dsml_strs)
+
+
+# ============================================================
+# Message Rendering
+# ============================================================
+
+def find_last_user_index(messages: List[Dict[str, Any]]) -> int:
+    """
+    Find the index of the last user message.
+
+    V4.1 supports mid-conversation system messages, which count as user
+    messages for the purposes of the assistant generation header.
+    User messages containing only tool results do not start a new turn.
+    """
+    last_user_index = -1
+    for idx in range(len(messages) - 1, -1, -1):
+        role = messages[idx].get("role")
+        if role == "user" or (role == "system" and idx > 0):
+            content_blocks = messages[idx].get("content_blocks")
+            if content_blocks and not any(
+                block.get("type") in ("text", "image", "image_url")
+                for block in content_blocks
+            ):
+                continue
+            last_user_index = idx
+            break
+    return last_user_index
+
+
+def render_message(
+    index: int,
+    messages: List[Dict[str, Any]],
+    thinking_mode: str,
+    drop_thinking: bool = True,
+    reasoning_effort: Union[str, int, None] = None,
+) -> str:
+    """
+    Render a single message at the given index into its V4.1 encoded string form.
+    """
+    assert 0 <= index < len(messages)
+    assert thinking_mode in ["chat", "thinking"], f"Invalid thinking_mode `{thinking_mode}`"
+
+    msg = messages[index]
+    last_user_idx = find_last_user_index(messages)
+
+    role = msg.get("role")
+    content = msg.get("content")
+    tools = msg.get("tools")
+    response_format = msg.get("response_format")
+    tool_calls = msg.get("tool_calls")
+    reasoning_content = msg.get("reasoning_content")
+    wo_eos = msg.get("wo_eos", False)
+
+    if tools:
+        tools = tools_from_openai_format(tools)
+    if tool_calls:
+        tool_calls = tool_calls_from_openai_format(tool_calls)
+
+    # Reasoning effort prefix (thinking mode, index 0 only)
+    reasoning_effort_prompt = render_reasoning_effort(index, thinking_mode, reasoning_effort)
+    # System token leads the conversation when there is a reasoning effort prompt
+    # or the first message is a system message.
+    prompt = SYSTEM_SP_TOKEN if index == 0 and (reasoning_effort_prompt or role == "system") else ""
+    prompt += reasoning_effort_prompt
+
+    if role == "system":
+        if index > 0:
+            # Mid-conversation system message
+            prompt += SYSTEM_SP_TOKEN
+        prompt += system_msg_template.format(content=content or "")
+        if tools:
+            prompt += "\n\n" + render_tools(tools)
+        if response_format:
+            prompt += "\n\n" + response_format_template.format(schema=to_json(response_format))
+
+    elif role == "user":
+        prompt += USER_SP_TOKEN
+
+        # Handle content blocks (tool results mixed with text)
+        content_blocks = msg.get("content_blocks")
+        if content_blocks:
+            parts = []
+            for block in content_blocks:
+                block_type = block.get("type")
+                if block_type == "text":
+                    parts.append(block.get("text", ""))
+                elif block_type == "tool_result":
+                    tool_content = block.get("content", "")
+                    if isinstance(tool_content, list):
+                        text_parts = []
+                        for b in tool_content:
+                            if b.get("type") == "text":
+                                text_parts.append(b.get("text", ""))
+                            else:
+                                text_parts.append(f"[Unsupported {b.get('type')}]")
+                        tool_content = "\n\n".join(text_parts)
+                    parts.append(tool_output_template.format(content=tool_content))
+                else:
+                    parts.append(f"[Unsupported {block_type}]")
+            prompt += "\n\n".join(parts)
+        else:
+            prompt += content or ""
+
+    elif role == "latest_reminder":
+        prompt += LATEST_REMINDER_SP_TOKEN + latest_reminder_msg_template.format(content=content)
+
+    elif role == "tool":
+        raise NotImplementedError("deepseek_v41 merges tool messages into user; please preprocess with merge_tool_messages()")
+
+    elif role == "assistant":
+        thinking_part = ""
+        tc_content = ""
+
+        if tool_calls:
+            tc_list = [
+                tool_call_template.format(
+                    dsml_token=dsml_token,
+                    tool_call_tag_name=tool_call_tag_name,
+                    name=_tool_name_for_encoding(tc),
+                    arguments=encode_arguments_to_dsml(tc)
+                )
+                for tc in tool_calls
+            ]
+            tc_content += '\n\n' + tool_calls_template.format(
+                dsml_token=dsml_token,
+                tool_calls="\n".join(tc_list),
+                tc_block_name=tool_calls_block_name,
+            )
+
+        summary_content = content or ""
+        rc = reasoning_content or ""
+
+        # Check if previous message has a task - if so, this is a task output (no thinking)
+        prev_has_task = index - 1 >= 0 and messages[index - 1].get("task") is not None
+
+        if thinking_mode == "thinking" and not prev_has_task:
+            if not drop_thinking or index > last_user_idx:
+                thinking_part = thinking_template.format(reasoning_content=rc) + thinking_end_token
+            else:
+                thinking_part = ""
+
+        if wo_eos:
+            prompt += assistant_msg_wo_eos_template.format(
+                reasoning=thinking_part,
+                content=summary_content,
+                tool_calls=tc_content,
+            )
+        else:
+            prompt += assistant_msg_template.format(
+                reasoning=thinking_part,
+                content=summary_content,
+                tool_calls=tc_content,
+            )
+    else:
+        raise NotImplementedError(f"Unknown role: {role}")
+
+    # Append transition tokens based on what follows
+    if index + 1 < len(messages) and messages[index + 1].get("role") not in ["assistant", "latest_reminder"]:
+        return prompt
+
+    task = messages[index].get("task")
+    if task is not None:
+        # Task special token for internal classification tasks
+        assert task in VALID_TASKS, f"Invalid task: '{task}'. Valid tasks are: {list(VALID_TASKS)}"
+        task_sp_token = DS_TASK_SP_TOKENS[task]
+
+        if task != "action":
+            # Non-action tasks: append task sp token directly after the message
+            prompt += task_sp_token
+        else:
+            # Action task: append Assistant + thinking token + action sp token
+            prompt += ASSISTANT_SP_TOKEN
+            prompt += thinking_end_token if thinking_mode != "thinking" else thinking_start_token
+            prompt += task_sp_token
+
+    elif role == "user" or (role == "system" and index > 0):
+        # Normal generation: append Assistant + thinking token
+        # (mid-conversation system messages also trigger the assistant header)
+        prompt += ASSISTANT_SP_TOKEN
+        if not drop_thinking and thinking_mode == "thinking":
+            prompt += thinking_start_token
+        elif drop_thinking and thinking_mode == "thinking" and index >= last_user_idx:
+            prompt += thinking_start_token
+        else:
+            prompt += thinking_end_token
+
+    return prompt
+
+
+# ============================================================
+# Main Encoding Function
+# ============================================================
+
+def _drop_thinking_messages(messages: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    """
+    Drop reasoning_content and non-essential messages before the last user message.
+    Same as V4, but uses the V4.1 last-user definition (mid systems count).
+    """
+    last_user_idx = find_last_user_index(messages)
+    result = []
+    keep_roles = {"user", "system", "tool", "latest_reminder", "direct_search_results"}
+
+    for idx, msg in enumerate(messages):
+        role = msg.get("role")
+        if role in keep_roles or idx >= last_user_idx:
+            result.append(msg)
+        elif role == "assistant":
+            msg = copy.copy(msg)
+            msg.pop("reasoning_content", None)
+            result.append(msg)
+
+    return result
+
+
+def _encode_messages_text(
+    messages: List[Dict[str, Any]],
+    thinking_mode: str,
+    context: Optional[List[Dict[str, Any]]] = None,
+    drop_thinking: bool = True,
+    add_default_bos_token: bool = True,
+    reasoning_effort: Union[str, int, None] = None,
+) -> str:
+    """Encode preprocessed (text-only) messages into the V4.1 prompt format."""
+    context = context if context else []
+
+    full_messages = context + messages
+
+    prompt = bos_token if add_default_bos_token and len(context) == 0 else ""
+
+    # Resolve drop_thinking: if any message has tools defined, don't drop thinking
+    effective_drop_thinking = drop_thinking
+    if any(m.get("tools") for m in full_messages):
+        effective_drop_thinking = False
+
+    if thinking_mode == "thinking" and effective_drop_thinking:
+        full_messages = _drop_thinking_messages(full_messages)
+        num_to_render = len(full_messages) - len(_drop_thinking_messages(context))
+        context_len = len(full_messages) - num_to_render
+    else:
+        num_to_render = len(messages)
+        context_len = len(context)
+
+    for idx in range(num_to_render):
+        prompt += render_message(
+            idx + context_len,
+            full_messages,
+            thinking_mode=thinking_mode,
+            drop_thinking=effective_drop_thinking,
+            reasoning_effort=reasoning_effort,
+        )
+
+    return prompt
+
+
+def encode_messages(
+    messages: List[Dict[str, Any]],
+    thinking_mode: str,
+    context: Optional[List[Dict[str, Any]]] = None,
+    drop_thinking: bool = True,
+    add_default_bos_token: bool = True,
+    reasoning_effort: Union[str, int, None] = None,
+    return_multi_modal_data: bool = False,
+) -> Any:
+    """Encode text or multimodal messages into the DeepSeek-V4.1 prompt format.
+
+    Text-only calls return the prompt string. When return_multi_modal_data is
+    true, the result is ``(prompt, media_data)``.
+    """
+    # Validate before merging can discard message-level textual fields.
+    for msg in (context or []) + messages:
+        _validate_no_image_sp_tokens(msg)
+
+    # Collect images only after tool results are in their final prompt order.
+    context = merge_tool_messages(context or [])
+    messages = merge_tool_messages(messages)
+    messages = sort_tool_results_by_call_order(context + messages)[len(context):]
+    processed_context, _ = process_image_messages(context) if context else ([], [])
+    processed_messages, images = process_image_messages(messages)
+    prompt = _encode_messages_text(
+        processed_messages,
+        thinking_mode=thinking_mode,
+        context=processed_context if processed_context else None,
+        drop_thinking=drop_thinking,
+        add_default_bos_token=add_default_bos_token,
+        reasoning_effort=reasoning_effort,
+    )
+    if return_multi_modal_data:
+        return prompt, {"images": images}
+    return prompt
+
+
+def load_cases(input_file: str) -> List[Dict[str, Any]]:
+    """Load one or more OpenAI-format conversation cases from JSON."""
+    with open(input_file) as file:
+        data = json.load(file)
+    if isinstance(data, dict):
+        data = [data]
+    elif data and isinstance(data[0], dict) and "role" in data[0]:
+        data = [{"messages": data}]
+
+    cases = []
+    for case in data:
+        messages = copy.deepcopy(case["messages"])
+        if "tools" in case:
+            if not messages:
+                raise ValueError("A case with tools must contain at least one message")
+            messages[0]["tools"] = case["tools"]
+        cases.append({
+            "messages": messages,
+            "context": case.get("context"),
+            "thinking_mode": case.get("thinking_mode"),
+            "reasoning_effort": case.get("reasoning_effort"),
+        })
+    return cases
+
+
+def encode_case(
+    case: Dict[str, Any], thinking_mode: str
+) -> Tuple[str, List[Dict[str, Any]]]:
+    """Encode one JSON case and return its current-turn image records."""
+    prompt, media_data = encode_messages(
+        case["messages"],
+        thinking_mode=case.get("thinking_mode") or thinking_mode,
+        context=case.get("context"),
+        reasoning_effort=case.get("reasoning_effort"),
+        return_multi_modal_data=True,
+    )
+    return prompt, media_data["images"]
+
+
+# ============================================================
+# Parsing (Decoding model output)
+# ============================================================
+
+def parse_tool_calls(index: int, text: str) -> Tuple[int, Optional[str], List[Dict[str, str]]]:
+    """
+    Parse V4.1 DSML tool calls from text starting at the given index.
+
+    Returns:
+        Tuple of (new_index, last_stop_token, list_of_tool_call_dicts).
+    """
+    tool_calls: List[Dict[str, Any]] = []
+    stop_token = None
+    tool_calls_end_token = f"</{dsml_token}{tool_calls_block_name}>"
+    tool_call_start_token = f"<{dsml_token}{tool_call_tag_name}"
+    tool_call_end_token = f"</{dsml_token}{tool_call_tag_name}"
+    tool_parameter_start_token = f"<{dsml_token}{tool_parameter_tag_name}"
+    tool_parameter_end_token = f"/{dsml_token}{tool_parameter_tag_name}"
+
+    while index < len(text):
+        index, _, stop_token = _read_until_stop(index, text, [tool_call_start_token, tool_calls_end_token])
+        if _ != ">\n":
+            raise ValueError(f"Tool call format error: expected '>\\n' but got '{_}'")
+
+        if stop_token == tool_calls_end_token:
+            break
+
+        if stop_token is None:
+            raise ValueError("Missing special token in tool calls")
+
+        index, tool_name_content, stop_token = _read_until_stop(index, text, [tool_parameter_start_token, tool_call_end_token])
+
+        p_tool_name = re.findall(r'^\s*name="(.*?)">\n$', tool_name_content, flags=re.DOTALL)
+        if len(p_tool_name) != 1:
+            raise ValueError(f"Tool name format error: '{tool_name_content}'")
+        tool_name = p_tool_name[0]
+
+        tool_args: Dict[str, Tuple[str, str]] = {}
+        while stop_token == tool_parameter_start_token:
+            index, param_content, stop_token = _read_until_stop(index, text, [tool_parameter_end_token])
+
+            param_kv = re.findall(r'^ name="(.*?)" string="(true|false)">(.*?)<$', param_content, flags=re.DOTALL)
+            if len(param_kv) != 1:
+                raise ValueError(f"Parameter format error: '{param_content}'")
+            param_name, string, param_value = param_kv[0]
+
+            if param_name in tool_args:
+                raise ValueError(f"Duplicate parameter name: '{param_name}'")
+            tool_args[param_name] = (param_value, string)
+
+            index, content, stop_token = _read_until_stop(index, text, [tool_parameter_start_token, tool_call_end_token])
+            if content != ">\n":
+                raise ValueError(f"Parameter format error: expected '>\\n' but got '{content}'")
+
+        tool_call = decode_dsml_to_arguments(tool_name=tool_name, tool_args=tool_args)
+        tool_calls.append(tool_call)
+
+    return index, stop_token, tool_calls
+
+
+def parse_message_from_completion_text(text: str, thinking_mode: str) -> Dict[str, Any]:
+    """
+    Parse a model completion text into a structured assistant message (V4.1 format).
+
+    Returns:
+        Dict with keys: "role", "content", "reasoning_content", "tool_calls".
+        tool_calls are in OpenAI format.
+    """
+    summary_content, reasoning_content, tool_calls = "", "", []
+    index, stop_token = 0, None
+    tool_calls_start_token = f"\n\n<{dsml_token}{tool_calls_block_name}"
+
+    is_thinking = thinking_mode == "thinking"
+    is_tool_calling = False
+
+    if is_thinking:
+        index, content_delta, stop_token = _read_until_stop(index, text, [thinking_end_token, tool_calls_start_token])
+        reasoning_content = content_delta
+        assert stop_token == thinking_end_token, "Invalid thinking format: missing </think>"
+
+    index, content_delta, stop_token = _read_until_stop(index, text, [eos_token, tool_calls_start_token])
+    summary_content = content_delta
+    if stop_token == tool_calls_start_token:
+        is_tool_calling = True
+    else:
+        assert stop_token == eos_token, "Invalid format: missing EOS token"
+
+    if is_tool_calling:
+        index, stop_token, tool_calls = parse_tool_calls(index, text)
+
+        index, tool_ends_text, stop_token = _read_until_stop(index, text, [eos_token])
+        assert not tool_ends_text, "Unexpected content after tool calls"
+
+    assert len(text) == index and stop_token in [eos_token, None], "Unexpected content at end"
+
+    for sp_token in [bos_token, eos_token, thinking_start_token, thinking_end_token, dsml_token]:
+        assert sp_token not in summary_content and sp_token not in reasoning_content, \
+            f"Unexpected special token '{sp_token}' in content"
+
+    return {
+        "role": "assistant",
+        "content": summary_content,
+        "reasoning_content": reasoning_content,
+        "tool_calls": tool_calls_to_openai_format(tool_calls)
+    }

encoding/test_encoding.py

@@ -0,0 +1,652 @@
+"""
+Tests for encoding.py (DeepSeek-V4.1 encoding).
+
+Adapted from dsv41-master/deepseek_harmony/tests/test_deepseek_v41.py for the
+self-contained dict-based API in this repo.
+"""
+
+import copy
+import json
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import encoding as enc
+from encoding import (
+    IMAGE_PLACEHOLDER,
+    SYSTEM_SP_TOKEN,
+    encode_messages,
+    parse_message_from_completion_text,
+    render_message,
+    merge_tool_messages,
+)
+
+
+REASONING_EFFORT_TEMPLATE = (
+    SYSTEM_SP_TOKEN + "Reasoning Effort: {budget} "
+    "(range 1-100, the higher the value, the more thorough the reasoning)\n\n"
+)
+
+V41_TOOL_CALL_OUTPUT = (
+    '  reason  </think>summary\n\n'
+    '<｜DSML｜ calls>\n'
+    '<｜DSML｜ invoke name="lookup">\n'
+    '<｜DSML｜ parameter name="query" string="true">value'
+    '</｜DSML｜ parameter>\n'
+    '<｜DSML｜ parameter name="limit" string="false">2'
+    '</｜DSML｜ parameter>\n'
+    '</｜DSML｜ invoke>\n'
+    '</｜DSML｜ calls><｜end▁of▁sentence｜>'
+)
+
+
+def make_tool() -> dict:
+    return {
+        "type": "function",
+        "function": {
+            "name": "lookup",
+            "description": "Look up a value",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string"},
+                    "limit": {"type": "integer"},
+                },
+            },
+        },
+    }
+
+
+def make_tool_call_messages() -> list:
+    return [
+        {"role": "user", "content": "question"},
+        {
+            "role": "assistant",
+            "reasoning_content": "  reason  ",
+            "content": "summary",
+            "tool_calls": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "lookup",
+                        "arguments": '{"query":"value","limit":2}',
+                    },
+                }
+            ],
+        },
+    ]
+
+
+# ============================================================
+# Vision
+# ============================================================
+
+def test_v41_renders_images() -> None:
+    prompt, media = encode_messages(
+        [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "inspect"},
+                    {"type": "image_url", "image_url": {"url": "/unused/image.png"}},
+                ],
+            }
+        ],
+        thinking_mode="chat",
+        return_multi_modal_data=True,
+    )
+
+    assert prompt == (
+        '<｜begin▁of▁sentence｜><｜User｜>inspect\n\n'
+        f'{IMAGE_PLACEHOLDER}<｜Assistant｜></think>'
+    )
+    assert media == {"images": [{"type": "image", "url": "/unused/image.png"}]}
+
+
+@pytest.mark.parametrize("role", ["user", "tool"])
+def test_v41_rejects_image_placeholder_in_text(role: str) -> None:
+    with pytest.raises(ValueError):
+        encode_messages(
+            [{"role": role, "content": f"hi {IMAGE_PLACEHOLDER}"}],
+            thinking_mode="chat",
+        )
+
+
+@pytest.mark.parametrize(
+    "input_format",
+    ["content_blocks", "tool_messages", "tool_content_blocks", "context"],
+)
+def test_v41_tool_result_images_follow_prompt_order(input_format: str) -> None:
+    history = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "image_url", "image_url": {"url": "history.png"}},
+            ],
+        },
+        {
+            "role": "assistant",
+            "tool_calls": [
+                {
+                    "id": name,
+                    "type": "function",
+                    "function": {"name": name, "arguments": "{}"},
+                }
+                for name in ("a", "b")
+            ],
+        },
+    ]
+    results = [
+        {
+            "type": "tool_result",
+            "tool_use_id": name,
+            "content": [
+                {"type": "text", "text": f"result {name}"},
+                {"type": "image_url", "image_url": {"url": f"{name}.png"}},
+            ],
+        }
+        for name in ("b", "a")
+    ]
+    if input_format in ("tool_messages", "tool_content_blocks"):
+        content_field = (
+            "content_blocks" if input_format == "tool_content_blocks" else "content"
+        )
+        messages = history + [
+            {
+                "role": "tool",
+                "tool_call_id": block["tool_use_id"],
+                content_field: block["content"],
+            }
+            for block in results
+        ]
+        context = []
+    elif input_format == "context":
+        messages = [{"role": "user", "content_blocks": results}]
+        context = history
+    else:
+        messages = history + [{"role": "user", "content_blocks": results}]
+        context = []
+    original = copy.deepcopy((messages, context))
+
+    prompt, media = encode_messages(
+        messages,
+        thinking_mode="chat",
+        context=context,
+        return_multi_modal_data=True,
+    )
+
+    assert prompt.endswith(
+        f"<｜User｜><tool_result>result a\n\n{IMAGE_PLACEHOLDER}</tool_result>\n\n"
+        f"<tool_result>result b\n\n{IMAGE_PLACEHOLDER}</tool_result><｜Assistant｜></think>"
+    )
+    expected_urls = ["a.png", "b.png"] if context else ["history.png", "a.png", "b.png"]
+    assert media == {"images": [{"type": "image", "url": url} for url in expected_urls]}
+    assert (messages, context) == original
+
+
+# ============================================================
+# Reasoning Effort
+# ============================================================
+
+@pytest.mark.parametrize(
+    ("effort", "budget"),
+    [
+        (None, 75),
+        ("low", 50),
+        ("high", 75),
+        ("max", 100),
+        (1, 1),
+        (42, 42),
+        (100, 100),
+    ],
+)
+def test_v41_maps_reasoning_effort_to_1_100_budget(
+    effort: Any,
+    budget: int,
+) -> None:
+    prompt = encode_messages(
+        [{"role": "user", "content": "question"}],
+        thinking_mode="thinking",
+        reasoning_effort=effort,
+    )
+
+    assert prompt == (
+        '<｜begin▁of▁sentence｜>'
+        f'{REASONING_EFFORT_TEMPLATE.format(budget=budget)}'
+        '<｜User｜>question<｜Assistant｜><think>'
+    )
+
+
+def test_v41_only_adds_reasoning_effort_to_first_thinking_message() -> None:
+    messages = [
+        {"role": "system", "content": "system"},
+        {"role": "user", "content": "question"},
+    ]
+
+    later_message = render_message(
+        1, messages, thinking_mode="thinking", reasoning_effort=100
+    )
+    chat_message = render_message(
+        0, messages, thinking_mode="chat", reasoning_effort=100
+    )
+
+    assert "Reasoning Effort:" not in later_message
+    assert "Reasoning Effort:" not in chat_message
+
+
+def test_v41_chat_mode_has_no_reasoning_effort_or_system_token() -> None:
+    prompt = encode_messages(
+        [{"role": "user", "content": "hello"}],
+        thinking_mode="chat",
+        reasoning_effort="max",
+    )
+    assert prompt == '<｜begin▁of▁sentence｜><｜User｜>hello<｜Assistant｜></think>'
+
+
+@pytest.mark.parametrize("effort", [-1, 0, 101, "medium"])
+def test_v41_rejects_out_of_range_or_unknown_reasoning_effort(
+    effort: Any,
+) -> None:
+    with pytest.raises(AssertionError, match=r"int within \[1,100\]"):
+        encode_messages(
+            [{"role": "user", "content": "question"}],
+            thinking_mode="thinking",
+            reasoning_effort=effort,
+        )
+
+
+@pytest.mark.parametrize("effort", [True, False, 1.5])
+def test_v41_rejects_non_string_non_integer_effort_types(effort: Any) -> None:
+    # bool is not `type(...) is int`; float is invalid too
+    with pytest.raises(AssertionError):
+        encode_messages(
+            [{"role": "user", "content": "question"}],
+            thinking_mode="thinking",
+            reasoning_effort=effort,
+        )
+
+
+# ============================================================
+# System token
+# ============================================================
+
+def test_v41_leading_system_message_uses_system_token() -> None:
+    prompt = encode_messages(
+        [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": "hello"},
+        ],
+        thinking_mode="chat",
+    )
+    assert prompt == (
+        '<｜begin▁of▁sentence｜><｜System｜>You are a helpful assistant.'
+        '<｜User｜>hello<｜Assistant｜></think>'
+    )
+
+
+def test_v41_mid_conversation_system_message() -> None:
+    prompt = encode_messages(
+        [
+            {"role": "system", "content": "sys"},
+            {"role": "user", "content": "q1"},
+            {"role": "assistant", "content": "a1", "reasoning_content": "r1"},
+            {"role": "system", "content": "mid sys"},
+        ],
+        thinking_mode="thinking",
+        reasoning_effort=88,
+    )
+    # Mid-conversation system gets its own <｜System｜> token and triggers
+    # the assistant generation header afterwards.
+    assert prompt == (
+        '<｜begin▁of▁sentence｜>'
+        f'{REASONING_EFFORT_TEMPLATE.format(budget=88)}'
+        'sys<｜User｜>q1<｜Assistant｜></think>a1<｜end▁of▁sentence｜>'
+        '<｜System｜>mid sys<｜Assistant｜><think>'
+    )
+
+
+# ============================================================
+# DSML tool tags
+# ============================================================
+
+def test_v41_tool_instructions_use_spaced_dsml_tags_in_chat_mode() -> None:
+    prompt = encode_messages(
+        [
+            {"role": "system", "content": "system", "tools": [make_tool()]},
+            {"role": "user", "content": "question"},
+        ],
+        thinking_mode="chat",
+    )
+
+    assert (
+        '<｜DSML｜ calls>\n'
+        '<｜DSML｜ invoke name="$TOOL_NAME">\n'
+        '<｜DSML｜ parameter name="$PARAMETER_NAME" '
+        'string="true|false">$PARAMETER_VALUE</｜DSML｜ parameter>\n'
+        '...\n'
+        '</｜DSML｜ invoke>'
+    ) in prompt
+    assert '<｜DSML｜tool_calls>' not in prompt
+    assert '<｜DSML｜invoke' not in prompt
+    assert '<｜DSML｜parameter' not in prompt
+
+
+def test_v41_renders_spaced_dsml_with_v4_assistant_semantics() -> None:
+    messages = make_tool_call_messages()
+
+    prompt = render_message(1, messages, thinking_mode="thinking")
+
+    assert prompt == V41_TOOL_CALL_OUTPUT
+
+
+def test_v41_parses_spaced_dsml_roundtrip() -> None:
+    messages = make_tool_call_messages()
+
+    parsed = parse_message_from_completion_text(
+        V41_TOOL_CALL_OUTPUT, thinking_mode="thinking"
+    )
+
+    assert parsed["role"] == "assistant"
+    assert parsed["reasoning_content"] == "  reason  "
+    assert parsed["content"] == "summary"
+    assert parsed["tool_calls"]
+    assert parsed["tool_calls"][0]["function"]["name"] == "lookup"
+    assert json.loads(parsed["tool_calls"][0]["function"]["arguments"]) == {
+        "query": "value",
+        "limit": 2,
+    }
+
+    # Re-encoding the parsed message reproduces the original completion text
+    assert encode_messages(
+        [parsed],
+        thinking_mode="thinking",
+        context=messages[:1],
+    ) == V41_TOOL_CALL_OUTPUT
+
+
+def test_v41_parse_rejects_unspaced_v4_dsml() -> None:
+    v4_output = V41_TOOL_CALL_OUTPUT.replace("｜DSML｜ calls", "｜DSML｜tool_calls") \
+        .replace("｜DSML｜ invoke", "｜DSML｜invoke") \
+        .replace("｜DSML｜ parameter", "｜DSML｜parameter")
+    with pytest.raises(AssertionError):
+        parse_message_from_completion_text(v4_output, thinking_mode="thinking")
+
+
+# ============================================================
+# Tool namespaces
+# ============================================================
+
+@pytest.mark.parametrize("location", ["tool", "function"])
+@pytest.mark.parametrize("namespace", ["search", {"name": "search", "description": "Search tools."}])
+def test_v41_renders_namespaced_tool_schemas(location: str, namespace: Any) -> None:
+    tool = make_tool()
+    target = tool if location == "tool" else tool["function"]
+    target["namespace"] = namespace
+    original = copy.deepcopy(tool)
+
+    prompt = encode_messages(
+        [{"role": "system", "content": "system", "tools": [tool]}],
+        thinking_mode="chat",
+    )
+
+    schema = dict(make_tool()["function"], name="search::lookup")
+    if isinstance(namespace, dict):
+        schema["description"] = "Search tools.\nLook up a value"
+    assert json.dumps(schema) in prompt
+    assert '"namespace":' not in prompt
+    assert tool == original
+
+
+@pytest.mark.parametrize("thinking_mode", ["chat", "thinking"])
+@pytest.mark.parametrize("location", ["tool", "function", "qualified_name"])
+def test_v41_namespaced_tool_calls_roundtrip(thinking_mode: str, location: str) -> None:
+    messages = make_tool_call_messages()
+    call = messages[1]["tool_calls"][0]
+    if location == "qualified_name":
+        call["function"]["name"] = "search::lookup"
+    else:
+        target = call if location == "tool" else call["function"]
+        target["namespace"] = "search"
+    original = copy.deepcopy(messages)
+
+    expected = V41_TOOL_CALL_OUTPUT.replace('name="lookup"', 'name="search::lookup"')
+    if thinking_mode == "chat":
+        expected = expected.split("</think>", 1)[1]
+    assert render_message(1, messages, thinking_mode=thinking_mode) == expected
+
+    parsed = parse_message_from_completion_text(expected, thinking_mode=thinking_mode)
+    assert parsed["tool_calls"] == [{
+        "type": "function",
+        "namespace": "search",
+        "function": {
+            "name": "lookup",
+            "arguments": '{"query": "value", "limit": 2}',
+        },
+    }]
+    assert encode_messages(
+        [parsed], thinking_mode=thinking_mode, context=messages[:1]
+    ) == expected
+    assert messages == original
+
+
+def test_v41_keeps_same_named_tools_in_separate_namespaces() -> None:
+    tools, calls = [], []
+    for namespace in (None, "search", "files"):
+        tool = make_tool()
+        call = {
+            "type": "function",
+            "function": {"name": "lookup", "arguments": '{"query":"value"}'},
+        }
+        if namespace is not None:
+            tool["namespace"] = {"name": namespace}
+            call["namespace"] = namespace
+        tools.append(tool)
+        calls.append(call)
+
+    messages = [
+        {"role": "system", "content": "system", "tools": tools},
+        {"role": "user", "content": "question"},
+        {"role": "assistant", "content": "summary", "tool_calls": calls},
+    ]
+    prompt = encode_messages(messages, thinking_mode="chat")
+    for name in ("lookup", "search::lookup", "files::lookup"):
+        assert f'"name": "{name}"' in prompt
+        assert f'<｜DSML｜ invoke name="{name}">' in prompt
+
+    completion = render_message(2, messages, thinking_mode="chat")
+    parsed = parse_message_from_completion_text(completion, thinking_mode="chat")
+    assert "namespace" not in parsed["tool_calls"][0]
+    assert [call.get("namespace") for call in parsed["tool_calls"]] == [None, "search", "files"]
+    assert all(call["function"]["name"] == "lookup" for call in parsed["tool_calls"])
+
+
+def test_v41_does_not_duplicate_a_qualified_namespace() -> None:
+    tool = make_tool()
+    tool["function"]["name"] = "search::lookup"
+    tool["namespace"] = {"name": "search", "description": "Search tools."}
+    schema = enc.tools_from_openai_format([tool])[0]
+    assert schema["name"] == "search::lookup"
+    assert schema["description"] == "Search tools.\nLook up a value"
+
+    messages = make_tool_call_messages()
+    call = messages[1]["tool_calls"][0]
+    call["function"]["name"] = "search::lookup"
+    call["namespace"] = "search"
+    assert render_message(1, messages, thinking_mode="thinking") == (
+        V41_TOOL_CALL_OUTPUT.replace('name="lookup"', 'name="search::lookup"')
+    )
+
+
+@pytest.mark.parametrize(
+    ("name", "namespace", "error"),
+    [
+        ("search::lookup", "files", "Conflicting tool namespaces"),
+        ("search::nested::lookup", None, "Tool name must not contain"),
+        ("lookup", "search::nested", "Tool namespace must not contain"),
+    ],
+)
+def test_v41_rejects_ambiguous_tool_namespaces(name: str, namespace: Any, error: str) -> None:
+    tool = make_tool()
+    tool["function"]["name"] = name
+    tool["namespace"] = namespace
+    with pytest.raises(AssertionError, match=error):
+        enc.tools_from_openai_format([tool])
+
+    messages = make_tool_call_messages()
+    call = messages[1]["tool_calls"][0]
+    call["function"]["name"] = name
+    call["namespace"] = namespace
+    with pytest.raises(AssertionError, match=error):
+        render_message(1, messages, thinking_mode="thinking")
+
+
+# ============================================================
+# Multi-turn flow
+# ============================================================
+
+def test_v41_drop_thinking_without_tools() -> None:
+    messages = [
+        {"role": "user", "content": "q1"},
+        {"role": "assistant", "content": "a1", "reasoning_content": "r1"},
+        {"role": "user", "content": "q2"},
+        {
+            "role": "assistant",
+            "reasoning_content": "r2",
+            "tool_calls": [
+                {
+                    "id": "c1",
+                    "type": "function",
+                    "function": {"name": "lookup", "arguments": "{}"},
+                }
+            ],
+        },
+        {"role": "tool", "tool_call_id": "c1", "content": "value"},
+    ]
+    prompt = encode_messages(
+        messages,
+        thinking_mode="thinking",
+        drop_thinking=True,
+    )
+    # Drop completed-turn reasoning, but keep the current turn across tool results.
+    assert "<｜User｜>q1<｜Assistant｜></think>a1<｜end▁of▁sentence｜>" in prompt
+    assert "r1" not in prompt
+    assert "<think>r2</think>" in prompt
+    assert prompt.endswith("<tool_result>value</tool_result><｜Assistant｜><think>")
+
+    next_turn = encode_messages(
+        messages + [{"role": "user", "content": "q3"}],
+        thinking_mode="thinking",
+    )
+    assert "r2" not in next_turn
+    assert next_turn.endswith("q3<｜Assistant｜><think>")
+
+
+# ============================================================
+# Preprocessing
+# ============================================================
+
+def test_merge_tool_messages_creates_tool_result_blocks() -> None:
+    merged = merge_tool_messages([
+        {"role": "assistant", "content": "", "tool_calls": []},
+        {"role": "tool", "tool_call_id": "a", "content": "r1"},
+        {"role": "tool", "tool_call_id": "b", "content": "r2"},
+    ])
+    assert len(merged) == 2
+    assert merged[1]["role"] == "user"
+    assert [b["type"] for b in merged[1]["content_blocks"]] == ["tool_result", "tool_result"]
+
+
+def test_v41_task_sp_token() -> None:
+    prompt = encode_messages(
+        [{"role": "user", "content": "classify me", "task": "query"}],
+        thinking_mode="chat",
+    )
+    assert prompt.endswith("classify me<｜query｜>")
+    assert "<｜Assistant｜>" not in prompt
+
+
+# ============================================================
+# Golden fixtures from encoding/tests
+# ============================================================
+
+ENCODING_DIR = Path(__file__).resolve().parent
+ENCODING_FIXTURES_DIR = ENCODING_DIR / "tests"
+INFERENCE_EXAMPLES_DIR = ENCODING_DIR.parent / "inference" / "examples"
+
+FIXTURE_CASE_IDS = sorted(
+    int(p.stem.split("_")[-1])
+    for p in ENCODING_FIXTURES_DIR.glob("test_input_*.json")
+)
+
+
+@pytest.mark.parametrize("case_id", FIXTURE_CASE_IDS)
+def test_examples_encoding_golden_outputs(case_id: int) -> None:
+    """Each tests/encoding input must encode to its checked-in golden output."""
+    input_file = ENCODING_FIXTURES_DIR / f"test_input_{case_id}.json"
+    output_file = ENCODING_FIXTURES_DIR / f"test_output_{case_id}.txt"
+    assert output_file.exists(), f"missing golden output: {output_file.name} (run tests/encoding/regen_outputs.py)"
+
+    case = enc.load_cases(str(input_file))[0]
+    prompt, _ = enc.encode_case(case, thinking_mode="chat")
+
+    assert prompt == output_file.read_text(), (
+        f"{output_file.name} is stale; regenerate with tests/encoding/regen_outputs.py"
+    )
+
+
+def test_examples_v41_output_uses_v41_format_markers() -> None:
+    """Sanity-check the V4.1 goldens actually exercise V4.1-specific format."""
+    # case 1: tool calls with spaced DSML tags
+    out1 = (ENCODING_FIXTURES_DIR / "test_output_1.txt").read_text()
+    assert '<｜DSML｜ calls>' in out1 and '<｜DSML｜ invoke name="get_weather">' in out1
+    assert '<｜DSML｜tool_calls>' not in out1
+
+    # case 5: numeric reasoning effort behind the system token
+    out5 = (ENCODING_FIXTURES_DIR / "test_output_5.txt").read_text()
+    assert out5.startswith(
+        '<｜begin▁of▁sentence｜>' + REASONING_EFFORT_TEMPLATE.format(budget=100)
+    )
+    assert out5.count(IMAGE_PLACEHOLDER) == 2
+
+
+def test_examples_vl_txt_and_json_encode_identically() -> None:
+    """The TXT (last block of example.txt) and JSON vision examples must encode identically."""
+    txt = (INFERENCE_EXAMPLES_DIR / "example.txt").read_text().rstrip("\n").split("\n\n")[-1]
+    messages = [{"role": "user", "content": enc.parse_tagged_text(txt)}]
+    p1, m1 = encode_messages(messages, thinking_mode="chat", return_multi_modal_data=True)
+
+    case = enc.load_cases(str(INFERENCE_EXAMPLES_DIR / "example_harmony.json"))[0]
+    p2, m2 = enc.encode_case(case, thinking_mode="chat")
+
+    assert p1 == p2
+    assert m1["images"] == m2
+    assert len(m2) == 2
+
+
+def test_examples_harmony_cases_encode() -> None:
+    """All example_harmony.json cases encode without error."""
+    cases = enc.load_cases(str(INFERENCE_EXAMPLES_DIR / "example_harmony.json"))
+    assert len(cases) == 4
+
+    # case 1 (vision) is covered by test_examples_vl_txt_and_json_encode_identically
+
+    # cases are pure OpenAI format: mode/effort are passed at call time
+    prompt = encode_messages(
+        cases[1]["messages"], thinking_mode="thinking", reasoning_effort=75
+    )
+    assert REASONING_EFFORT_TEMPLATE.format(budget=75) in prompt
+
+    # case 3: tools with spaced DSML tags
+    prompt, _ = enc.encode_case(cases[2], thinking_mode="chat")
+    assert '<｜DSML｜ calls>' in prompt
+
+    # case 4: mid-conversation system message triggers assistant header
+    prompt, _ = enc.encode_case(cases[3], thinking_mode="chat")
+    assert '<｜System｜>Mid-conversation instruction update' in prompt
+    assert prompt.endswith('<｜Assistant｜></think>')
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(pytest.main([__file__, "-v"]))

encoding/tests/test_input_1.json

@@ -0,0 +1,82 @@
+{
+    "thinking_mode": "thinking",
+    "tools": [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "Get the weather for a specific location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city name"
+                        },
+                        "unit": {
+                            "type": "string",
+                            "enum": ["celsius", "fahrenheit"],
+                            "description": "Temperature unit"
+                        }
+                    },
+                    "required": ["location"]
+                }
+            }
+        },
+        {
+            "type": "function",
+            "function": {
+                "name": "search",
+                "description": "Search the web for information",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "query": {
+                            "type": "string",
+                            "description": "Search query"
+                        },
+                        "num_results": {
+                            "type": "integer",
+                            "description": "Number of results to return"
+                        }
+                    },
+                    "required": ["query"]
+                }
+            }
+        }
+    ],
+    "messages": [
+        {
+            "role": "system",
+            "content": "You are a helpful assistant."
+        },
+        {
+            "role": "user",
+            "content": "What's the weather like in Beijing?"
+        },
+        {
+            "role": "assistant",
+            "reasoning_content": "The user wants the weather in Beijing. I should call get_weather.",
+            "content": "",
+            "tool_calls": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "get_weather",
+                        "arguments": "{\"location\": \"Beijing\", \"unit\": \"celsius\"}"
+                    }
+                }
+            ]
+        },
+        {
+            "role": "tool",
+            "tool_call_id": "call_0",
+            "content": "{\"temperature\": 22, \"condition\": \"sunny\", \"humidity\": 45}"
+        },
+        {
+            "role": "assistant",
+            "reasoning_content": "Got the weather data. Let me format a nice response.",
+            "content": "The weather in Beijing is currently sunny with a temperature of 22\u00b0C and 45% humidity."
+        }
+    ]
+}

encoding/tests/test_input_2.json

@@ -0,0 +1,24 @@
+[
+  {
+    "role": "system",
+    "content": "You are a helpful assistant."
+  },
+  {
+    "role": "user",
+    "content": "Hello"
+  },
+  {
+    "role": "assistant",
+    "reasoning_content": "The user said hello, I should greet back.",
+    "content": "Hi there! How can I help you?"
+  },
+  {
+    "role": "user",
+    "content": "What is the capital of France?"
+  },
+  {
+    "role": "assistant",
+    "reasoning_content": "The user asks about the capital of France. It is Paris.",
+    "content": "The capital of France is Paris."
+  }
+]

encoding/tests/test_input_3.json

@@ -0,0 +1,93 @@
+[
+  {
+    "role": "system",
+    "content": "该助手为DeepSeek，由深度求索公司创造。"
+  },
+  {
+    "role": "latest_reminder",
+    "content": "2026-02-21,星期六,广州,App,中文"
+  },
+  {
+    "role": "system",
+    "content": "CITATION FORMAT: 【{cursor_id}†L{start_line_id}(-L{end_line_id})?】",
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "search",
+          "description": "Web search. Split multiple queries with '||'.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "queries": {
+                "type": "string",
+                "description": "query1||query2"
+              }
+            },
+            "required": ["queries"],
+            "additionalProperties": false
+          }
+        }
+      },
+      {
+        "type": "function",
+        "function": {
+          "name": "open",
+          "description": "Batch open IDs (format 【{id}†...】) or URLs.",
+          "parameters": {
+            "type": "object",
+            "properties": {
+              "open_list": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "id": {
+                      "description": "ID or URL",
+                      "anyOf": [{"type": "integer"}, {"type": "string"}],
+                      "default": -1
+                    },
+                    "loc": {"type": "integer", "description": "Start line", "default": -1},
+                    "num_lines": {"type": "integer", "description": "", "default": -1}
+                  },
+                  "additionalProperties": false
+                },
+                "description": ""
+              }
+            },
+            "required": ["open_list"],
+            "additionalProperties": false
+          }
+        }
+      }
+    ]
+  },
+  {
+    "role": "user",
+    "content": "小柴胡冲剂和布洛芬能一起吃吗？"
+  },
+  {
+    "role": "assistant",
+    "content": "",
+    "reasoning_content": "用户想知道小柴胡冲剂和布洛芬能否一起服用。",
+    "tool_calls": [
+      {
+        "type": "function",
+        "function": {
+          "name": "search",
+          "arguments": "{\"queries\": \"小柴胡冲剂 布洛芬 相互作用 一起吃\"}"
+        }
+      }
+    ]
+  },
+  {
+    "role": "tool",
+    "content": "[0]"
+  },
+  {
+    "role": "assistant",
+    "content": "请及时就医。",
+    "reasoning_content": "现在开始组织回答。",
+    "tool_calls": []
+  }
+]

encoding/tests/test_input_4.json

@@ -0,0 +1,28 @@
+[
+  {
+    "role": "system",
+    "content": "该助手为DeepSeek-V3，由深度求索公司创造。\n今天是2025年10月17日，星期五。"
+  },
+  {
+    "role": "latest_reminder",
+    "content": "2024-11-15,上海市,App,中文"
+  },
+  {
+    "role": "user",
+    "content": "热海大滚锅是世界著名温泉吗"
+  },
+  {
+    "role": "assistant",
+    "content": "热海大滚锅在中国乃至全球的地热奇观中占有重要地位，但“世界著名”的称号更侧重于它作为独特的地质现象和旅游景点。",
+    "mask": 1
+  },
+  {
+    "role": "user",
+    "content": "世界著名温泉有哪些",
+    "task": "action"
+  },
+  {
+    "role": "assistant",
+    "content": "Search"
+  }
+]

encoding/tests/test_input_5.json

@@ -0,0 +1,39 @@
+{
+    "thinking_mode": "thinking",
+    "reasoning_effort": "max",
+    "messages": [
+        {
+            "role": "system",
+            "content": "You are a helpful vision assistant."
+        },
+        {
+            "role": "user",
+            "content": [
+                {
+                    "type": "text",
+                    "text": "请按“第一张、第二张”的顺序回答：第一张图"
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "examples/images/carrots.jpeg"
+                    }
+                },
+                {
+                    "type": "text",
+                    "text": "和第二张图"
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": "examples/images/corn.jpeg"
+                    }
+                },
+                {
+                    "type": "text",
+                    "text": "中分别是什么食材？它们通常食用的部位分别是什么？"
+                }
+            ]
+        }
+    ]
+}

encoding/tests/test_output_1.txt

@@ -0,0 +1,38 @@
+<｜begin▁of▁sentence｜><｜System｜>Reasoning Effort: 75 (range 1-100, the higher the value, the more thorough the reasoning)
+
+You are a helpful assistant.
+
+## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<｜DSML｜ calls>" block like the following:
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="$TOOL_NAME">
+<｜DSML｜ parameter name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</｜DSML｜ parameter>
+...
+</｜DSML｜ invoke>
+<｜DSML｜ invoke name="$TOOL_NAME2">
+...
+</｜DSML｜ invoke>
+</｜DSML｜ calls>
+
+String parameters should be specified as is and set `string="true"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string="false"`.
+
+If thinking_mode is enabled (triggered by <think>), you MUST output your complete reasoning inside <think>...</think> BEFORE any tool calls or final response.
+
+Otherwise, output directly after </think> with tool calls or final response.
+
+### Available Tool Schemas
+
+{"name": "get_weather", "description": "Get the weather for a specific location", "parameters": {"type": "object", "properties": {"location": {"type": "string", "description": "The city name"}, "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "description": "Temperature unit"}}, "required": ["location"]}}
+{"name": "search", "description": "Search the web for information", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "Search query"}, "num_results": {"type": "integer", "description": "Number of results to return"}}, "required": ["query"]}}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.
+<｜User｜>What's the weather like in Beijing?<｜Assistant｜><think>The user wants the weather in Beijing. I should call get_weather.</think>
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="get_weather">
+<｜DSML｜ parameter name="location" string="true">Beijing</｜DSML｜ parameter>
+<｜DSML｜ parameter name="unit" string="true">celsius</｜DSML｜ parameter>
+</｜DSML｜ invoke>
+</｜DSML｜ calls><｜end▁of▁sentence｜><｜User｜><tool_result>{"temperature": 22, "condition": "sunny", "humidity": 45}</tool_result><｜Assistant｜><think>Got the weather data. Let me format a nice response.</think>The weather in Beijing is currently sunny with a temperature of 22°C and 45% humidity.<｜end▁of▁sentence｜>

encoding/tests/test_output_2.txt

@@ -0,0 +1 @@
+<｜begin▁of▁sentence｜><｜System｜>You are a helpful assistant.<｜User｜>Hello<｜Assistant｜></think>Hi there! How can I help you?<｜end▁of▁sentence｜><｜User｜>What is the capital of France?<｜Assistant｜></think>The capital of France is Paris.<｜end▁of▁sentence｜>

encoding/tests/test_output_3.txt

@@ -0,0 +1,35 @@
+<｜begin▁of▁sentence｜><｜System｜>该助手为DeepSeek，由深度求索公司创造。<｜latest_reminder｜>2026-02-21,星期六,广州,App,中文<｜System｜>CITATION FORMAT: 【{cursor_id}†L{start_line_id}(-L{end_line_id})?】
+
+## Tools
+
+You have access to a set of tools to help answer the user's question. You can invoke tools by writing a "<｜DSML｜ calls>" block like the following:
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="$TOOL_NAME">
+<｜DSML｜ parameter name="$PARAMETER_NAME" string="true|false">$PARAMETER_VALUE</｜DSML｜ parameter>
+...
+</｜DSML｜ invoke>
+<｜DSML｜ invoke name="$TOOL_NAME2">
+...
+</｜DSML｜ invoke>
+</｜DSML｜ calls>
+
+String parameters should be specified as is and set `string="true"`. For all other types (numbers, booleans, arrays, objects), pass the value in JSON format and set `string="false"`.
+
+If thinking_mode is enabled (triggered by <think>), you MUST output your complete reasoning inside <think>...</think> BEFORE any tool calls or final response.
+
+Otherwise, output directly after </think> with tool calls or final response.
+
+### Available Tool Schemas
+
+{"name": "search", "description": "Web search. Split multiple queries with '||'.", "parameters": {"type": "object", "properties": {"queries": {"type": "string", "description": "query1||query2"}}, "required": ["queries"], "additionalProperties": false}}
+{"name": "open", "description": "Batch open IDs (format 【{id}†...】) or URLs.", "parameters": {"type": "object", "properties": {"open_list": {"type": "array", "items": {"type": "object", "properties": {"id": {"description": "ID or URL", "anyOf": [{"type": "integer"}, {"type": "string"}], "default": -1}, "loc": {"type": "integer", "description": "Start line", "default": -1}, "num_lines": {"type": "integer", "description": "", "default": -1}}, "additionalProperties": false}, "description": ""}}, "required": ["open_list"], "additionalProperties": false}}
+
+You MUST strictly follow the above defined tool name and parameter schemas to invoke tool calls.
+<｜User｜>小柴胡冲剂和布洛芬能一起吃吗？<｜Assistant｜></think>
+
+<｜DSML｜ calls>
+<｜DSML｜ invoke name="search">
+<｜DSML｜ parameter name="queries" string="true">小柴胡冲剂 布洛芬 相互作用 一起吃</｜DSML｜ parameter>
+</｜DSML｜ invoke>
+</｜DSML｜ calls><｜end▁of▁sentence｜><｜User｜><tool_result>[0]</tool_result><｜Assistant｜></think>请及时就医。<｜end▁of▁sentence｜>

encoding/tests/test_output_4.txt

@@ -0,0 +1,2 @@
+<｜begin▁of▁sentence｜><｜System｜>该助手为DeepSeek-V3，由深度求索公司创造。
+今天是2025年10月17日，星期五。<｜latest_reminder｜>2024-11-15,上海市,App,中文<｜User｜>热海大滚锅是世界著名温泉吗<｜Assistant｜></think>热海大滚锅在中国乃至全球的地热奇观中占有重要地位，但“世界著名”的称号更侧重于它作为独特的地质现象和旅游景点。<｜end▁of▁sentence｜><｜User｜>世界著名温泉有哪些<｜Assistant｜></think><｜action｜>Search<｜end▁of▁sentence｜>

encoding/tests/test_output_5.txt

@@ -0,0 +1,11 @@
+<｜begin▁of▁sentence｜><｜System｜>Reasoning Effort: 100 (range 1-100, the higher the value, the more thorough the reasoning)
+
+You are a helpful vision assistant.<｜User｜>请按“第一张、第二张”的顺序回答：第一张图
+
+<｜deepseek_image｜>
+
+和第二张图
+
+<｜deepseek_image｜>
+
+中分别是什么食材？它们通常食用的部位分别是什么？<｜Assistant｜><think>

exl3_k_map.json

@@ -0,0 +1,99 @@
+{
+  "codebook": "mul1",
+  "mul1_multiplier": 2212286765,
+  "mul1_marker_i32": -2082680531,
+  "routed": {
+    "0": 4,
+    "1": 4,
+    "2": 4,
+    "3": 4,
+    "4": 4,
+    "5": 4,
+    "6": 4,
+    "7": 4,
+    "8": 4,
+    "9": 4,
+    "10": 3,
+    "11": 3,
+    "12": 3,
+    "13": 3,
+    "14": 3,
+    "15": 3,
+    "16": 3,
+    "17": 3,
+    "18": 3,
+    "19": 3,
+    "20": 3,
+    "21": 3,
+    "22": 3,
+    "23": 3,
+    "24": 3,
+    "25": 3,
+    "26": 3,
+    "27": 3,
+    "28": 3,
+    "29": 3,
+    "30": 4,
+    "31": 4,
+    "32": 4,
+    "33": 4,
+    "34": 4,
+    "35": 4,
+    "36": 4,
+    "37": 4,
+    "38": 4,
+    "39": 4
+  },
+  "shared": {
+    "0": 6,
+    "1": 6,
+    "2": 6,
+    "3": 6,
+    "4": 6,
+    "5": 6,
+    "6": 6,
+    "7": 6,
+    "8": 6,
+    "9": 6,
+    "10": 6,
+    "11": 6,
+    "12": 6,
+    "13": 6,
+    "14": 6,
+    "15": 6,
+    "16": 6,
+    "17": 6,
+    "18": 6,
+    "19": 6,
+    "20": 6,
+    "21": 6,
+    "22": 6,
+    "23": 6,
+    "24": 6,
+    "25": 6,
+    "26": 6,
+    "27": 6,
+    "28": 6,
+    "29": 6,
+    "30": 6,
+    "31": 6,
+    "32": 6,
+    "33": 6,
+    "34": 6,
+    "35": 6,
+    "36": 6,
+    "37": 6,
+    "38": 6,
+    "39": 6
+  },
+  "shared_overrides": {},
+  "engram": {
+    "1": 6,
+    "14": 6
+  },
+  "mtp_bits": 6,
+  "head_bits": 6,
+  "attn_default": 6,
+  "indexer_wk_bits": 8,
+  "num_hidden_layers": 40
+}

model-00001-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba5ccb4d39882d08800e856150bce42b23584f3d9943520ae4cff5647d5a3045
+size 1323827293

model-00002-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:012504ba47677b9bb8727bb89cb8c6327a066ef10d2ade179f7ffd5c8151ff84
+size 7060206910

model-00003-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f9d5228106bd5c8064d672f5ae24cce6005be8c2cf33592ef0478655c9e9b80
+size 6942014187

model-00004-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8cae1bf802a2e10c59e1f3e057b58f183a0f64e6bf4a1c76107168a9cbb9d532
+size 6950309596

model-00005-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b583b45c6a5848dc33a7219d2c34149663779059b11b1bba5a9e76951b333af7
+size 6942014187

model-00006-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4d2e5290f5253262adb8b83b91f37406f24d0a1ce14c7c6844734aa2cbe064a
+size 6942014187

model-00007-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:65a639c07a74c59da458298adc99bca87036f8316f9c09ac409e2c9b68d414ba
+size 6942014187

model-00008-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:90f9448977e45f2db5859ca7c9d33ea34a6cdaffc4c28c0d8bb030938db4d614
+size 6942014187

model-00009-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:06cd3e7672a90c4edfb9ff98b77d11261e39a21558af314f2b235ea5b90b7518
+size 6942014187

model-00010-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:286c1c0597f29d154391d9f8252cabc560a89be68b50c1f227d0b078200336b2
+size 6950309596

model-00011-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b644d168923b319816185fc99b77478db7698067e5e8c67fae619f56a6b18405
+size 6942014187

model-00012-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8e278e5d6a44c81d6fe16c9231aa2cb3823cb8d26e55bdb491345f4e0797f28
+size 5243325245

model-00013-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39e25072f8f8de381b3176cb56eb0ec7caa8ab70e85956b57d7f9452291cd386
+size 5243325245

model-00014-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3e6e26fad54c7cbc90fbda7209a2f389ff73e58160fb60326bcaa5635e52d811
+size 5243325245

model-00015-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e34e397fb634b06a8558643d6b621a2b560b68c0766aac9c0252451ea3daffe2
+size 5361517974

model-00016-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:db9782ab6346e2dbcf259b79289e6dbc6b4fe183c4936bc1c1c892e2604fd6c7
+size 5251620673

model-00017-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:711c747176c8494d0cef290e98de5026658bd79a3ef51ed4d43ce403acbfa481
+size 5243325245

model-00018-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:111ce8d8496d6265098337f5b5ff79e71a31ba340eb2b682d0042dbca4dc954a
+size 5243325245

model-00019-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6feedcd839b5593b275761107593ad9f9a0244098dffed66ae6f88ead8844c0d
+size 5243325245

model-00020-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bf22fe666d473899b7d6f7bfa1709ad3cffe93f69d39a3da272eac854b39a882
+size 5243325245

model-00021-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:afef0df9f451e9392cbf4704c9f8ee9183695e543b669d811b6eca88c21a7fe2
+size 5243325245

model-00022-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:987c51d505f4b49442481ad8596256d846067e8c1fa8edb6c90bd6fc3f85d454
+size 5249642888

model-00023-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38cfb33a3a47483a1b1f7b3eebd22ffc9087437d45c8561062a72a8798fa48ef
+size 5243325245

model-00024-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aec09849c4916f7254129324bb6aa73eb3685448709534f66fbb31009e0edaf1
+size 5243325245

model-00025-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e0730da79761933690a243e2dd7dd8ecada43c95d9ec96fcc3a520b9f3194a2
+size 5243325245

model-00026-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9a15b99de6190d10099c62383e283c32ef42fdab8ec37ebf355448669eeb027
+size 5247596381

model-00027-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c673fa72f6aca977106267afb63f218f241f49a57eb833311ec8affe16009560
+size 5243325245

model-00028-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e54fe28e42bd8eec92fa07ac0e4be0850149b20b74e15d7af37d5314a9842deb
+size 5243325245

model-00029-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f69616591acdc45b7760db5ef9fab39dfb66558a908778aab230bd8c0d9faa3d
+size 5243325245

model-00030-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac4862535de5828c521e7e5e13906f993395940693cb66fbd323ce9360cd1917
+size 5247596381

model-00031-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0beae804fe362965413ba7d26c9c902cf44dd77824838239878332c95170dc7b
+size 5243325245

model-00032-of-00044.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48df9384d595f94b0093b9182b63b4c48216c3c1e486f7aa43a894e93521785d
+size 6942018869