@camstack/addon-model-studio 1.0.1

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@camstack/addon-model-studio",
+  "version": "1.0.1",
+  "description": "Custom detection model registry, conversion & distribution for CamStack",
+  "keywords": [
+    "camstack",
+    "addon",
+    "camstack-addon",
+    "model",
+    "detection",
+    "registry"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/camstack/server"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "camstack": {
+    "displayName": "Model Studio",
+    "addons": [
+      {
+        "id": "model-studio",
+        "category": "system",
+        "name": "Model Studio",
+        "version": "1.0.0",
+        "description": "Register, manipulate and distribute custom detection models",
+        "entry": "./dist/index.js",
+        "execution": {
+          "placement": "any-node"
+        },
+        "capabilities": [
+          {
+            "name": "custom-model-registry"
+          },
+          {
+            "name": "model-convert"
+          }
+        ],
+        "python": {
+          "requirements": "./python/requirements.txt"
+        },
+        "color": "#8b5cf6"
+      }
+    ]
+  },
+  "files": [
+    "dist",
+    "python"
+  ],
+  "scripts": {
+    "build": "vite build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "publish": "npm publish --access public"
+  },
+  "peerDependencies": {
+    "@camstack/types": "*"
+  },
+  "devDependencies": {
+    "@camstack/types": "*",
+    "typescript": "~6.0.3",
+    "vite": "^8.0.11",
+    "vitest": "^3.0.0",
+    "zod": "^4.3.6"
+  }
+}

package/python/__tests__/test_convert_lib.py

@@ -0,0 +1,31 @@
+import os
+import tempfile
+import pytest
+
+ov = pytest.importorskip("openvino")  # skip where openvino is absent
+import numpy as np
+
+from convert_lib import export_openvino, validate_openvino_ir
+
+
+def _tiny_onnx(path: str) -> None:
+    # Build a 1-op ONNX (Relu) with NAMED input/output via onnx helpers.
+    import onnx
+    from onnx import helper, TensorProto
+    x = helper.make_tensor_value_info("input", TensorProto.FLOAT, [1, 3, 8, 8])
+    y = helper.make_tensor_value_info("output", TensorProto.FLOAT, [1, 3, 8, 8])
+    node = helper.make_node("Relu", ["input"], ["output"])
+    graph = helper.make_graph([node], "tiny", [x], [y])
+    model = helper.make_model(graph, opset_imports=[helper.make_opsetid("", 13)])
+    onnx.save(model, path)
+
+
+def test_export_and_validate_named_tensors():
+    with tempfile.TemporaryDirectory() as d:
+        onnx_path = os.path.join(d, "tiny.onnx")
+        xml_path = os.path.join(d, "tiny.xml")
+        _tiny_onnx(onnx_path)
+        export_openvino(onnx_path, xml_path, fp16=True)
+        assert os.path.exists(xml_path)
+        assert os.path.exists(xml_path.replace(".xml", ".bin"))
+        validate_openvino_ir(xml_path)  # must not raise — tensors are named

package/python/convert.py

@@ -0,0 +1,69 @@
+"""Runtime conversion subprocess. Invoked as: python convert.py <job.json>
+
+job.json: { onnxPath, outDir, modelId, imgsz, targets: [...], calibDir? }
+stdout: one JSON object per line — progress {"phase","pct","detail"} then a
+final {"result": {"artifacts": [...]}} line. Errors -> stderr, non-zero exit."""
+import json
+import sys
+from pathlib import Path
+
+import convert_lib as cl
+
+
+def emit(obj: dict) -> None:
+    sys.stdout.write(json.dumps(obj) + "\n")
+    sys.stdout.flush()
+
+
+def main() -> int:
+    job = json.loads(Path(sys.argv[1]).read_text())
+    onnx_path = job["onnxPath"]
+    out_dir = Path(job["outDir"])
+    model_id = job["modelId"]
+    imgsz = int(job["imgsz"])
+    artifacts = []
+
+    for target in job["targets"]:
+        fmt = target["format"]
+        if fmt == "openvino":
+            for precision in target["precisions"]:
+                emit({"phase": "convert", "pct": 0, "detail": f"openvino/{precision}"})
+                suffix = "" if precision == "fp16" else f"-{precision}"
+                xml = out_dir / f"camstack-{model_id}{suffix}.xml"
+                if precision == "fp16":
+                    cl.export_openvino(onnx_path, str(xml), fp16=True)
+                else:
+                    calib = job.get("calibDir")
+                    if not calib:
+                        emit({"phase": "skip", "detail": "int8: no calibration set"})
+                        continue
+                    cl.quantize_openvino_int8(onnx_path, str(xml), calib, imgsz)
+                emit({"phase": "validate", "detail": f"openvino/{precision}"})
+                cl.validate_openvino_ir(str(xml))
+                bin_path = xml.with_suffix(".bin")
+                size_mb = (xml.stat().st_size + bin_path.stat().st_size) / 1e6
+                artifacts.append({
+                    "format": "openvino", "precision": precision, "sizeMB": round(size_mb, 2),
+                    "validated": True, "files": [xml.name, bin_path.name],
+                })
+        elif fmt == "coreml":
+            emit({"phase": "convert", "pct": 0, "detail": "coreml"})
+            pkg = out_dir / f"camstack-{model_id}.mlpackage"
+            cl.export_coreml_from_onnx(onnx_path, str(pkg), imgsz)
+            cl.validate_coreml(str(pkg))
+            size_mb = sum(f.stat().st_size for f in pkg.rglob("*") if f.is_file()) / 1e6
+            artifacts.append({
+                "format": "coreml", "sizeMB": round(size_mb, 2),
+                "validated": True, "files": [pkg.name],
+            })
+
+    emit({"result": {"artifacts": artifacts}})
+    return 0
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except Exception as exc:  # noqa: BLE001 — surface to the parent on stderr
+        sys.stderr.write(f"convert.py failed: {exc}\n")
+        sys.exit(1)

