Upload gguf.py

gguf.py

@@ -325,11 +325,23 @@ class GGUFReader:
         """Raw packed label channel bytes for ``name`` (undecoded KV value)."""
         for key, vtype, raw in self.kv_pairs:
             if key == SEG_KV_PREFIX + name:
-                if vtype != 8:
-                    raise ValueError(f"{name}: label channel KV has non-string type {vtype}")
-                if len(raw) < 8:
-                    raise ValueError(f"{name}: corrupt label channel KV")
-                return raw[8:]
+                if vtype == 8:
+                    # legacy: string value, u64 length prefix then raw bytes
+                    if len(raw) < 8:
+                        raise ValueError(f"{name}: corrupt label channel KV")
+                    return raw[8:]
+                if vtype == 9:
+                    # uint8 array: u32 element type + u64 count + data
+                    if len(raw) < 12:
+                        raise ValueError(f"{name}: corrupt label channel KV")
+                    if struct.unpack("<I", raw[:4])[0] != 0:
+                        raise ValueError(f"{name}: label channel array is not uint8")
+                    n = struct.unpack("<Q", raw[4:12])[0]
+                    if len(raw) < 12 + n:
+                        raise ValueError(f"{name}: truncated label channel array")
+                    return raw[12 : 12 + n]
+                raise ValueError(f"{name}: label channel KV has bad type {vtype}")
+        return None
         return None
 
     def seg_labels(self, name: str) -> tuple[np.ndarray, int] | None:
@@ -897,7 +909,10 @@ def write_quantized_gguf(
                 key = SEG_KV_PREFIX + ti.name
                 content_len = label_channel_bytes(ti.n_elements, seg_k)
                 seg_reserve[key] = content_len
-                kv_pairs.append((key, 8, struct.pack("<Q", content_len) + bytes(content_len)))
+                # GGUF uint8 array: u32 element type + u64 count + zeros
+                kv_pairs.append(
+                    (key, 9, struct.pack("<I", 0) + struct.pack("<Q", content_len) + bytes(content_len))
+                )
 
     output_path = Path(output_path)
     output_path.parent.mkdir(parents=True, exist_ok=True)
@@ -925,7 +940,7 @@ def write_quantized_gguf(
             if len(packed) != seg_reserve.get(key, -1):
                 raise RuntimeError(f"{key}: label channel size {len(packed)} != reserved")
             pos = fout.tell()
-            fout.seek(seg_patch_offsets[key] + 8)  # skip the u64 value length prefix
+            fout.seek(seg_patch_offsets[key] + 12)  # skip u32 array type + u64 count
             fout.write(packed)
             fout.seek(pos)
         for ti, out_type, out_size, offset in out_infos: