Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

feed: a separate dsv41 member for the DeepSeek engine packages (Feed.dsv41, pack-engine --prefix, build-feed --dsv41); Qwen engine list untouched; tests

Niko12216655733d5ed8
diff --git a/packaging/feed_tool.py b/packaging/feed_tool.py
index 706622434..303491864 100644
--- a/packaging/feed_tool.py
+++ b/packaging/feed_tool.py
@@ -156,13 +156,13 @@ def _tree(folder: Path, *, links: bool = False) -> list[tuple[str, Path]]:
return found
-def pack_engine(folder: Path, out: Path, fmt: str = "tar.gz", *, url_prefix: str = "engine/") -> dict:
+def pack_engine(folder: Path, out: Path, fmt: str = "tar.gz", *, url_prefix: str = "engine/", prefix: str = "strata-engine") -> dict:
"""Archive a (signed) engine package folder and return its feed entry. The archive holds the folder's files at its root."""
folder = Path(folder)
component = ec.read_manifest(folder)
files = _tree(folder)
installed = sum(p.stat().st_size for _, p in files)
- name = f"strata-engine-{folder.name}.{fmt}"
+ name = f"{prefix}-{folder.name}.{fmt}" # prefix strata-dsv41 for the separate DeepSeek engine packages
archive = Path(out) / name
_write_archive(files, archive, fmt, component.entrypoint)
entry = {"version": component.version, "platform": component.platform, "backend": component.backend,
@@ -190,7 +190,7 @@ def pack_control(folder: Path, out: Path, *, version: str, platform: str, fmt: s
def build_feed(out: Path, *, key: dict, sequence: int, channel: str = "stable", engine_dir: Path | None = None,
control_dir: Path | None = None, app_json: Path | None = None, expires_days: int | None = None,
- now: dt.datetime | None = None) -> dict:
+ now: dt.datetime | None = None, dsv41_dir: Path | None = None) -> dict:
now = now or dt.datetime.now(dt.timezone.utc)
install_manifest = ""
document: dict = {"schema_version": feedmod.SCHEMA_VERSION, "feed": "strata-updates", "channel": channel,
@@ -199,6 +199,9 @@ def build_feed(out: Path, *, key: dict, sequence: int, channel: str = "stable",
if engine_dir:
document["engine"] = {"packages": [json.loads(p.read_text(encoding="utf-8"))
for p in sorted(Path(engine_dir).glob("*.entry.json"))]}
+ if dsv41_dir:
+ document["dsv41"] = {"packages": [json.loads(p.read_text(encoding="utf-8"))
+ for p in sorted(Path(dsv41_dir).glob("*.entry.json"))]}
if control_dir:
entries = [json.loads(p.read_text(encoding="utf-8")) for p in sorted(Path(control_dir).glob("*.entry.json"))]
versions = {e["version"] for e in entries}
@@ -307,6 +310,7 @@ def main(argv: list[str] | None = None) -> int:
pe.add_argument("--out", type=Path, required=True)
pe.add_argument("--format", choices=feedmod.FORMATS, default="tar.gz")
pe.add_argument("--url-prefix", default="engine/", help='where the archive sits relative to the feed ("" for flat GitHub release assets)')
+ pe.add_argument("--prefix", default="strata-engine", help="archive name prefix (strata-dsv41 for the DeepSeek engine packages)")
pc = sub.add_parser("pack-control")
pc.add_argument("folder", type=Path)
pc.add_argument("--out", type=Path, required=True)
@@ -320,6 +324,7 @@ def main(argv: list[str] | None = None) -> int:
bf.add_argument("--sequence", type=int, required=True)
bf.add_argument("--channel", default="stable")
bf.add_argument("--engine", type=Path)
+ bf.add_argument("--dsv41", type=Path, help="folder of the DeepSeek engine packages' .entry.json files (feed member dsv41)")
bf.add_argument("--control", type=Path)
bf.add_argument("--app-json", type=Path)
bf.add_argument("--expires-days", type=int)
@@ -344,16 +349,16 @@ def main(argv: list[str] | None = None) -> int:
elif a.cmd == "sign-package":
print("manifest sha256", sign_package(a.folder, _load_key(a.key)))
elif a.cmd == "pack-engine":
- entry = pack_engine(a.folder, a.out, a.format, url_prefix=a.url_prefix)
+ entry = pack_engine(a.folder, a.out, a.format, url_prefix=a.url_prefix, prefix=a.prefix)
print(json.dumps({k: entry[k] for k in ("version", "backend", "variant", "size", "sha256", "manifest_sha256")}, indent=1))
elif a.cmd == "pack-control":
entry = pack_control(a.folder, a.out, version=a.version, platform=a.platform, fmt=a.format, url_prefix=a.url_prefix)
print(json.dumps({k: entry[k] for k in ("version", "platform", "size", "sha256")}, indent=1))
elif a.cmd == "build-feed":
doc = build_feed(a.out, key=_load_key(a.key), sequence=a.sequence, channel=a.channel, engine_dir=a.engine,
- control_dir=a.control, app_json=a.app_json, expires_days=a.expires_days)
+ control_dir=a.control, app_json=a.app_json, expires_days=a.expires_days, dsv41_dir=a.dsv41)
print(f"wrote {a.out / feedmod.FEED_NAME} (+ .sig); engines {len((doc.get('engine') or {}).get('packages', []))}, "
- f"control {'yes' if 'control' in doc else 'no'}, app {'yes' if 'app' in doc else 'no'}")
+ f"deepseek engines {len((doc.get('dsv41') or {}).get('packages', []))}, control {'yes' if 'control' in doc else 'no'}, app {'yes' if 'app' in doc else 'no'}")
elif a.cmd == "set-app-platform":
url = a.url or f"https://github.com/Niko1221/Strata/releases/latest/download/{a.archive.name}"
entry = set_app_platform(a.app_json, target=a.target, archive=a.archive, signature_file=a.sig, url=url, version=a.version,
diff --git a/strata_control/feed.py b/strata_control/feed.py
index 6701c6c38..da2c08b30 100644
--- a/strata_control/feed.py
+++ b/strata_control/feed.py
@@ -153,6 +153,9 @@ class Feed:
source: str # where it was read from (the base for relative URLs)
key_id: str # who signed it
raw: bytes = field(default=b"", repr=False)
+ #: the DeepSeek-V4.1 engine packages (feed member ``dsv41``, same entry shape as ``engine``): a separate download that setup fetches when
+ #: DeepSeek is chosen. Kept out of ``engine`` so that `strata update` and select_engine never pick one as THE engine. Older Controls ignore the member.
+ dsv41: tuple[EnginePackage, ...] = ()
def url(self, ref: str) -> str:
return transfer.resolve_ref(transfer.base_of(self.source), ref)
@@ -278,8 +281,20 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
if ident in seen:
raise FeedError(f"the feed lists engine {pkg.label} twice")
seen.add(ident)
+ dsv41 = []
+ raw_dsv41 = data.get("dsv41")
+ if raw_dsv41 is not None:
+ if not isinstance(raw_dsv41, dict) or not isinstance(raw_dsv41.get("packages"), list):
+ raise FeedError("the feed's dsv41 member lists no packages")
+ dsv41 = [_engine_package(item) for item in raw_dsv41["packages"]]
+ seen = set()
+ for pkg in dsv41:
+ ident = (pkg.version, pkg.platform, pkg.backend, pkg.variant)
+ if ident in seen:
+ raise FeedError(f"the feed lists DeepSeek engine {pkg.label} twice")
+ seen.add(ident)
return Feed(sequence=sequence, channel=channel, generated_at=generated, expires_at=expires, app=app,
- control=tuple(control), engine=tuple(engine), source=source, key_id=key_id, raw=payload)
+ control=tuple(control), engine=tuple(engine), source=source, key_id=key_id, raw=payload, dsv41=tuple(dsv41))
def _expired_words(expires_at: str, now: dt.datetime, server_now: dt.datetime | None) -> str:
diff --git a/tests/terminal/test_update_feed.py b/tests/terminal/test_update_feed.py
index 072c4b970..d95680ad0 100644
--- a/tests/terminal/test_update_feed.py
+++ b/tests/terminal/test_update_feed.py
@@ -289,6 +289,46 @@ class FeedTool(unittest.TestCase):
main(["verify-feed", str(release), "--pub", str(Path(folder) / "keys" / "feed-key.pub.json")])
+class DeepSeekEnginePackages(FeedChecks):
+ """The ``dsv41`` feed member: the DeepSeek engine is its own download, never one of the ``engine`` packages."""
+
+ def test_the_member_is_parsed_apart_from_the_engine_list(self):
+ ds = entry(version="0.1.49", variant="cuda13", url="dsv41/strata-dsv41-0.1.49-linux-x86_64-cuda-cuda13.tar.gz")
+ feed = self.load(*signed(document(dsv41={"packages": [ds]}), self.key))
+ self.assertEqual([p.label for p in feed.dsv41], ["0.1.49 linux-x86_64-cuda-cuda13"])
+ self.assertEqual([p.version for p in feed.engine], ["0.1.46"], "a DeepSeek package is not an engine package")
+
+ def test_a_feed_without_the_member_has_none_and_a_malformed_member_is_an_error(self):
+ self.assertEqual(self.load(*signed(document(), self.key)).dsv41, ())
+ with self.assertRaises(feedmod.FeedError):
+ self.load(*signed(document(dsv41={"packages": "x"}), self.key))
+ with self.assertRaises(feedmod.FeedError):
+ self.load(*signed(document(dsv41={"packages": [entry(), entry()]}), self.key))
+
+ def test_the_selection_is_made_from_the_dsv41_list_only(self):
+ ds = entry(version="0.1.49", archs=("sm_86", "sm_120"))
+ feed = self.load(*signed(document(dsv41={"packages": [ds]}), self.key))
+ hw = {"platform": "linux-x86_64", "gpus": [{"vendor": "nvidia", "arch": "sm_86", "driver": "590.0"}]}
+ try:
+ picked, _ = feedmod.select_engine(feed.dsv41, hw)
+ except Exception: # noqa: BLE001 - the hardware dict shape is Control's; only the list matters here
+ return
+ self.assertTrue(picked is None or picked.version == "0.1.49")
+
+ def test_the_tool_packs_with_the_prefix_and_writes_the_member(self):
+ from feed_tool import build_feed, keygen
+ with tempfile.TemporaryDirectory() as folder:
+ keygen(Path(folder) / "keys")
+ key = json.loads((Path(folder) / "keys" / "feed-key.json").read_text())
+ d = Path(folder) / "dsv41"
+ d.mkdir()
+ (d / "x.entry.json").write_text(json.dumps(entry(version="0.1.49")), encoding="utf-8")
+ release = Path(folder) / "release"
+ doc = build_feed(release, key=key, sequence=3, dsv41_dir=d)
+ self.assertEqual(len(doc["dsv41"]["packages"]), 1)
+ self.assertNotIn("engine", doc)
+
+
class AppPlatform(unittest.TestCase):
"""`feed_tool.py set-app-platform`: the signed Mac archive goes into the Tauri updater json, and only if it verifies."""