package/python/convert_lib.py

@@ -0,0 +1,79 @@
+"""Shared model converter: ONNX -> OpenVINO IR (fp16/int8/CoreML) + validation.
+
+Used by both the runtime model-convert cap (convert.py) and the offline
+scripts/build-camstack-models.py. Conversion ALWAYS starts from ONNX via
+ov.convert_model (never the Ultralytics OV exporter, which emits unnamed
+tensors that break the runtime's named-output postprocess)."""
+from __future__ import annotations
+from pathlib import Path
+
+
+def export_openvino(onnx_path: str, out_xml: str, *, fp16: bool) -> None:
+    import openvino as ov
+    ov_model = ov.convert_model(onnx_path)
+    Path(out_xml).parent.mkdir(parents=True, exist_ok=True)
+    ov.save_model(ov_model, out_xml, compress_to_fp16=fp16)
+
+
+def validate_openvino_ir(xml_path: str) -> None:
+    """Compile the IR and assert every input/output tensor carries a name.
+    This is the exact defect (unnamed tensors) that broke 14/26 catalog IRs."""
+    import openvino as ov
+    core = ov.Core()
+    model = core.read_model(xml_path)
+    compiled = core.compile_model(model, "CPU")
+    for port in list(compiled.inputs) + list(compiled.outputs):
+        try:
+            name = port.get_any_name()
+        except Exception as exc:  # ov raises when a tensor has no names
+            raise ValueError(f"IR {xml_path} has an unnamed tensor: {exc}") from exc
+        if not name:
+            raise ValueError(f"IR {xml_path} has an empty-named tensor")
+
+
+def quantize_openvino_int8(
+    onnx_path: str, out_xml: str, calib_dir: str, imgsz: int, max_samples: int = 300
+) -> None:
+    import cv2
+    import numpy as np
+    import openvino as ov
+    import nncf
+
+    calib = Path(calib_dir)
+    images = sorted(
+        p for p in calib.iterdir() if p.suffix.lower() in {".jpg", ".jpeg", ".png"}
+    )[:max_samples]
+    if not images:
+        raise ValueError(f"no calibration images in {calib_dir}")
+
+    def preprocess(path: Path):
+        img = cv2.imread(str(path))
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        h, w = img.shape[:2]
+        scale = imgsz / max(h, w)
+        nh, nw = int(round(h * scale)), int(round(w * scale))
+        resized = cv2.resize(img, (nw, nh))
+        canvas = np.full((imgsz, imgsz, 3), 114, dtype=np.uint8)
+        canvas[:nh, :nw] = resized
+        chw = canvas.transpose(2, 0, 1).astype(np.float32) / 255.0
+        return chw[np.newaxis, ...]
+
+    dataset = nncf.Dataset(images, lambda p: preprocess(p))
+    ov_model = ov.convert_model(onnx_path)
+    quantized = nncf.quantize(ov_model, dataset, subset_size=len(images))
+    Path(out_xml).parent.mkdir(parents=True, exist_ok=True)
+    ov.save_model(quantized, out_xml)
+
+
+def export_coreml_from_onnx(onnx_path: str, out_pkg: str, imgsz: int) -> None:
+    """ONNX -> CoreML mlpackage via coremltools (darwin only)."""
+    import coremltools as ct
+    mlmodel = ct.converters.onnx.convert(model=onnx_path) if hasattr(ct.converters, "onnx") \
+        else ct.convert(onnx_path, minimum_deployment_target=ct.target.iOS16)
+    Path(out_pkg).parent.mkdir(parents=True, exist_ok=True)
+    mlmodel.save(out_pkg)
+
+
+def validate_coreml(pkg_path: str) -> None:
+    import coremltools as ct
+    ct.models.MLModel(pkg_path)  # load; raises if malformed

package/python/requirements.txt

@@ -0,0 +1,14 @@
+# Cross-platform base + platform-gated conversion backends.
+#
+# openvino has NO arm64-macOS wheel (Intel/x86 Linux/Windows only), so installing
+# it unconditionally aborts the WHOLE pip install on an Apple-Silicon agent and
+# model-studio crash-loops on boot. coremltools is macOS-only. pip evaluates
+# these environment markers per host, so a Mac agent installs the CoreML backend
+# and skips OpenVINO, while a Linux/Windows agent does the reverse — convert_lib
+# imports each backend lazily, matching whatever this host provides.
+numpy
+opencv-python-headless
+onnx
+openvino>=2025,<2026 ; platform_system != "Darwin"
+nncf>=2.14 ; platform_system != "Darwin"
+coremltools>=8.0,<9 ; platform_system == "Darwin"