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++

The feed parser skips what it does not know: an engine, DeepSeek engine, Control or app entry for an unknown platform, backend or archive format is left out with one plain line instead of refusing the whole feed

Niko122158f244ab1ea6
diff --git a/strata_control/feed.py b/strata_control/feed.py
index cae083ca0..9f2f6ed4b 100644
--- a/strata_control/feed.py
+++ b/strata_control/feed.py
@@ -159,6 +159,9 @@ class Feed:
#: 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, ...] = ()
+ #: entries this Control does not know how to use (a platform, a backend or an archive format added after it was built): left out, one plain line each.
+ #: A feed with such an entry is still a feed; only an entry of a kind this Control knows and that is malformed refuses the feed.
+ skipped: tuple[str, ...] = ()
def url(self, ref: str) -> str:
return transfer.resolve_ref(transfer.base_of(self.source), ref)
@@ -174,18 +177,27 @@ def _time(value, what: str) -> dt.datetime:
return parsed if parsed.tzinfo else parsed.replace(tzinfo=dt.timezone.utc)
-def _engine_package(item: dict) -> EnginePackage:
+def _skipping(skipped: list | None, what: str, reason: str) -> None:
+ if skipped is None: # a caller that wants the strict reading
+ raise FeedError(f"the update feed lists {what}, {reason}")
+ skipped.append(f"The update feed lists {what}, {reason}: skipped (a newer Strata may use it).")
+
+
+def _engine_package(item: dict, skipped: list | None = None) -> EnginePackage | None:
if not isinstance(item, dict):
raise FeedError("an engine entry in the feed is not an object")
where = f"engine entry {item.get('version')!r}"
version = _need(item, "version", str, where)
version_key(version)
platform = _need(item, "platform", str, where)
- if platform not in PLATFORMS:
- raise FeedError(f"the feed's {where} names an unknown platform {platform!r}")
backend = _need(item, "backend", str, where)
+ label = f"{version} {platform}-{backend}" + (f"-{item['variant']}" if item.get("variant") else "")
+ if platform not in PLATFORMS:
+ _skipping(skipped, f"engine {label}", f"for a platform this Strata does not know ({platform})")
+ return None
if backend not in BACKEND_MATRIX:
- raise FeedError(f"the feed's {where} names an unknown backend {backend!r}")
+ _skipping(skipped, f"engine {label}", f"for a backend this Strata does not know ({backend})")
+ return None
archs = item.get("archs")
if not isinstance(archs, list) or not all(isinstance(a, str) and a for a in archs) or (backend != "cpu" and not archs):
raise FeedError(f"the feed's {where} needs a list of archs")
@@ -194,7 +206,8 @@ def _engine_package(item: dict) -> EnginePackage:
raise FeedError(f"the feed's {where} has an invalid min_driver")
fmt = _need(item, "format", str, where)
if fmt not in FORMATS:
- raise FeedError(f"the feed's {where} uses an unsupported archive format {fmt!r}")
+ _skipping(skipped, f"engine {label}", f"in an archive format this Strata does not know ({fmt})")
+ return None
size = _need(item, "size", int, where)
installed = _need(item, "installed_bytes", int, where)
if size <= 0 or installed <= 0:
@@ -210,14 +223,16 @@ def _engine_package(item: dict) -> EnginePackage:
notes=str(item.get("notes") or ""))
-def _control_package(item: dict, version: str) -> ControlPackage:
+def _control_package(item: dict, version: str, skipped: list | None = None) -> ControlPackage | None:
where = "control entry"
platform = _need(item, "platform", str, where)
if platform not in PLATFORMS:
- raise FeedError(f"the feed's control entry names an unknown platform {platform!r}")
+ _skipping(skipped, f"Control {version} {platform}", "for a platform this Strata does not know")
+ return None
fmt = _need(item, "format", str, where)
if fmt not in FORMATS:
- raise FeedError(f"the feed's control entry uses an unsupported archive format {fmt!r}")
+ _skipping(skipped, f"Control {version} {platform}", f"in an archive format this Strata does not know ({fmt})")
+ return None
size, installed = _need(item, "size", int, where), _need(item, "installed_bytes", int, where)
if size <= 0 or installed <= 0:
raise FeedError("the feed's control entry declares a size that cannot be a real file")
@@ -243,6 +258,7 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
expires = data.get("expires_at")
if expires is not None:
_time(expires, "expires_at")
+ skipped: list = []
app = None
raw_app = data.get("app")
if raw_app is not None:
@@ -256,8 +272,11 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
by_tauri = {v: k for k, v in TAURI_TARGETS.items()}
for target, entry in platforms.items():
plat = by_tauri.get(str(target).split("-nsis")[0].split("-msi")[0])
- if plat is None or not isinstance(entry, dict):
- raise FeedError(f"the feed's app entry names an unknown platform {target!r}")
+ if plat is None:
+ _skipping(skipped, f"the app for {target}", "a platform this Strata does not know")
+ continue
+ if not isinstance(entry, dict):
+ raise FeedError(f"the feed's app entry for {target!r} is not an object")
parsed_platforms[plat] = {"url": _need(entry, "url", str, "app entry"),
"signature": _need(entry, "signature", str, "app entry"),
"sha256": _hex(entry.get("sha256"), "app entry"),
@@ -271,13 +290,13 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
raise FeedError("the feed's control member is not an object")
cver = _need(raw_control, "version", str, "control entry")
version_key(cver)
- control = [_control_package(item, cver) for item in (raw_control.get("packages") or [])]
+ control = [c for c in (_control_package(item, cver, skipped) for item in (raw_control.get("packages") or [])) if c is not None]
engine = []
raw_engine = data.get("engine")
if raw_engine is not None:
if not isinstance(raw_engine, dict) or not isinstance(raw_engine.get("packages"), list):
raise FeedError("the feed's engine member lists no packages")
- engine = [_engine_package(item) for item in raw_engine["packages"]]
+ engine = [e for e in (_engine_package(item, skipped) for item in raw_engine["packages"]) if e is not None]
seen = set()
for pkg in engine:
ident = (pkg.version, pkg.platform, pkg.backend, pkg.variant)
@@ -289,7 +308,7 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
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"]]
+ dsv41 = [e for e in (_engine_package(item, skipped) for item in raw_dsv41["packages"]) if e is not None]
seen = set()
for pkg in dsv41:
ident = (pkg.version, pkg.platform, pkg.backend, pkg.variant)
@@ -297,7 +316,8 @@ def parse(payload: bytes, *, source: str, key_id: str) -> Feed:
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, dsv41=tuple(dsv41))
+ control=tuple(control), engine=tuple(engine), source=source, key_id=key_id, raw=payload, dsv41=tuple(dsv41),
+ skipped=tuple(skipped))
def _expired_words(expires_at: str, now: dt.datetime, server_now: dt.datetime | None) -> str:
diff --git a/strata_control/updater.py b/strata_control/updater.py
index 995e0c641..a32ac7504 100644
--- a/strata_control/updater.py
+++ b/strata_control/updater.py
@@ -365,6 +365,8 @@ def open_feed(ctx: Context, state: State) -> feedmod.Feed:
loaded = feedmod.fetch(ctx.source, ctx.trusted, last_sequence=last, channel=ctx.channel, now=ctx.now)
except feedmod.FeedDowngrade as exc:
raise feedmod.FeedDowngrade(downgrade_words(exc.sequence, exc.accepted, state.path)) from None
+ for line in loaded.skipped: # an entry from a newer release that this Control cannot use: said once, never an error
+ ctx.say("feed", line)
info = state.section("feed")
info.update({"sequence": loaded.sequence, "key_id": loaded.key_id, "source": ctx.source, "channel": loaded.channel,
"checked_at": (ctx.now or dt.datetime.now(dt.timezone.utc)).isoformat()})
diff --git a/tests/terminal/test_feed_skips_unknown.py b/tests/terminal/test_feed_skips_unknown.py
new file mode 100644
index 000000000..5d874fa99
--- /dev/null
+++ b/tests/terminal/test_feed_skips_unknown.py
@@ -0,0 +1,110 @@
+"""A feed that lists something this Control does not know (a platform, a backend or an archive format added in a later release) is still a feed:
+the entry is left out with one plain line, and the rest is read as usual. A Control up to 0.1.52 refused the whole feed in that case, which is why
+the first release with a new platform must not put it into the shared feed (see test_feed_aarch64.py). An entry of a KNOWN kind that is malformed
+still refuses the feed."""
+
+from __future__ import annotations
+
+import copy
+import json
+import unittest
+
+from strata_control import feed as feedmod
+
+
+def engine(**kw):
+ e = {"version": "0.1.53", "platform": "linux-x86_64", "backend": "cuda", "variant": "cuda13", "archs": ["sm_86"], "min_driver": {},
+ "min_runtime": None, "build_id": "b", "format": "tar.gz", "url": "e.tar.gz", "size": 10, "sha256": "a" * 64,
+ "manifest_sha256": "b" * 64, "installed_bytes": 20, "notes": ""}
+ e.update(kw)
+ return e
+
+
+def control(**kw):
+ c = {"platform": "linux-x86_64", "format": "tar.gz", "url": "c.tar.gz", "size": 10, "sha256": "a" * 64, "installed_bytes": 20, "entry": "strata.py"}
+ c.update(kw)
+ return c
+
+
+def doc(**members):
+ d = {"schema_version": 1, "feed": "strata-updates", "channel": "stable", "sequence": 1, "generated_at": "2026-10-28T00:00:00Z", "expires_at": None}
+ d.update(members)
+ return d
+
+
+def parse(d):
+ return feedmod.parse(json.dumps(d).encode(), source="x/strata-feed.json", key_id="k")
+
+
+class UnknownEntriesAreSkipped(unittest.TestCase):
+ def test_unknown_platform_in_every_member(self):
+ f = parse(doc(engine={"packages": [engine(), engine(platform="freebsd-riscv", url="u1")]},
+ dsv41={"packages": [engine(url="d"), engine(platform="plan9-mips", url="u2")]},
+ control={"version": "0.1.53", "packages": [control(), control(platform="linux-m68k", url="c2")]}))
+ self.assertEqual([p.platform for p in f.engine], ["linux-x86_64"])
+ self.assertEqual([p.platform for p in f.dsv41], ["linux-x86_64"])
+ self.assertEqual([p.platform for p in f.control], ["linux-x86_64"])
+ self.assertEqual(len(f.skipped), 3)
+ for line in f.skipped:
+ self.assertNotIn("\n", line)
+ self.assertIn("skipped", line)
+
+ def test_unknown_backend_and_format(self):
+ f = parse(doc(engine={"packages": [engine(), engine(backend="npu", url="u1"), engine(format="7z", url="u2")]},
+ control={"version": "0.1.53", "packages": [control(), control(format="rar", url="c2")]}))
+ self.assertEqual(len(f.engine), 1)
+ self.assertEqual(len(f.control), 1)
+ self.assertEqual(len(f.skipped), 3)
+
+ def test_an_unknown_variant_is_just_a_name(self):
+ f = parse(doc(engine={"packages": [engine(variant="cuda14-new")]}))
+ self.assertEqual(f.engine[0].variant, "cuda14-new")
+ self.assertEqual(f.skipped, ())
+
+ def test_unknown_app_platform(self):
+ app = {"version": "0.2.8", "notes": "", "pub_date": "2026-10-28T00:00:00Z", "platforms": {
+ "windows-x86_64": {"url": "a", "signature": "s", "sha256": "a" * 64, "size": 5},
+ "plan9-mips": {"url": "b", "signature": "s", "sha256": "a" * 64, "size": 5}}}
+ f = parse(doc(app=app))
+ self.assertEqual(sorted(f.app.platforms), ["windows-x86_64"])
+ self.assertEqual(len(f.skipped), 1)
+
+ def test_the_known_entries_are_unchanged_by_the_skipped_ones(self):
+ base = doc(engine={"packages": [engine()]}, control={"version": "0.1.53", "packages": [control()]})
+ more = copy.deepcopy(base)
+ more["engine"]["packages"].append(engine(platform="linux-aarch64x", url="u"))
+ a, b = parse(base), parse(more)
+ self.assertEqual(a.engine, b.engine)
+ self.assertEqual(a.control, b.control)
+ self.assertEqual(a.skipped, ())
+
+ def test_linux_aarch64_is_known_here(self):
+ f = parse(doc(engine={"packages": [engine(platform="linux-aarch64", archs=["sm_121"], url="a")]}))
+ self.assertEqual(len(f.engine), 1)
+ self.assertEqual(f.skipped, ())
+
+ def test_a_feed_of_only_unknown_entries_is_empty_not_an_error(self):
+ f = parse(doc(engine={"packages": [engine(platform="freebsd-riscv")]}))
+ self.assertEqual(f.engine, ())
+ self.assertEqual(len(f.skipped), 1)
+
+
+class MalformedKnownEntriesStillRefuse(unittest.TestCase):
+ def test_missing_fields(self):
+ for bad in (engine(sha256="zz"), engine(size=0), engine(archs=[]), engine(version="x.y")):
+ with self.assertRaises(feedmod.FeedError, msg=str(bad)):
+ parse(doc(engine={"packages": [bad]}))
+ with self.assertRaises(feedmod.FeedError):
+ parse(doc(control={"version": "0.1.53", "packages": [control(size=0)]}))
+
+ def test_a_duplicate_known_entry(self):
+ with self.assertRaises(feedmod.FeedError):
+ parse(doc(engine={"packages": [engine(), engine(url="again")]}))
+
+ def test_the_strict_reading_is_still_there_for_a_direct_caller(self):
+ with self.assertRaises(feedmod.FeedError):
+ feedmod._engine_package(engine(platform="freebsd-riscv"))
+
+
+if __name__ == "__main__":
+ unittest.main()