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.pyindex 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 Noneif 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 Nonearchs = 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 Nonesize = _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 Nonefmt = _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 Nonesize, 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 = Noneraw_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.pyindex 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.pynew file mode 100644index 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()