diff --git a/gpt_oss/metal/scripts/create-local-modelnew.py b/gpt_oss/metal/scripts/create-local-modelnew.py
new file mode 100644
index 0000000..170e3c4
--- /dev/null
+++ b/gpt_oss/metal/scripts/create-local-modelnew.py
@@ -0,0 +1,500 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+GPT‑OSS → Metal bin converter (safe, sharded‑aware)
+- Supports single or sharded safetensors (index.json)
+- Compatible with OpenHarmony‑MLX metal backend
+- Works with finetuned GPT‑OSS‑20B variants (Jinx naming fallback)
+- Safer MXFP4 scales write (int16 + clamp + bias)
+- Tokenizer header/UUID table aligned to Harmony GPT‑OSS encoding
+
+Usage:
+  python create-local-modelnew.py \
+    -s /path/to/ckpt_dir \
+    -d /path/to/output/model.bin
+"""
+
+import argparse
+import os
+import math
+import sys
+import json
+import struct
+from uuid import UUID
+import contextlib
+from contextlib import ExitStack
+
+import torch
+from safetensors import safe_open
+import tiktoken
+from tqdm import tqdm
+from openai_harmony import load_harmony_encoding, HarmonyEncodingName
+
+# ---------------- CLI ----------------
+parser = argparse.ArgumentParser(
+    prog="create-local-modelnew.py",
+    description="Convert GPT‑OSS MXFP4 weights to Metal .bin (safe)"
+)
+parser.add_argument("-s", "--src", metavar="DIR", type=str, required=True, help="Path to safetensors dir (single or sharded)")
+parser.add_argument("-d", "--dst", metavar="FILE", type=str, required=True, help="Path to output model.bin")
+
+# --------------- Encoding (match GPT‑OSS) ---------------
+o200k_base = tiktoken.get_encoding("o200k_base")
+harmony_encoding = load_harmony_encoding(HarmonyEncodingName.HARMONY_GPT_OSS)
+
+# Compose the GPT‑OSS view over o200k with the expected special IDs
+# NOTE: keep the official eot id as ""
+o200k_gptoss = tiktoken.Encoding(
+    name="o200k_gptoss",
+    pat_str=o200k_base._pat_str,
+    mergeable_ranks=o200k_base._mergeable_ranks,
+    special_tokens={
+        "<|reversed199998|>": 199998,
+        "": 199999,  # official eot id
+        "<|untrusted|>": 200000,
+        "<|endofuntrusted|>": 200001,  # official spelling
+        "<|return|>": 200002,
+        "<|constrain|>": 200003,
+        "<|reversed200004|>": 200004,
+        "<|channel|>": 200005,
+        "<|start|>": 200006,
+        "<|end|>": 200007,
+        "<|message|>": 200008,
+        "<|reversed200008|>": 200008,
+        "<|reversed200009|>": 200009,
+        "<|reversed200010|>": 200010,
+        "<|reversed200011|>": 200011,
+        "<|call|>": 200012,
+        "<|refusal|>": 200013,
+    },
+)
+
+# --------------- File / token constants ---------------
+FILE_MAGIC = struct.pack('ccccccccccccI', b'G', b'P', b'T', b'-', b'O', b'S', b'S', b' ', b'v', b'1', b'.', b'0', 0)
+
+SPECIAL_TOKEN_UUID = {
+    '<|start|>': UUID('55a77c2f-8a01-4c54-8ac2-313bfc7e208d').bytes,
+    '<|message|>': UUID('16e40431-f47f-4b22-b59b-8b278fc30a54').bytes,
+    '<|end|>': UUID('fcac2f6d-4705-4f6b-b228-642accac7238').bytes,
+    '<|return|>': UUID('f799ff69-1992-43c4-a3d8-d831f475dc75').bytes,
+    '<|refusal|>': UUID('e15ba702-28c4-4292-ab8f-ffa434709128').bytes,
+    '<|constrain|>': UUID('c0bb14c7-6022-49da-ad08-792d67e8b470').bytes,
+    '<|channel|>': UUID('fd3dda11-c8ab-4033-876e-d93deb172c93').bytes,
+    '<|call|>': UUID('1220f796-e388-4de5-b487-fe2eb5fe03c0').bytes,
+    '<|untrusted|>': UUID('07d7da55-b346-4cff-8b37-7cefacf8a3e8').bytes,
+    '<|endofuntrusted|>': UUID('f265bd9c-c717-469e-a447-920687d65d90').bytes,
+    # NOTE: EOT ("") has no UUID
+}
+INCLUDE_SPECIAL_TOKENS = [
+    "<|start|>", "<|message|>", "<|end|>", "<|return|>",
+    "<|refusal|>", "<|constrain|>", "<|channel|>", "<|call|>",
+    "<|untrusted|>", "<|endofuntrusted|>",
+]
+
+GPTOSS_MODEL_UUID = UUID('df52dc86-1789-4ed0-a295-66f10508145b').bytes
+APPLE_GPU_LAYOUT_UUID = UUID('229177a8-5775-4268-bfd8-588b351c56d'.replace('588','d588')).bytes  # formatting guard
+TIKTOKEN_TOKENIZER_UUID = UUID('7401aded-2a95-40cb-b782-9ccebaafe72b').bytes
+
+UE8_OFFSET = 14  # bias for MXFP4 block scales (UE8)
+
+# --------------- IO helpers ---------------
+
+def write_file_header(f):
+    f.write(FILE_MAGIC)
+
+def write_tokenizer_header(f, num_special_tokens:int, num_text_tokens:int, regex_size:int, tokens_size:int):
+    f.write(TIKTOKEN_TOKENIZER_UUID)
+    f.write(struct.pack('<I', num_special_tokens))
+    f.write(struct.pack('<I', num_text_tokens))
+    f.write(struct.pack('<I', regex_size))
+    f.write(struct.pack('<I', tokens_size))
+
+# model header layout: 6*U32, 1*F32, 4*U32, 6*F32 (total 17 fields)
+# Keep exactly in sync with the metal runtime reader.
+
+def write_model_header(f,
+    context_length:int, num_blocks:int, num_experts:int, num_active_experts:int,
+    embedding_dim:int, mlp_dim:int, swiglu_limit:float, head_dim:int, num_heads:int,
+    num_kv_heads:int, attention_window:int, rope_theta:float, interpolation_scale:float,
+    yarn_offset:float, yarn_scale:float, yarn_multiplier:float, rmsnorm_epsilon:float,
+):
+    f.write(GPTOSS_MODEL_UUID)
+    f.write(struct.pack('<I', context_length))
+    f.write(struct.pack('<I', num_blocks))
+    f.write(struct.pack('<I', num_experts))
+    f.write(struct.pack('<I', num_active_experts))
+    f.write(struct.pack('<I', embedding_dim))
+    f.write(struct.pack('<I', mlp_dim))
+    f.write(struct.pack('<f', swiglu_limit))
+    f.write(struct.pack('<I', head_dim))
+    f.write(struct.pack('<I', num_heads))
+    f.write(struct.pack('<I', num_kv_heads))
+    f.write(struct.pack('<I', attention_window))
+    f.write(struct.pack('<f', rope_theta))
+    f.write(struct.pack('<f', interpolation_scale))
+    f.write(struct.pack('<f', yarn_offset))
+    f.write(struct.pack('<f', yarn_scale))
+    f.write(struct.pack('<f', yarn_multiplier))
+    f.write(struct.pack('<f', rmsnorm_epsilon))
+    f.write(APPLE_GPU_LAYOUT_UUID)
+
+
+def write_padding(out_file, alignment_multiple=16384):
+    off = out_file.tell()
+    pad = (-off) % alignment_multiple
+    if pad:
+        out_file.write(bytes(pad))
+
+
+def write_bytes_from_tensor(out_file, t: torch.Tensor, align=16):
+    write_padding(out_file, align)
+    out_file.write(t.view(torch.uint8).numpy().tobytes())
+
+
+def write_embedding_weight(out_file, weight: torch.Tensor):
+    assert weight.dtype in (torch.float8_e4m3fn, torch.bfloat16)
+    write_bytes_from_tensor(out_file, weight, 16)
+
+
+def write_rmsnorm_gain(out_file, gain: torch.Tensor):
+    assert gain.dtype == torch.bfloat16
+    write_bytes_from_tensor(out_file, gain, 16)
+
+
+def write_attn_sink(out_file, sink: torch.Tensor):
+    assert sink.dtype == torch.bfloat16
+    write_bytes_from_tensor(out_file, sink, 16)
+
+
+def write_linear_weight(out_file, *args: torch.Tensor):
+    write_padding(out_file, 16)
+    for t in args:
+        out_file.write(t.view(torch.uint8).numpy().tobytes())
+
+
+def write_ue8_with_bias(out_file, scales: torch.Tensor, align=16, offset: int = UE8_OFFSET):
+    # Avoid uint8 wraparound by accumulating in int16 then clamping to [0,255]
+    s = scales.to(torch.int16).add_(int(offset)).clamp_(0, 255).to(torch.uint8)
+    write_padding(out_file, align)
+    out_file.write(s.numpy().tobytes())
+
+# ---- open single or sharded safetensors (index.json) ----
+@contextlib.contextmanager
+def open_st_reader(srcdir: str):
+    single = os.path.join(srcdir, "model.safetensors")
+    index  = os.path.join(srcdir, "model.safetensors.index.json")
+
+    if os.path.exists(single):
+        with safe_open(single, framework="pt", device="cpu") as f:
+            class R:
+                def get_tensor(self, k): return f.get_tensor(k)
+                def keys(self): return list(f.keys())
+            yield R(); return
+
+    if os.path.exists(index):
+        idx = json.load(open(index, "r"))
+        wm = idx["weight_map"]
+        with ExitStack() as stack:
+            cache = {}
+            def get_handle(relpath):
+                if relpath not in cache:
+                    cache[relpath] = stack.enter_context(
+                        safe_open(os.path.join(srcdir, relpath), framework="pt", device="cpu")
+                    )
+                return cache[relpath]
+            class R:
+                def get_tensor(self, k):
+                    fp = wm[k]
+                    return get_handle(fp).get_tensor(k)
+                def keys(self):
+                    return list(wm.keys())
+            yield R(); return
+
+    raise FileNotFoundError("Neither model.safetensors nor model.safetensors.index.json found")
+
+# --------------- main ---------------
+
+def pick(config, *keys, default=None):
+    for k in keys:
+        v = config
+        ok = True
+        for part in k.split('.'):
+            if isinstance(v, dict) and part in v:
+                v = v[part]
+            else:
+                ok = False; break
+        if ok: return v
+    if default is not None: return default
+    raise KeyError(f"Missing any of keys: {keys}")
+
+
+def get_tensor_first(src, cands):
+    last = None
+    for k in cands:
+        try:
+            return src.get_tensor(k), k
+        except KeyError as e:
+            last = e
+    sample = list(src.keys())[:20]
+    raise KeyError(f"none of {cands}; sample keys: {sample}") from last
+
+
+def get_attn_qkv(src, n, num_q_heads, num_kv_heads, head_dim):
+    # fused qkv
+    try:
+        w = src.get_tensor(f"block.{n}.attn.qkv.weight")
+        b = src.get_tensor(f"block.{n}.attn.qkv.bias")
+        return w, b, "qkv"
+    except KeyError:
+        # split projections
+        q_w,_ = get_tensor_first(src, [f"block.{n}.attn.q_proj.weight", f"model.layers.{n}.self_attn.q_proj.weight"])
+        k_w,_ = get_tensor_first(src, [f"block.{n}.attn.k_proj.weight", f"model.layers.{n}.self_attn.k_proj.weight"])
+        v_w,_ = get_tensor_first(src, [f"block.{n}.attn.v_proj.weight", f"model.layers.{n}.self_attn.v_proj.weight"])
+        w = torch.cat((q_w, k_w, v_w), dim=0).contiguous()
+        try:
+            q_b,_ = get_tensor_first(src, [f"block.{n}.attn.q_proj.bias", f"model.layers.{n}.self_attn.q_proj.bias"])
+            k_b,_ = get_tensor_first(src, [f"block.{n}.attn.k_proj.bias", f"model.layers.{n}.self_attn.k_proj.bias"])
+            v_b,_ = get_tensor_first(src, [f"block.{n}.attn.v_proj.bias", f"model.layers.{n}.self_attn.v_proj.bias"])
+            b = torch.cat((q_b, k_b, v_b), dim=0).contiguous()
+        except KeyError:
+            b = torch.zeros(w.shape[0], dtype=w.dtype)
+        return w, b, "qkv_split"
+
+
+def main(argv):
+    opt = parser.parse_args(argv)
+
+    config = json.load(open(os.path.join(opt.src, "config.json"), "r"))
+
+    # ---- hyperparams (with fallbacks for popular finetune configs) ----
+    num_blocks = int(pick(config, "num_hidden_layers"))
+    num_experts = int(pick(config, "num_experts", "num_local_experts"))
+    num_active_experts = int(pick(config, "num_active_experts", "experts_per_token", "num_experts_per_tok", default=4))
+    num_q_heads = int(pick(config, "num_attention_heads"))
+    num_kv_heads = int(pick(config, "num_key_value_heads"))
+    head_dim = int(pick(config, "head_dim"))
+    embedding_dim = int(pick(config, "hidden_size"))
+    mlp_dim = int(pick(config, "intermediate_size"))
+    swiglu_limit = float(config.get("swiglu_limit", 7.0))
+    rope_theta = float(pick(config, "rope_theta"))
+    attention_window = int(pick(config, "sliding_window"))
+    initial_context_length = int(pick(config, "initial_context_length"))
+    rope_scaling = config.get("rope_scaling")
+    if isinstance(rope_scaling, dict):
+        rope_scaling_factor = float(rope_scaling.get("factor", 1.0))
+        rope_ntk_alpha = float(rope_scaling.get("ntk_alpha", 1.0))
+        rope_ntk_beta  = float(rope_scaling.get("ntk_beta", 32.0))
+    else:
+        rope_scaling_factor = float(pick(config, "rope_scaling_factor", default=1.0))
+        rope_ntk_alpha = float(pick(config, "rope_ntk_alpha", default=1.0))
+        rope_ntk_beta  = float(pick(config, "rope_ntk_beta",  default=32.0))
+
+    # ---- tokenizer sizes ----
+    tokens_size = 0
+    num_text_tokens = 0
+    for t in range(o200k_gptoss.n_vocab):
+        if not harmony_encoding.is_special_token(t):
+            tb = o200k_gptoss.decode_single_token_bytes(t)
+            assert len(tb) > 0
+            tokens_size += len(tb) + 2  # uint16 length + data
+            num_text_tokens += 1
+    num_included_tokens = o200k_gptoss.n_vocab
+    print(f"[tokenizer] vocab={num_included_tokens} text={num_text_tokens} special={num_included_tokens - num_text_tokens}")
+
+    with open(opt.dst, "wb") as dst:
+        with open_st_reader(opt.src) as src:
+            write_file_header(dst)
+
+            # YARN params derived from NTK bounds
+            yarn_low  = (head_dim/2) * math.log(initial_context_length / (rope_ntk_beta * 2 * math.pi)) / math.log(rope_theta)
+            yarn_high = (head_dim/2) * math.log(initial_context_length / (rope_ntk_alpha * 2 * math.pi)) / math.log(rope_theta)
+
+            write_model_header(
+                dst,
+                context_length=int(initial_context_length * rope_scaling_factor),
+                num_blocks=num_blocks,
+                num_experts=num_experts,
+                num_active_experts=num_active_experts,
+                embedding_dim=embedding_dim,
+                mlp_dim=mlp_dim,
+                swiglu_limit=swiglu_limit,
+                head_dim=head_dim,
+                num_heads=num_q_heads,
+                num_kv_heads=num_kv_heads,
+                attention_window=attention_window,
+                rope_theta=rope_theta,
+                interpolation_scale=1.0/rope_scaling_factor,
+                yarn_offset=-yarn_low/(yarn_high-yarn_low),
+                yarn_scale=1.0/(yarn_high-yarn_low),
+                yarn_multiplier=0.1*math.log(rope_scaling_factor)+1.0,
+                rmsnorm_epsilon=1e-5,
+            )
+
+            write_tokenizer_header(
+                dst,
+                num_special_tokens=num_included_tokens - num_text_tokens,
+                num_text_tokens=num_text_tokens,
+                regex_size=len(o200k_gptoss._pat_str.encode("ascii")) + 1,
+                tokens_size=tokens_size,
+            )
+
+            # UUID table for special tokens [num_text .. vocab)
+            for token_idx in range(num_text_tokens, num_included_tokens):
+                token = o200k_gptoss.decode_single_token_bytes(token_idx).decode('ascii', errors='ignore')
+                if token in INCLUDE_SPECIAL_TOKENS:
+                    dst.write(SPECIAL_TOKEN_UUID[token])
+                else:
+                    dst.write(bytes(16))
+
+            # regex + NUL
+            dst.write(o200k_gptoss._pat_str.encode("ascii"))
+            dst.write(struct.pack('B', 0))
+
+            # text tokens
+            written = 0
+            for t in range(num_text_tokens):
+                tb = o200k_gptoss.decode_single_token_bytes(t)
+                dst.write(struct.pack('<H', len(tb)))
+                dst.write(tb)
+                written += len(tb) + 2
+            assert written == tokens_size
+            write_padding(dst)
+
+            # ---- embedding ----
+            emb, emb_key = get_tensor_first(src, [
+                "embedding.weight", "model.embed_tokens.weight", "embed_tokens.weight", "tok_embeddings.weight", "model.wte.weight"
+            ])
+            print(f"[ok] embedding: {emb_key} shape={tuple(emb.shape)}")
+            emb = emb[:min(emb.shape[0], num_included_tokens), :]
+            write_embedding_weight(dst, emb)
+
+            # ---- blocks ----
+            for n in tqdm(range(num_blocks), desc="blocks"):
+                attn_norm, key = get_tensor_first(src, [
+                    f"block.{n}.attn.norm.scale",
+                    f"model.layers.{n}.input_layernorm.weight",
+                ])
+                if n == 0: print(f"[ok] attn norm: {key}")
+                write_rmsnorm_gain(dst, attn_norm)
+
+                qkv_w, qkv_b, src_kind = get_attn_qkv(src, n, num_q_heads, num_kv_heads, head_dim)
+                if n == 0: print(f"[ok] attn qkv source: {src_kind}")
+
+                for qkv in (qkv_w, qkv_b):
+                    qk = qkv[:head_dim*(num_q_heads+num_kv_heads), ...].contiguous()
+                    v  = qkv[head_dim*(num_q_heads+num_kv_heads):, ...].contiguous()
+                    qk = qk.view(num_q_heads+num_kv_heads, 2, head_dim//2, -1).transpose(1,2).reshape(num_q_heads+num_kv_heads, head_dim, -1)
+                    q = qk[:num_q_heads, ...]
+                    k = qk[num_q_heads:, ...]
+                    assert head_dim == 64, "assumes head_dim==64 for baked scale"
+                    q *= 0.5; k *= 0.25
+                    v = v.view(num_kv_heads, head_dim, -1)
+                    qkv.copy_(torch.cat((q, k, v), dim=0).reshape(*qkv.shape))
+
+                write_linear_weight(dst, qkv_w, qkv_b)
+
+                sinks, sinks_key = get_tensor_first(src, [
+                    f"block.{n}.attn.sinks",
+                    f"model.layers.{n}.self_attn.sinks",
+                ])
+                if n == 0: print(f"[ok] attn sinks: {sinks_key}")
+                write_attn_sink(dst, sinks)
+
+                attn_out_w,_ = get_tensor_first(src, [
+                    f"block.{n}.attn.out.weight",
+                    f"model.layers.{n}.self_attn.o_proj.weight",
+                ])
+                try:
+                    attn_out_b,_ = get_tensor_first(src, [
+                        f"block.{n}.attn.out.bias",
+                        f"model.layers.{n}.self_attn.o_proj.bias",
+                    ])
+                except KeyError:
+                    attn_out_b = torch.zeros(attn_out_w.shape[0], dtype=attn_out_w.dtype)
+                write_linear_weight(dst, attn_out_w, attn_out_b)
+
+                mlp_norm,_ = get_tensor_first(src, [
+                    f"block.{n}.mlp.norm.scale",
+                    f"model.layers.{n}.post_attention_layernorm.weight",
+                ])
+                if n == 0: print(f"[ok] mlp norm")
+                write_rmsnorm_gain(dst, mlp_norm)
+
+                router_w,_ = get_tensor_first(src, [
+                    f"block.{n}.mlp.gate.weight",        # router logits
+                    f"model.layers.{n}.mlp.router.weight",
+                ])
+                try:
+                    router_b,_ = get_tensor_first(src, [
+                        f"block.{n}.mlp.gate.bias",
+                        f"model.layers.{n}.mlp.router.bias",
+                    ])
+                except KeyError:
+                    router_b = torch.zeros(router_w.shape[0], dtype=router_w.dtype)
+                write_linear_weight(dst, router_w, router_b)
+
+            final_norm,_ = get_tensor_first(src, ["norm.scale", "model.norm.weight"])
+            print(f"[ok] final norm")
+            write_rmsnorm_gain(dst, final_norm)
+
+            unemb, unemb_key = get_tensor_first(src, ["unembedding.weight", "lm_head.weight", "model.lm_head.weight"])
+            print(f"[ok] unembedding: {unemb_key} shape={tuple(unemb.shape)}")
+            unemb = unemb[:min(unemb.shape[0], num_included_tokens), :]
+            write_linear_weight(dst, unemb)
+
+            # ---- MoE (per-expert grouped); support native + Jinx naming ----
+            for n in tqdm(range(num_blocks), desc="experts"):
+                try:
+                    mlp1_blocks,_ = get_tensor_first(src, [f"block.{n}.mlp.mlp1_weight.blocks"])
+                    mlp1_scales,_ = get_tensor_first(src, [f"block.{n}.mlp.mlp1_weight.scales"])
+                    mlp1_bias,  _ = get_tensor_first(src, [f"block.{n}.mlp.mlp1_bias"])
+                    mlp2_blocks,_ = get_tensor_first(src, [f"block.{n}.mlp.mlp2_weight.blocks"])
+                    mlp2_scales,_ = get_tensor_first(src, [f"block.{n}.mlp.mlp2_weight.scales"])
+                    mlp2_bias,  _ = get_tensor_first(src, [f"block.{n}.mlp.mlp2_bias"])
+                except KeyError:
+                    # Jinx naming: fused gate+up becomes "mlp1"; down is "mlp2"
+                    gate_up_blk,_ = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.gate_up_proj_blocks"])
+                    gate_up_scl,_ = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.gate_up_proj_scales"])
+                    gate_up_bia,_ = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.gate_up_proj_bias"])
+
+                    down_blk,_    = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.down_proj_blocks"])
+                    down_scl,_    = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.down_proj_scales"])
+                    down_bia,_    = get_tensor_first(src, [f"model.layers.{n}.mlp.experts.down_proj_bias"])
+
+                    mlp1_blocks = gate_up_blk
+                    mlp1_scales = gate_up_scl
+                    mlp1_bias   = gate_up_bia
+
+                    mlp2_blocks = down_blk
+                    mlp2_scales = down_scl
+                    mlp2_bias   = down_bia
+
+                assert mlp1_blocks.shape[0] == mlp2_blocks.shape[0] == num_experts, \
+                    f"experts dim mismatch at block {n}: {mlp1_blocks.shape} vs {mlp2_blocks.shape}"
+
+                write_padding(dst)
+                for e in range(num_experts):
+                    write_bytes_from_tensor(dst, mlp1_blocks[e, ...], 16)
+                    write_ue8_with_bias(dst, mlp1_scales[e, ...], 16)
+                    write_bytes_from_tensor(dst, mlp1_bias[e, ...], 16)
+                    write_bytes_from_tensor(dst, mlp2_blocks[e, ...], 16)
+                    write_ue8_with_bias(dst, mlp2_scales[e, ...], 16)
+                    write_bytes_from_tensor(dst, mlp2_bias[e, ...], 16)
+
+    print(f"[done] Wrote {opt.dst}")
+
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
+
+"""
+python /Volumes/long990max/project/openharmony-mlx/gpt_oss/metal/scripts/create-local-modelnew.py \
+  -s /Volumes/long990max/gpustack_data/huihui-ai/Huihui-gpt-oss-20b-mxfp4-abliterated \
+  -d /Volumes/long990max/project/openharmony-mlx/model.bin
+
+python /Volumes/long990max/project/openharmony-mlx/gpt_oss/metal/scripts/create-local-modelnew.py \
+  -s /Volumes/long990max/gpustack_data/huizimao/gpt-oss-20b-uncensored-mxfp4 \         
+  -d /Volumes/long990max/project/openharmony-mlx/model.bin
+
+想要“拒绝更少”就选 huizimao/gpt-oss-20b-uncensored-mxfp4。
+"""
\ No newline at end of file