Add MLX 8-bit conversion of Cloudflare/clef with joint schema head and clef_mlx.py loader

.gitattributes

@@ -33,3 +33,4 @@ 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
+tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Alibaba Cloud
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,108 @@
+---
+license: apache-2.0
+library_name: mlx
+base_model: Cloudflare/clef
+base_model_relation: quantized
+pipeline_tag: image-text-to-text
+tags:
+- mlx
+- clef
+- cloudflare
+- systemone
+- structured-output
+- classification
+- multimodal
+- custom-code
+---
+
+# mlx-community/clef-8bit
+
+[Cloudflare/clef](https://huggingface.co/Cloudflare/clef) converted to MLX (8-bit) for Apple Silicon.
+
+Clef turns a state (text, JSON, images, or video) plus a schema of typed questions into a
+probability for every allowed option, in a single forward pass. **It is not a chat model** —
+`mlx_vlm.generate`, `mlx_lm.generate`, and LM Studio will load the backbone but produce
+meaningless text. Use the bundled `clef_mlx.py` loader, which runs the backbone and the
+joint schema head.
+
+## Usage
+
+```bash
+pip install mlx-vlm huggingface_hub   # no torch needed
+```
+
+```python
+import sys
+from huggingface_hub import snapshot_download
+
+path = snapshot_download("mlx-community/clef-8bit")
+sys.path.insert(0, path)
+import clef_mlx
+
+model = clef_mlx.load(path)
+response = model.systemone({
+    "model": "clef",
+    "state": "Our checkout started returning errors and orders are blocked.",
+    "questions": {
+        "department": {
+            "type": "choice",
+            "instructions": "Which team should handle the message?",
+            "criteria": {"billing": "Payments or invoices", "technical": "Bugs or outages"},
+        },
+        "urgency": {"type": "score", "criteria": ["Can wait", "This week", "Today"]},
+        "outage": {"type": "noul", "instructions": "Is a service down?"},
+    },
+})
+print(response["answers"])
+```
+
+Images (PIL) and videos (frame arrays) go in `images` / `videos`, as in the original:
+
+```python
+from PIL import Image
+model.predict({
+    "state": {"task": "Review the attached receipt."},
+    "images": [Image.open("receipt.jpg")],
+    "questions": {"legible": {"type": "noul", "instructions": "Is the receipt total legible?"}},
+})
+```
+
+See the [original model card](https://huggingface.co/Cloudflare/clef) for the input format, question types, and benchmarks.
+
+## Conversion
+
+- Backbone: `mlx_vlm.convert -q --q-bits 8 --q-group-size 64` (vision tower kept in bf16).
+- Joint schema head: `joint_head.safetensors` copied unchanged (bf16) and run by `clef_mlx.py`.
+- `processor_config.json` is the original from Cloudflare/clef; prompt/token layout matches the reference
+  `joint_schema_model.py` exactly (images and video).
+
+## Parity vs. official PyTorch implementation (bf16)
+
+| Inputs | Top answer agrees | Max abs Δprob |
+|---|---|---|
+| Text (4 records, 10 questions) | 10/10 | 0.007 |
+| Images + video (5 records, 9 questions) | 9/9 | 0.032 |
+
+Measured on an M5 Max (128 GB). Small spot-check, not a full benchmark run.
+
+## Quality check: Decision Index (sampled)
+
+| | Decision Index (sample) | Median latency |
+|---|---|---|
+| **This model (8-bit)** | **57.96** | 1.13 s |
+| MLX 4-bit ([mlx-community/clef-4bit](https://huggingface.co/mlx-community/clef-4bit)), same rows | 57.02 (98.1% same top answer) | 1.03 s |
+| Cloudflare published (full suite) | 61.21 | |
+
+8-bit tracks the PyTorch reference within 0.007 probability on spot checks. The gap to the published score is
+mostly sample noise and harness differences (Arts & Human Taste in particular), not quantization.
+
+Method: [Decision Index](https://github.com/apolinario/decision-index) 0.2.1 kit (suite rebuilt byte-identical), stratified
+2,000-request sample across all 44 benchmarks (`suite sample --n 2000`), engine = `clef_mlx.py` with
+`max_length=16384` and **no truncation** (over-length requests are refused and count as wrong; 15 of 2,000,
+mostly BRIGHT). The index is computed from each benchmark's native metric on the sampled rows with the kit's
+chance correction and weights; HLE and iSarcasmEval are set to 0 to match how Cloudflare's published run is
+scored. With ~40 rows per benchmark, per-benchmark numbers are noisy (±10+ pts) — only the index is meaningful.
+
+## License
+
+Apache-2.0, following [Cloudflare/clef](https://huggingface.co/Cloudflare/clef).

chat_template.jinja

@@ -0,0 +1,170 @@
+{%- set image_count = namespace(value=0) %}
+{%- set video_count = namespace(value=0) %}
+{%- macro render_content(content, do_vision_count, is_system_content=false) %}
+    {%- if content is string %}
+        {{- content }}
+    {%- elif content is iterable and content is not mapping %}
+        {%- for item in content %}
+            {%- if 'image' in item or 'image_url' in item or item.type == 'image' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain images.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set image_count.value = image_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Picture ' ~ image_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|image_pad|><|vision_end|>' }}
+            {%- elif 'video' in item or item.type == 'video' %}
+                {%- if is_system_content %}
+                    {{- raise_exception('System message cannot contain videos.') }}
+                {%- endif %}
+                {%- if do_vision_count %}
+                    {%- set video_count.value = video_count.value + 1 %}
+                {%- endif %}
+                {%- if add_vision_id %}
+                    {{- 'Video ' ~ video_count.value ~ ': ' }}
+                {%- endif %}
+                {{- '<|vision_start|><|video_pad|><|vision_end|>' }}
+            {%- elif 'text' in item %}
+                {{- item.text }}
+            {%- else %}
+                {{- raise_exception('Unexpected item type in content.') }}
+            {%- endif %}
+        {%- endfor %}
+    {%- elif content is none or content is undefined %}
+        {{- '' }}
+    {%- else %}
+        {{- raise_exception('Unexpected content type.') }}
+    {%- endif %}
+{%- endmacro %}
+{%- if not messages %}
+    {{- raise_exception('No messages provided.') }}
+{%- endif %}
+{%- set reasoning_instructions = '' %}
+{%- if enable_thinking is undefined or enable_thinking is true %}
+    {%- set resolved_reasoning_effort = reasoning_effort|default('xhigh') %}
+    {%- if resolved_reasoning_effort not in ('xhigh', 'medium', 'low') %}
+        {{- raise_exception('Unexpected reasoning effort ' ~ reasoning_effort ~ '. Supported types are xhigh (default), medium, and low.') }}
+    {%- endif %}
+    {%- if resolved_reasoning_effort == 'xhigh' %}
+        {%- set reasoning_instructions = 'Reasoning effort is set to xhigh. Please think carefully through the task, validate key assumptions, consider plausible alternatives, and prioritize correctness, consistency, and clarity in the final answer.' %}
+    {%- elif resolved_reasoning_effort == 'low' %}
+        {%- set reasoning_instructions = 'Reasoning effort is set to low. Keep your thinking brief and focused, moving directly to the conclusion without unnecessary elaboration.' %}
+    {%- endif %}
+{%- endif %}
+{%- if tools and tools is iterable and tools is not mapping %}
+    {{- '<|im_start|>system\n' }}
+    {%- if reasoning_instructions %}
+        {{- reasoning_instructions + '\n\n' }}
+    {%- endif %}
+    {{- "# Tools\n\nYou have access to the following functions:\n\n<tools>" }}
+    {%- for tool in tools %}
+        {{- "\n" }}
+        {{- tool | tojson }}
+    {%- endfor %}
+    {{- "\n</tools>" }}
+    {{- '\n\nIf you choose to call a function ONLY reply in the following format with NO suffix:\n\n<tool_call>\n<function=example_function_name>\n<parameter=example_parameter_1>\nvalue_1\n</parameter>\n<parameter=example_parameter_2>\nThis is the value for the second parameter\nthat can span\nmultiple lines\n</parameter>\n</function>\n</tool_call>\n\n<IMPORTANT>\nReminder:\n- Function calls MUST follow the specified format: an inner <function=...></function> block must be nested within <tool_call></tool_call> XML tags\n- Required parameters MUST be specified\n- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after\n- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls\n</IMPORTANT>' }}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '\n\n' + content }}
+        {%- endif %}
+    {%- endif %}
+    {{- '<|im_end|>\n' }}
+{%- else %}
+    {%- if messages[0].role == 'system' %}
+        {%- set content = render_content(messages[0].content, false, true)|trim %}
+        {%- if content %}
+            {{- '<|im_start|>system\n' + (reasoning_instructions + '\n\n' if reasoning_instructions else '')  + content + '<|im_end|>\n' }}
+        {%- elif reasoning_instructions %}
+            {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
+        {%- endif %}
+    {%- elif reasoning_instructions %}
+        {{- '<|im_start|>system\n' + reasoning_instructions + '<|im_end|>\n' }}
+    {%- endif %}
+{%- endif %}
+{%- set ns = namespace(multi_step_tool=true, last_query_index=messages|length - 1) %}
+{%- for message in messages[::-1] %}
+    {%- set index = (messages|length - 1) - loop.index0 %}
+    {%- if ns.multi_step_tool and message.role == "user" %}
+        {%- set content = render_content(message.content, false)|trim %}
+        {%- if not(content.startswith('<tool_response>') and content.endswith('</tool_response>')) %}
+            {%- set ns.multi_step_tool = false %}
+            {%- set ns.last_query_index = index %}
+        {%- endif %}
+    {%- endif %}
+{%- endfor %}
+{%- if ns.multi_step_tool %}
+    {{- raise_exception('No user query found in messages.') }}
+{%- endif %}
+{%- for message in messages %}
+    {%- set content = render_content(message.content, true)|trim %}
+    {%- if message.role == "system" %}
+        {%- if not loop.first %}
+            {{- raise_exception('System message must be at the beginning.') }}
+        {%- endif %}
+    {%- elif message.role == "user" %}
+        {{- '<|im_start|>' + message.role + '\n' + content + '<|im_end|>' + '\n' }}
+    {%- elif message.role == "assistant" %}
+        {%- set reasoning_content = '' %}
+        {%- if message.reasoning_content is string %}
+            {%- set reasoning_content = message.reasoning_content %}
+        {%- endif %}
+        {%- set reasoning_content = reasoning_content|trim %}
+        {%- if preserve_thinking is undefined or preserve_thinking is true or loop.index0 > ns.last_query_index %}
+            {{- '<|im_start|>' + message.role + '\n<think>\n' + reasoning_content + '\n</think>\n\n' + content }}
+        {%- else %}
+            {{- '<|im_start|>' + message.role + '\n' + content }}
+        {%- endif %}
+        {%- if message.tool_calls and message.tool_calls is iterable and message.tool_calls is not mapping %}
+            {%- for tool_call in message.tool_calls %}
+                {%- if tool_call.function is defined %}
+                    {%- set tool_call = tool_call.function %}
+                {%- endif %}
+                {%- if loop.first %}
+                    {%- if content|trim %}
+                        {{- '\n\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- else %}
+                        {{- '<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                    {%- endif %}
+                {%- else %}
+                    {{- '\n<tool_call>\n<function=' + tool_call.name + '>\n' }}
+                {%- endif %}
+                {%- if tool_call.arguments is defined and tool_call.arguments != '' %}
+                    {%- for args_name, args_value in tool_call.arguments|items %}
+                        {{- '<parameter=' + args_name + '>\n' }}
+                        {%- set args_value = args_value | string if args_value is string else args_value | tojson | safe %}
+                        {{- args_value }}
+                        {{- '\n</parameter>\n' }}
+                    {%- endfor %}
+                {%- endif %}
+                {{- '</function>\n</tool_call>' }}
+            {%- endfor %}
+        {%- endif %}
+        {{- '<|im_end|>\n' }}
+    {%- elif message.role == "tool" %}
+        {%- if loop.previtem and loop.previtem.role != "tool" %}
+            {{- '<|im_start|>user' }}
+        {%- endif %}
+        {{- '\n<tool_response>\n' }}
+        {{- content }}
+        {{- '\n</tool_response>' }}
+        {%- if not loop.last and loop.nextitem.role != "tool" %}
+            {{- '<|im_end|>\n' }}
+        {%- elif loop.last %}
+            {{- '<|im_end|>\n' }}
+        {%- endif %}
+    {%- else %}
+        {{- raise_exception('Unexpected message role.') }}
+    {%- endif %}
+{%- endfor %}
+{%- if add_generation_prompt %}
+    {{- '<|im_start|>assistant\n' }}
+    {%- if enable_thinking is defined and enable_thinking is false %}
+        {{- '<think>\n\n</think>\n\n' }}
+    {%- else %}
+        {{- '<think>\n' }}
+    {%- endif %}
+{%- endif %}

clef_mlx.py

@@ -0,0 +1,551 @@
+"""MLX port of Cloudflare Clef / Clef-Flash (Qwen3.5 backbone + joint schema head).
+
+Torch-free. The backbone is loaded with mlx-vlm (text + images/video) or mlx-lm
+(text only), bf16 or quantized. The joint head is loaded from the original
+``joint_head.safetensors`` / ``joint_head_config.json`` with no conversion.
+
+    import clef_mlx
+    model = clef_mlx.load("mlx-community/clef-flash-4bit")
+    model.predict(record)        # {question_id: {option_id: probability}}
+    model.systemone(request)     # Jev/SystemOne /v1/systemone response body
+"""
+
+from __future__ import annotations
+
+import json
+import math
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import mlx.core as mx
+import mlx.nn as nn
+
+SYSTEM_PROMPT = (
+    "Read the complete state and schema. Decide every field jointly. Each answer "
+    "must be exactly one of that field's allowed options."
+)
+QUESTION_TYPES = {"noul": 0, "choice": 1, "score": 2}
+
+
+class ContextTooLong(ValueError):
+    pass
+
+
+# --------------------------------------------------------------------------- encoding
+# Mirrors joint_schema_model.encode_record (text-only path) exactly.
+
+
+def render(value: Any) -> str:
+    if isinstance(value, str):
+        return value
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), sort_keys=True)
+
+
+def question_options(question: dict[str, Any]) -> list[tuple[str, Any]]:
+    question_type = str(question["type"])
+    if question_type == "noul":
+        criteria = {
+            "true": "The proposition is true or the answer is yes.",
+            "false": "The proposition is false or the answer is no.",
+        }
+        criteria.update(question.get("criteria") or {})
+        return [(key, criteria[key]) for key in ("true", "false")]
+    if question_type == "choice":
+        return sorted((str(key), value) for key, value in question["criteria"].items())
+    return [(str(index), value) for index, value in enumerate(question["criteria"])]
+
+
+@dataclass(frozen=True)
+class EncodedQuestion:
+    question_id: str
+    question_type: int
+    question_span: tuple[int, int]
+    option_spans: tuple[tuple[int, int], ...]
+    option_ids: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class EncodedRecord:
+    input_ids: tuple[int, ...]
+    questions: tuple[EncodedQuestion, ...]
+    media: dict[str, Any] | None = field(default=None, compare=False, repr=False)
+
+
+def _tokens(tokenizer: Any, text: str) -> list[int]:
+    return tokenizer(text, add_special_tokens=False).input_ids
+
+
+def sample_frames(video, fps=2.0, source_fps=24.0, min_frames=4, max_frames=768):
+    """Uniform frame sampling matching transformers' Qwen3VLVideoProcessor.
+
+    Frame arrays carry no metadata, so (like transformers) assume a 24 fps source.
+    Returns (frames, source frame indices).
+    """
+    import numpy as np
+
+    video = np.asarray(video)
+    total = len(video)
+    n = int(total / source_fps * fps)
+    n = min(max(n, min_frames), max_frames, total)
+    indices = np.linspace(0, total - 1, n).round().astype(int)
+    return video[indices], indices.tolist()
+
+
+def _timestamps(indices: list[int], source_fps: float, temporal_patch: int) -> list[float]:
+    indices = list(indices)
+    if len(indices) % temporal_patch:
+        indices.extend(indices[-1] for _ in range(temporal_patch - len(indices) % temporal_patch))
+    seconds = [i / source_fps for i in indices]
+    return [(seconds[i] + seconds[i + temporal_patch - 1]) / 2 for i in range(0, len(seconds), temporal_patch)]
+
+
+def _encode_media(processor: Any, record: dict[str, Any]) -> tuple[list[int], dict[str, Any] | None]:
+    """Pixel preprocessing via the (torch-free) mlx-vlm processor; the token layout is
+    built here to match the transformers Qwen3-VL processor the model was trained with."""
+    import numpy as np
+
+    images = list(record.get("images") or [])
+    videos = list(record.get("videos") or [])
+    if not images and not videos:
+        return [], None
+    if processor is None:
+        raise ValueError("records with images or videos require a processor")
+    kwargs = dict(record.get("media_kwargs") or {})
+    sample = {k: kwargs.pop(k) for k in ("fps", "source_fps", "min_frames", "max_frames") if k in kwargs}
+    source_fps = sample.get("source_fps", 24.0)
+    do_sample = kwargs.pop("do_sample_frames", True)
+
+    media: dict[str, Any] = {}
+    text = ""
+    if images:
+        out = processor.image_processor(images=images, **kwargs)
+        media["pixel_values"] = mx.array(np.asarray(out["pixel_values"]))
+        grids = np.asarray(out["image_grid_thw"])
+        media["image_grid_thw"] = mx.array(grids)
+        merge = processor.image_processor.merge_size**2
+        for grid in grids:
+            text += "<|vision_start|>" + "<|image_pad|>" * (int(np.prod(grid)) // merge) + "<|vision_end|>"
+    if videos:
+        vp = processor.video_processor
+        frames, frame_indices = [], []
+        for v in videos:
+            f, idx = sample_frames(v, **sample) if do_sample else (np.asarray(v), list(range(len(v))))
+            frames.append(f)
+            frame_indices.append(idx)
+        out = vp(videos=frames, **kwargs)
+        media["pixel_values_videos"] = mx.array(np.asarray(out["pixel_values_videos"]))
+        grids = np.asarray(out["video_grid_thw"])
+        media["video_grid_thw"] = mx.array(grids)
+        for grid, idx in zip(grids, frame_indices):
+            per_frame = int(grid[1] * grid[2]) // vp.merge_size**2
+            stamps = _timestamps(idx, source_fps, vp.temporal_patch_size)
+            text += "<|vision_start|>"
+            for t in range(int(grid[0])):
+                text += f"<{stamps[t]:.1f} seconds><|vision_start|>" + "<|video_pad|>" * per_frame + "<|vision_end|>"
+            text += "<|vision_end|>"
+    text += "\n"
+    return _tokens(processor.tokenizer, text), media
+
+
+def encode_record(
+    tokenizer: Any,
+    record: dict[str, Any],
+    max_length: int = 16384,
+    max_state_tokens: int | None = None,
+    processor: Any | None = None,
+    truncate: bool = True,
+) -> EncodedRecord:
+    """Encode a record. Like the reference, the state is truncated to fit ``max_length``
+    unless ``truncate=False``, in which case ``ContextTooLong`` is raised instead."""
+    schema_ids = _tokens(tokenizer, "\n\nSCHEMA FIELDS:\n")
+    questions: list[EncodedQuestion] = []
+    for qi, (question_id, question) in enumerate(record["questions"].items()):
+        schema_ids.extend(
+            _tokens(
+                tokenizer,
+                f"\nFIELD {qi + 1}\nID: {question_id}\nTYPE: {question['type']}\nINSTRUCTION: ",
+            )
+        )
+        q_start = len(schema_ids)
+        instructions = question.get("instructions") or str(question_id)
+        schema_ids.extend(_tokens(tokenizer, render(instructions)))
+        q_end = len(schema_ids)
+        schema_ids.extend(_tokens(tokenizer, "\nALLOWED OPTIONS:\n"))
+        option_spans, option_ids = [], []
+        for oi, (option_id, description) in enumerate(question_options(question)):
+            schema_ids.extend(_tokens(tokenizer, f"OPTION {oi + 1}: "))
+            o_start = len(schema_ids)
+            semantics = {"option_id": option_id}
+            if description is not None:
+                semantics["description"] = description
+            schema_ids.extend(_tokens(tokenizer, render(semantics)))
+            option_spans.append((o_start, len(schema_ids)))
+            option_ids.append(option_id)
+            schema_ids.extend(_tokens(tokenizer, "\n"))
+        schema_ids.extend(_tokens(tokenizer, "END FIELD\n"))
+        questions.append(
+            EncodedQuestion(
+                str(question_id),
+                QUESTION_TYPES[str(question["type"])],
+                (q_start, q_end),
+                tuple(option_spans),
+                tuple(option_ids),
+            )
+        )
+
+    prefix_ids = _tokens(
+        tokenizer, f"<|im_start|>system\n{SYSTEM_PROMPT}<|im_end|>\n<|im_start|>user\nSTATE:\n"
+    )
+    suffix_ids = _tokens(
+        tokenizer,
+        "\n<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\nJOINT SCHEMA DECISIONS:",
+    )
+    media_ids, media = _encode_media(processor, record)
+    prefix_ids = prefix_ids + media_ids
+    state_ids = _tokens(tokenizer, render(record["state"]))
+    if max_state_tokens is not None:
+        state_ids = state_ids[:max_state_tokens]
+    fixed = len(prefix_ids) + len(schema_ids) + len(suffix_ids)
+    if fixed > max_length:
+        raise ContextTooLong(f"schema requires {fixed} tokens before state; maximum is {max_length}")
+    if not truncate and fixed + len(state_ids) > max_length:
+        raise ContextTooLong(f"request needs {fixed + len(state_ids)} tokens; maximum is {max_length}")
+    state_ids = state_ids[: max_length - fixed]
+    off = len(prefix_ids) + len(state_ids)
+    shifted = tuple(
+        EncodedQuestion(
+            q.question_id,
+            q.question_type,
+            (q.question_span[0] + off, q.question_span[1] + off),
+            tuple((s + off, e + off) for s, e in q.option_spans),
+            q.option_ids,
+        )
+        for q in questions
+    )
+    return EncodedRecord(tuple(prefix_ids + state_ids + schema_ids + suffix_ids), shifted, media)
+
+
+# --------------------------------------------------------------------------- head
+
+
+class MultiheadAttention(nn.Module):
+    """torch.nn.MultiheadAttention (batch_first, packed in_proj) in MLX."""
+
+    def __init__(self, width: int, heads: int):
+        super().__init__()
+        self.heads = heads
+        self.in_proj_weight = mx.zeros((3 * width, width))
+        self.in_proj_bias = mx.zeros((3 * width,))
+        self.out_proj = nn.Linear(width, width)
+
+    def __call__(self, q: mx.array, k: mx.array, v: mx.array) -> mx.array:
+        w = self.in_proj_weight
+        b = self.in_proj_bias
+        d = w.shape[1]
+        q = q @ w[:d].T + b[:d]
+        k = k @ w[d : 2 * d].T + b[d : 2 * d]
+        v = v @ w[2 * d :].T + b[2 * d :]
+        B, Lq, _ = q.shape
+        Lk = k.shape[1]
+        hd = d // self.heads
+        q = q.reshape(B, Lq, self.heads, hd).transpose(0, 2, 1, 3)
+        k = k.reshape(B, Lk, self.heads, hd).transpose(0, 2, 1, 3)
+        v = v.reshape(B, Lk, self.heads, hd).transpose(0, 2, 1, 3)
+        o = mx.fast.scaled_dot_product_attention(q, k, v, scale=hd**-0.5)
+        return self.out_proj(o.transpose(0, 2, 1, 3).reshape(B, Lq, d))
+
+
+class FeedForward(nn.Module):
+    def __init__(self, width: int, feedforward: int):
+        super().__init__()
+        self.fc1 = nn.Linear(width, feedforward)
+        self.fc2 = nn.Linear(feedforward, width)
+
+    def __call__(self, x):
+        return self.fc2(nn.gelu(self.fc1(x)))
+
+
+class EvidenceRoutingLayer(nn.Module):
+    def __init__(self, width: int, heads: int, feedforward: int):
+        super().__init__()
+        self.query_norm = nn.LayerNorm(width)
+        self.memory_norm = nn.LayerNorm(width)
+        self.attention = MultiheadAttention(width, heads)
+        self.feedforward_norm = nn.LayerNorm(width)
+        self.feedforward = FeedForward(width, feedforward)
+
+    def __call__(self, queries, memory):
+        m = self.memory_norm(memory)
+        queries = queries + self.attention(self.query_norm(queries), m, m)
+        return queries + self.feedforward(self.feedforward_norm(queries))
+
+
+class TransformerDecoderLayer(nn.Module):
+    """torch.nn.TransformerDecoderLayer(norm_first=True, activation='gelu')."""
+
+    def __init__(self, width: int, heads: int, feedforward: int):
+        super().__init__()
+        self.self_attn = MultiheadAttention(width, heads)
+        self.multihead_attn = MultiheadAttention(width, heads)
+        self.linear1 = nn.Linear(width, feedforward)
+        self.linear2 = nn.Linear(feedforward, width)
+        self.norm1 = nn.LayerNorm(width)
+        self.norm2 = nn.LayerNorm(width)
+        self.norm3 = nn.LayerNorm(width)
+
+    def __call__(self, x, memory):
+        h = self.norm1(x)
+        x = x + self.self_attn(h, h, h)
+        x = x + self.multihead_attn(self.norm2(x), memory, memory)
+        return x + self.linear2(nn.gelu(self.linear1(self.norm3(x))))
+
+
+def _l2norm(x, eps=1e-12):
+    return x / mx.maximum(mx.linalg.norm(x, axis=-1, keepdims=True), eps)
+
+
+class JointSchemaHead(nn.Module):
+    def __init__(self, hidden_size, width, routing_layers, layers, heads, feedforward):
+        super().__init__()
+        self.hidden_norm = nn.LayerNorm(hidden_size)
+        self.memory_projection = nn.Linear(hidden_size, width, bias=False)
+        self.question_projection = nn.Linear(hidden_size, width, bias=False)
+        self.option_question_projection = nn.Linear(hidden_size, width, bias=False)
+        self.global_projection = nn.Linear(hidden_size, width, bias=False)
+        self.option_context_projection = nn.Linear(hidden_size, width, bias=False)
+        self.option_lexical_projection = nn.Linear(hidden_size, width, bias=False)
+        self.type_embedding = nn.Embedding(3, width)
+        self.evidence_layers = [
+            EvidenceRoutingLayer(width, heads, feedforward) for _ in range(routing_layers)
+        ]
+        self.option_summary_norm = nn.LayerNorm(width)
+        self.layers = [TransformerDecoderLayer(width, heads, feedforward) for _ in range(layers)]
+        self.field_norm = nn.LayerNorm(width)
+        self.option_norm = nn.LayerNorm(width)
+        self.scorer1 = nn.Linear(width * 4, width)
+        self.scorer2 = nn.Linear(width, 1)
+        self.prior_logit_scale = mx.zeros(())
+        self.joint_logit_scale = mx.zeros(())
+        self.residual_gate = mx.zeros(())
+
+    @staticmethod
+    def sanitize(weights: dict[str, mx.array]) -> dict[str, mx.array]:
+        out = {}
+        for k, v in weights.items():
+            k = k.replace(".feedforward.0.", ".feedforward.fc1.")
+            k = k.replace(".feedforward.3.", ".feedforward.fc2.")
+            k = k.replace("residual_scorer.0.", "scorer1.").replace("residual_scorer.3.", "scorer2.")
+            out[k] = v
+        return out
+
+    def __call__(self, hidden, input_ids, record: EncodedRecord, lexical_lookup):
+        """hidden: (L, H) final backbone states for one record. Returns list of (n_opts,)."""
+        h = self.hidden_norm(hidden)
+        memory = self.memory_projection(h)[None]
+        global_vector = h[-1]
+        qs = record.questions
+        question_vectors = mx.stack([h[s:e].mean(0) for s, e in (q.question_span for q in qs)])
+        type_ids = mx.array([q.question_type for q in qs])
+
+        option_contexts, lexical_options, counts = [], [], []
+        for q in qs:
+            option_contexts.append(mx.stack([h[s:e].mean(0) for s, e in q.option_spans]))
+            lexical_options.append(
+                mx.stack([lexical_lookup(input_ids[s:e]).mean(0) for s, e in q.option_spans])
+            )
+            counts.append(len(q.option_spans))
+
+        option_queries = [
+            self.option_context_projection(c)
+            + self.option_lexical_projection(lx)
+            + self.option_question_projection(question_vectors[i])[None]
+            for i, (c, lx) in enumerate(zip(option_contexts, lexical_options))
+        ]
+        routed = mx.concatenate(option_queries, axis=0)[None]
+        for layer in self.evidence_layers:
+            routed = layer(routed, memory)
+        routed = routed[0]
+        splits = [int(x) for x in mx.cumsum(mx.array(counts))[:-1].tolist()]
+        split_options = mx.split(routed, splits, axis=0) if splits else [routed]
+
+        base_fields = self.question_projection(question_vectors)
+        summaries = []
+        for field, options in zip(base_fields, split_options):
+            w = mx.softmax((options @ field) / math.sqrt(options.shape[-1]), axis=0)
+            summaries.append((w[:, None] * options).sum(0))
+        fields = (
+            base_fields
+            + self.option_summary_norm(mx.stack(summaries))
+            + self.global_projection(global_vector)[None]
+            + self.type_embedding(type_ids)
+        )[None]
+        for layer in self.layers:
+            fields = layer(fields, memory)
+        fields = self.field_norm(fields[0])
+
+        prior_scale = mx.exp(mx.minimum(self.prior_logit_scale, math.log(100.0)))
+        joint_scale = mx.exp(mx.minimum(self.joint_logit_scale, math.log(100.0)))
+        gate = mx.sigmoid(self.residual_gate)
+        logits = []
+        for i, (field, lexical, routed_opts) in enumerate(zip(fields, lexical_options, split_options)):
+            anchor = _l2norm(question_vectors[i] + global_vector)
+            prior = prior_scale * (_l2norm(lexical) @ anchor)
+            options = self.option_norm(routed_opts)
+            rf = mx.broadcast_to(field[None], options.shape)
+            cosine = (rf * options).sum(-1) / mx.maximum(
+                mx.linalg.norm(rf, axis=-1) * mx.linalg.norm(options, axis=-1), 1e-8
+            )
+            feats = mx.concatenate([rf, options, rf * options, mx.abs(rf - options)], axis=-1)
+            residual = self.scorer2(nn.gelu(self.scorer1(feats)))[:, 0]
+            logits.append(prior + gate * (joint_scale * cosine + residual))
+        return logits
+
+
+# --------------------------------------------------------------------------- model
+
+
+class ClefMLX:
+    def __init__(self, backbone, tokenizer, head: JointSchemaHead, processor=None):
+        self.backbone = backbone
+        if type(tokenizer).__name__ == "TokenizerWrapper":  # mlx-lm wrapper
+            tokenizer = tokenizer._tokenizer
+        self.tokenizer = tokenizer
+        self.processor = processor
+        self.head = head
+        self.vision = hasattr(backbone, "vision_tower")
+        lm = backbone.language_model
+        self._text_model = lm.model
+        self._out = lm.lm_head if hasattr(lm, "lm_head") else lm.model.embed_tokens
+
+    def _lexical(self, ids: mx.array) -> mx.array:
+        """Rows of the output-embedding matrix, dequantized if needed."""
+        m = self._out
+        if isinstance(m, (nn.QuantizedLinear, nn.QuantizedEmbedding)):
+            return mx.dequantize(
+                m.weight[ids], m.scales[ids], m.get("biases")[ids] if "biases" in m else None,
+                group_size=m.group_size, bits=m.bits, mode=getattr(m, "mode", "affine"),
+            )
+        return m.weight[ids]
+
+    def _hidden(self, ids: mx.array, media: dict[str, Any] | None) -> mx.array:
+        if not self.vision:
+            if media:
+                raise ValueError("this checkpoint has no vision tower; convert with mlx_vlm")
+            return self._text_model(ids[None])[0]
+        media = media or {}
+        if "pixel_values" in media and "pixel_values_videos" in media:
+            raise NotImplementedError("mixing images and videos in one record is not supported")
+        pixel_values = media.get("pixel_values", media.get("pixel_values_videos"))
+        feats = self.backbone.get_input_embeddings(
+            ids[None],
+            pixel_values=pixel_values,
+            image_grid_thw=media.get("image_grid_thw"),
+            video_grid_thw=media.get("video_grid_thw"),
+        )
+        return self._text_model(
+            ids[None], inputs_embeds=feats.inputs_embeds, position_ids=feats.position_ids
+        )[0]
+
+    def logits(self, record: dict[str, Any], **encode_kwargs) -> tuple[EncodedRecord, list[mx.array]]:
+        enc = encode_record(self.tokenizer, record, processor=self.processor, **encode_kwargs)
+        ids = mx.array(enc.input_ids)
+        hidden = self._hidden(ids, enc.media)
+        out = self.head(hidden, ids, enc, self._lexical)
+        mx.eval(out)
+        return enc, out
+
+    def predict(self, record: dict[str, Any], **kw) -> dict[str, dict[str, float]]:
+        enc, logits = self.logits(record, **kw)
+        return {
+            q.question_id: dict(zip(q.option_ids, mx.softmax(lg.astype(mx.float32)).tolist()))
+            for q, lg in zip(enc.questions, logits)
+        }
+
+    def systemone(self, request: dict[str, Any], max_length: int = 16384, truncate: bool = True) -> dict[str, Any]:
+        """Answer a Jev/SystemOne ``POST /v1/systemone`` request body (same response body)."""
+        questions = request.get("questions")
+        if not isinstance(request.get("model"), str) or "state" not in request:
+            raise ValueError("model and state are required")
+        if not isinstance(questions, dict) or not questions:
+            raise ValueError("at least one question is required")
+        for qid, q in questions.items():
+            if q.get("type") not in QUESTION_TYPES:
+                raise ValueError(f"{qid}: type must be noul, choice, or score")
+            if q["type"] != "noul" and not q.get("criteria"):
+                raise ValueError(f"{qid}: criteria must not be empty")
+        enc, logits = self.logits(request, max_length=max_length, truncate=truncate)
+        answers = {
+            q.question_id: systemone_answer(
+                questions[q.question_id],
+                dict(zip(q.option_ids, mx.softmax(lg.astype(mx.float32)).tolist())),
+            )
+            for q, lg in zip(enc.questions, logits)
+        }
+        return {
+            "model": request["model"],
+            "answers": answers,
+            "usage": {"input_tokens": len(enc.input_ids), "output_tokens": 0},
+        }
+
+
+def systemone_answer(question: dict[str, Any], probabilities: dict[str, float]) -> dict[str, Any]:
+    if question["type"] == "noul":
+        return {"type": "noul", "noul": round(probabilities["true"], 4)}
+    if question["type"] == "choice":
+        options = [str(o) for o in question["criteria"]]
+        choice = max(options, key=probabilities.__getitem__)
+        return {
+            "type": "choice",
+            "choice": choice,
+            "confidence": round(probabilities[choice], 4),
+            "probabilities": {o: round(probabilities[o], 4) for o in options},
+        }
+    levels = [str(i) for i in range(len(question["criteria"]))]
+    return {
+        "type": "score",
+        "score": round(sum(i * probabilities[lv] for i, lv in enumerate(levels)), 4),
+        "confidence": round(max(probabilities[lv] for lv in levels), 4),
+        "legend": dict(zip(levels, question["criteria"])),
+        "probabilities": {lv: round(probabilities[lv], 4) for lv in levels},
+    }
+
+
+def _has_vision_weights(path: Path) -> bool:
+    index = path / "model.safetensors.index.json"
+    if index.exists():
+        keys = json.loads(index.read_text())["weight_map"]
+    else:
+        keys = mx.load(str(next(path.glob("*.safetensors"))))
+    return any(k.startswith(("vision_tower", "model.visual")) for k in keys)
+
+
+def load(path: str | Path, head_dtype=mx.bfloat16, backend: str = "auto") -> ClefMLX:
+    """Load an MLX Clef checkpoint (local dir or HF repo id).
+
+    backend: "vlm" (mlx-vlm, text + images/video), "lm" (mlx-lm, text only), or "auto".
+    """
+    path = Path(path)
+    if not path.is_dir():
+        from huggingface_hub import snapshot_download
+
+        path = Path(snapshot_download(str(path)))
+    if backend == "auto":
+        backend = "vlm" if _has_vision_weights(path) else "lm"
+    processor = None
+    if backend == "vlm":
+        from mlx_vlm import load as vlm_load
+
+        backbone, processor = vlm_load(str(path))
+        tokenizer = processor.tokenizer
+    else:
+        from mlx_lm import load as lm_load
+
+        backbone, tokenizer = lm_load(str(path))
+    cfg = json.loads((path / "joint_head_config.json").read_text())
+    head = JointSchemaHead(**cfg)
+    weights = JointSchemaHead.sanitize(mx.load(str(path / "joint_head.safetensors")))
+    head.load_weights(list(weights.items()), strict=True)
+    head.set_dtype(head_dtype)
+    mx.eval(head.parameters())
+    return ClefMLX(backbone, tokenizer, head, processor)

config.json

@@ -0,0 +1,173 @@
+{
+    "architectures": [
+        "Qwen3_5ForConditionalGeneration"
+    ],
+    "do_sample": true,
+    "dtype": "bfloat16",
+    "eos_token_id": [
+        248046,
+        248044
+    ],
+    "generation_config": {
+        "bos_token_id": 248044,
+        "do_sample": true,
+        "eos_token_id": [
+            248046,
+            248044
+        ],
+        "pad_token_id": 248044,
+        "temperature": 1.0,
+        "top_k": 20,
+        "top_p": 0.95,
+        "transformers_version": "5.10.2"
+    },
+    "image_token_id": 248056,
+    "language_model_only": false,
+    "model_type": "qwen3_5",
+    "quantization": {
+        "group_size": 64,
+        "bits": 8,
+        "mode": "affine"
+    },
+    "quantization_config": {
+        "group_size": 64,
+        "bits": 8,
+        "mode": "affine"
+    },
+    "temperature": 1.0,
+    "text_config": {
+        "attention_bias": false,
+        "attention_dropout": 0.0,
+        "attn_output_gate": true,
+        "bos_token_id": 248044,
+        "dtype": "bfloat16",
+        "eos_token_id": 248044,
+        "full_attention_interval": 4,
+        "head_dim": 256,
+        "hidden_act": "silu",
+        "hidden_size": 5120,
+        "initializer_range": 0.02,
+        "intermediate_size": 17408,
+        "layer_types": [
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention",
+            "linear_attention",
+            "linear_attention",
+            "linear_attention",
+            "full_attention"
+        ],
+        "linear_conv_kernel_dim": 4,
+        "linear_key_head_dim": 128,
+        "linear_num_key_heads": 16,
+        "linear_num_value_heads": 48,
+        "linear_value_head_dim": 128,
+        "mamba_ssm_dtype": "float32",
+        "max_position_embeddings": 262144,
+        "model_type": "qwen3_5_text",
+        "mtp_num_hidden_layers": 0,
+        "mtp_use_dedicated_embeddings": false,
+        "num_attention_heads": 24,
+        "num_hidden_layers": 64,
+        "num_key_value_heads": 4,
+        "output_gate_type": "swish",
+        "pad_token_id": null,
+        "partial_rotary_factor": 0.25,
+        "rms_norm_eps": 1e-06,
+        "rope_parameters": {
+            "mrope_interleaved": true,
+            "mrope_section": [
+                11,
+                11,
+                10
+            ],
+            "partial_rotary_factor": 0.25,
+            "rope_theta": 10000000,
+            "rope_type": "default"
+        },
+        "tie_word_embeddings": false,
+        "use_cache": true,
+        "vocab_size": 248320
+    },
+    "tie_word_embeddings": false,
+    "top_k": 20,
+    "top_p": 0.95,
+    "transformers_version": "5.10.2",
+    "video_token_id": 248057,
+    "vision_config": {
+        "deepstack_visual_indexes": [],
+        "depth": 27,
+        "dtype": "bfloat16",
+        "hidden_act": "gelu_pytorch_tanh",
+        "hidden_size": 1152,
+        "in_channels": 3,
+        "initializer_range": 0.02,
+        "intermediate_size": 4304,
+        "model_type": "qwen3_5_vision",
+        "num_heads": 16,
+        "num_position_embeddings": 2304,
+        "out_hidden_size": 5120,
+        "patch_size": 16,
+        "spatial_merge_size": 2,
+        "temporal_patch_size": 2
+    },
+    "vision_end_token_id": 248054,
+    "vision_start_token_id": 248053
+}

generation_config.json

@@ -0,0 +1,13 @@
+{
+  "bos_token_id": 248044,
+  "do_sample": true,
+  "eos_token_id": [
+    248046,
+    248044
+  ],
+  "pad_token_id": 248044,
+  "temperature": 1.0,
+  "top_k": 20,
+  "top_p": 0.95,
+  "transformers_version": "5.10.2"
+}

joint_head.safetensors

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

joint_head_config.json

@@ -0,0 +1,8 @@
+{
+  "hidden_size": 5120,
+  "width": 1024,
+  "routing_layers": 2,
+  "layers": 4,
+  "heads": 16,
+  "feedforward": 4096
+}

model-00001-of-00006.safetensors

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

model-00002-of-00006.safetensors

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

model-00003-of-00006.safetensors

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

model-00004-of-00006.safetensors

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

model-00005-of-00006.safetensors

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

model-00006-of-00006.safetensors

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

processor_config.json

@@ -0,0 +1,60 @@
+{
+  "image_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_processor_type": "Qwen2VLImageProcessor",
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "merge_size": 2,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "size": {
+      "longest_edge": 16777216,
+      "shortest_edge": 65536
+    },
+    "temporal_patch_size": 2
+  },
+  "processor_class": "Qwen3VLProcessor",
+  "video_processor": {
+    "do_convert_rgb": true,
+    "do_normalize": true,
+    "do_rescale": true,
+    "do_resize": true,
+    "do_sample_frames": true,
+    "fps": 2,
+    "image_mean": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "image_std": [
+      0.5,
+      0.5,
+      0.5
+    ],
+    "max_frames": 768,
+    "merge_size": 2,
+    "min_frames": 4,
+    "patch_size": 16,
+    "resample": 3,
+    "rescale_factor": 0.00392156862745098,
+    "return_metadata": false,
+    "size": {
+      "longest_edge": 25165824,
+      "shortest_edge": 4096
+    },
+    "temporal_patch_size": 2,
+    "video_processor_type": "Qwen3VLVideoProcessor"
+  }
+}

tokenizer.json

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

tokenizer_config.json

@@ -0,0 +1,34 @@
+{
+  "add_prefix_space": false,
+  "audio_bos_token": "<|audio_start|>",
+  "audio_eos_token": "<|audio_end|>",
+  "audio_token": "<|audio_pad|>",
+  "backend": "tokenizers",
+  "bos_token": null,
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "<|im_end|>",
+  "errors": "replace",
+  "image_token": "<|image_pad|>",
+  "is_local": true,
+  "local_files_only": false,
+  "merges_file": null,
+  "model_max_length": 262144,
+  "model_specific_special_tokens": {
+    "audio_bos_token": "<|audio_start|>",
+    "audio_eos_token": "<|audio_end|>",
+    "audio_token": "<|audio_pad|>",
+    "image_token": "<|image_pad|>",
+    "video_token": "<|video_pad|>",
+    "vision_bos_token": "<|vision_start|>",
+    "vision_eos_token": "<|vision_end|>"
+  },
+  "pad_token": "<|endoftext|>",
+  "pretokenize_regex": "(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\\r\\n\\p{L}\\p{N}]?[\\p{L}\\p{M}]+|\\p{N}| ?[^\\s\\p{L}\\p{M}\\p{N}]+[\\r\\n]*|\\s*[\\r\\n]+|\\s+(?!\\S)|\\s+",
+  "processor_class": "Qwen3VLProcessor",
+  "split_special_tokens": false,
+  "tokenizer_class": "Qwen3_5Tokenizer",
+  "unk_token": null,
+  "video_token": "<|video_pad|>",
+  "vision_bos_token": "<|vision_start|>",
+  "vision_eos_token": "<|vision_end|>"
+}