ilang-protocol 1.0.0__tar.gz

ilang_protocol-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ilang-ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ilang_protocol-1.0.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: ilang-protocol
+Version: 1.0.0
+Summary: The iLang loader: fetches the official iLang runtime, verifies it, caches it and puts it in front of any model's context. Don't learn iLang. Your AI should.
+Author: Long Quan Zhu
+License: MIT
+Project-URL: Homepage, https://ilang.ai
+Project-URL: Source, https://github.com/ilang-ai/ilang
+Project-URL: Specification, https://github.com/ilang-ai/ilang-spec
+Keywords: ilang,iLang,ai,llm,prompt,protocol,agent,openai,anthropic,gemini,deepseek
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ilang-protocol
+
+**Don't learn iLang. Your AI should.**
+
+The Python loader for [iLang](https://ilang.ai). It fetches the official iLang runtime from the canon repository, checks its sha256, keeps a verified copy on disk and adds it to any model's messages.
+
+```bash
+pip install ilang-protocol
+```
+
+```python
+import ilang
+
+messages = ilang.wrap([{"role": "user", "content": "帮我分析这个问题"}])   # OpenAI-style messages
+system = ilang.system()                                                     # Anthropic, Gemini
+print(ilang.status())
+```
+
+Updates are checked at most once an hour; without a network the last verified copy is used, and with no copy at all the messages go out unchanged unless `strict=True`. Pin an exact runtime with `version=` for reproducible runs; add `extensions=["media"]` for image, video and audio work. The core runtime is about 27,000 tokens, so enable your provider's prompt caching.
+
+Standard library only, Python 3.9+. Source, JavaScript version and documentation: [github.com/ilang-ai/ilang](https://github.com/ilang-ai/ilang). MIT.

ilang_protocol-1.0.0/README.md

@@ -0,0 +1,21 @@
+# ilang-protocol
+
+**Don't learn iLang. Your AI should.**
+
+The Python loader for [iLang](https://ilang.ai). It fetches the official iLang runtime from the canon repository, checks its sha256, keeps a verified copy on disk and adds it to any model's messages.
+
+```bash
+pip install ilang-protocol
+```
+
+```python
+import ilang
+
+messages = ilang.wrap([{"role": "user", "content": "帮我分析这个问题"}])   # OpenAI-style messages
+system = ilang.system()                                                     # Anthropic, Gemini
+print(ilang.status())
+```
+
+Updates are checked at most once an hour; without a network the last verified copy is used, and with no copy at all the messages go out unchanged unless `strict=True`. Pin an exact runtime with `version=` for reproducible runs; add `extensions=["media"]` for image, video and audio work. The core runtime is about 27,000 tokens, so enable your provider's prompt caching.
+
+Standard library only, Python 3.9+. Source, JavaScript version and documentation: [github.com/ilang-ai/ilang](https://github.com/ilang-ai/ilang). MIT.

ilang_protocol-1.0.0/ilang/__init__.py

@@ -0,0 +1,57 @@
+"""iLang loader. Don't learn iLang. Your AI should.
+
+    import ilang
+    messages = ilang.wrap(messages)          # OpenAI-style message lists
+    system = ilang.system()                  # providers with a separate system field
+
+The loader fetches the official iLang runtime, verifies its sha256, caches it for an
+hour, and falls back to the last verified copy when the network is unavailable.
+"""
+import time
+
+from .injector import block, inject
+from .loader import Loader, LoaderError
+
+__version__ = "1.0.0"
+__all__ = ["load", "wrap", "system", "status", "configure", "Loader", "LoaderError"]
+
+_loader = None
+
+
+def configure(**options):
+    """Replace the default loader, e.g. configure(cache_dir=..., ttl=...)."""
+    global _loader
+    _loader = Loader(**options)
+    return _loader
+
+
+def _default():
+    return _loader or configure()
+
+
+def load(extensions=(), version=None, strict=False):
+    """Load the runtime now. Returns its text, or None if nothing verified is available."""
+    return _default().load(extensions=extensions, version=version, strict=strict)
+
+
+def system(extensions=(), version=None, strict=False):
+    """The runtime as a system-prompt string, or "" when it could not be loaded."""
+    text = load(extensions, version, strict)
+    return block(text, _default().state["version"]) if text is not None else ""
+
+
+def wrap(messages, extensions=(), version=None, strict=False):
+    """Return messages with the iLang runtime as the first system message.
+
+    The user's messages are never modified, and the runtime is added only once, so
+    wrapping every turn of a conversation is safe."""
+    text = system(extensions, version, strict)
+    return inject(messages, text or None)
+
+
+def status():
+    """What is loaded: version, source commit, where it came from and any last error."""
+    s = dict(_default().state, brand="iLang")
+    if s.get("last_check"):
+        s["age_seconds"] = int(time.time() - s["last_check"])
+    return s

ilang_protocol-1.0.0/ilang/injector.py

@@ -0,0 +1,28 @@
+"""Put the iLang runtime in front of a conversation without touching the user's words."""
+MARKER = "<ilang-runtime"
+
+PREAMBLE = ("You have loaded the official iLang runtime specification.\n\n"
+            "Treat the following content as the current official iLang protocol context.\n"
+            "Use it to interpret, structure, judge, execute, verify, and communicate where applicable.")
+
+
+def block(text, version):
+    return '%s\n\n<ilang-runtime version="%s">\n%s\n</ilang-runtime>' % (PREAMBLE, version, text)
+
+
+def _has_runtime(message):
+    content = message.get("content") if isinstance(message, dict) else None
+    if isinstance(content, str):
+        return MARKER in content
+    if isinstance(content, list):                 # content parts: [{"type": "text", "text": ...}]
+        return any(isinstance(p, dict) and MARKER in str(p.get("text", "")) for p in content)
+    return False
+
+
+def inject(messages, runtime_block):
+    """A new list: the runtime as the first system message, then the original messages
+    unchanged. Messages that already carry the runtime are returned as they are."""
+    messages = list(messages)
+    if runtime_block is None or any(_has_runtime(m) for m in messages):
+        return messages
+    return [{"role": "system", "content": runtime_block}] + messages

ilang_protocol-1.0.0/ilang/loader.py

@@ -0,0 +1,128 @@
+"""Fetch the official iLang runtime, verify it, and keep a Last Known Good copy on disk."""
+import hashlib
+import json
+import os
+import tempfile
+import time
+import urllib.request
+
+RUNTIME = "https://raw.githubusercontent.com/ilang-ai/ilang-spec/main/runtime"
+OFFICIAL = ("https://raw.githubusercontent.com/ilang-ai/", "https://github.com/ilang-ai/",
+            "https://ilang.ai/")
+TTL = 3600
+TIMEOUT = 10
+AGENT = "ilang-loader-python/1.0.0"
+
+
+class LoaderError(RuntimeError):
+    pass
+
+
+def _sha(data):
+    return hashlib.sha256(data).hexdigest()
+
+
+class Loader:
+    def __init__(self, runtime=RUNTIME, cache_dir=None, ttl=TTL, allow_custom_source=False):
+        if not runtime.startswith(OFFICIAL) and not allow_custom_source:
+            raise ValueError("iLang loads only from official sources unless allow_custom_source=True")
+        self.runtime = runtime.rstrip("/")
+        self.cache = cache_dir or os.environ.get("ILANG_CACHE_DIR") or os.path.join(
+            os.environ.get("XDG_CACHE_HOME") or os.path.join(os.path.expanduser("~"), ".cache"), "ilang")
+        self.ttl = ttl
+        self.state = {"loaded": False, "source": "none", "version": None, "source_commit": None,
+                      "last_check": None, "error": None}
+        self._memo = {}
+
+    def _read(self, *parts):
+        try:
+            with open(os.path.join(self.cache, *parts), "rb") as f:
+                return f.read()
+        except OSError:
+            return None
+
+    def _write(self, data, *parts):
+        path = os.path.join(self.cache, *parts)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        fd, tmp = tempfile.mkstemp(dir=os.path.dirname(path))
+        with os.fdopen(fd, "wb") as f:
+            f.write(data)
+        os.replace(tmp, path)                     # atomic: a reader never sees half a file
+
+    def _fetch(self, url):
+        if not url.startswith(OFFICIAL) and not url.startswith(self.runtime):
+            raise LoaderError("refusing to fetch from %s" % url)
+        req = urllib.request.Request(url, headers={"User-Agent": AGENT})
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as r:
+            return r.read()
+
+    def _last_check(self):
+        raw = self._read("state.json")
+        return json.loads(raw).get("last_check", 0) if raw else 0
+
+    def _get(self, manifest, name, where, remote):
+        """One bundle, verified against the manifest; (bytes, came_from_network)."""
+        meta = manifest["bundles"].get(name)
+        if meta is None:
+            raise LoaderError("the runtime has no bundle named %r" % name)
+        data = self._read(*where, name + ".md")
+        if data is not None and _sha(data) == meta["sha256"]:
+            return data, False
+        if not remote:
+            raise LoaderError("no verified %s bundle in the cache" % name)
+        data = self._fetch(meta["url"])
+        if len(data) != meta["bytes"] or _sha(data) != meta["sha256"]:
+            raise LoaderError("the %s bundle failed its sha256 check" % name)
+        return data, True
+
+    def _load(self, names, version):
+        where = ("versions", version) if version else ("latest",)
+        cached = self._read(*where, "manifest.json")
+        manifest = json.loads(cached) if cached else None
+        checked = False
+        if manifest is None or (not version and time.time() - self._last_check() >= self.ttl):
+            url = "%s/versions/%s/manifest.json" % (self.runtime, version) if version else \
+                self.runtime + "/manifest.json"
+            manifest, checked = json.loads(self._fetch(url)), True
+        got = [self._get(manifest, n, where, True) for n in names]
+        for n, (data, new) in zip(names, got):   # write only once everything has verified
+            if new:
+                self._write(data, *where, n + ".md")
+        if checked:
+            self._write(json.dumps(manifest).encode(), *where, "manifest.json")
+            if not version:
+                self._write(json.dumps({"last_check": time.time()}).encode(), "state.json")
+        source = "remote" if checked or any(new for _, new in got) else "cache"
+        return manifest, [data.decode("utf-8") for data, _ in got], source
+
+    def load(self, extensions=(), version=None, strict=False):
+        """The runtime text, or None when nothing verified is available and strict is off."""
+        names = ["core"] + [e for e in extensions if e != "core"]
+        key = (tuple(names), version)
+        hit = self._memo.get(key)
+        if hit and (version or time.time() - hit[1] < self.ttl):
+            self.state.update(hit[2])
+            return hit[0]
+        try:
+            manifest, texts, source = self._load(names, version)
+            self.state["error"] = None
+        except Exception as err:                  # network, hash or parse failure
+            self.state["error"] = "%s: %s" % (type(err).__name__, err)
+            try:                                  # Last Known Good, never the network
+                where = ("versions", version) if version else ("latest",)
+                manifest = json.loads(self._read(*where, "manifest.json") or b"null")
+                texts = [self._get(manifest, n, where, False)[0].decode("utf-8") for n in names]
+                source = "cache"
+            except Exception:
+                if strict:
+                    raise LoaderError(self.state["error"])
+                self.state.update(loaded=False, source="none")
+                return None
+        self.state.update(loaded=True, source=source, version=manifest["version"],
+                          source_commit=manifest["source_commit"],
+                          last_check=self._last_check() or None)
+        text = "\n\n".join(texts)
+        if self.state["error"] is None:           # a fallback copy is re-checked next call
+            self._memo[key] = (text, time.time(), {k: self.state[k] for k in
+                                                    ("loaded", "source", "version", "source_commit")})
+        return text

ilang_protocol-1.0.0/ilang_protocol.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: ilang-protocol
+Version: 1.0.0
+Summary: The iLang loader: fetches the official iLang runtime, verifies it, caches it and puts it in front of any model's context. Don't learn iLang. Your AI should.
+Author: Long Quan Zhu
+License: MIT
+Project-URL: Homepage, https://ilang.ai
+Project-URL: Source, https://github.com/ilang-ai/ilang
+Project-URL: Specification, https://github.com/ilang-ai/ilang-spec
+Keywords: ilang,iLang,ai,llm,prompt,protocol,agent,openai,anthropic,gemini,deepseek
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# ilang-protocol
+
+**Don't learn iLang. Your AI should.**
+
+The Python loader for [iLang](https://ilang.ai). It fetches the official iLang runtime from the canon repository, checks its sha256, keeps a verified copy on disk and adds it to any model's messages.
+
+```bash
+pip install ilang-protocol
+```
+
+```python
+import ilang
+
+messages = ilang.wrap([{"role": "user", "content": "帮我分析这个问题"}])   # OpenAI-style messages
+system = ilang.system()                                                     # Anthropic, Gemini
+print(ilang.status())
+```
+
+Updates are checked at most once an hour; without a network the last verified copy is used, and with no copy at all the messages go out unchanged unless `strict=True`. Pin an exact runtime with `version=` for reproducible runs; add `extensions=["media"]` for image, video and audio work. The core runtime is about 27,000 tokens, so enable your provider's prompt caching.
+
+Standard library only, Python 3.9+. Source, JavaScript version and documentation: [github.com/ilang-ai/ilang](https://github.com/ilang-ai/ilang). MIT.

ilang_protocol-1.0.0/ilang_protocol.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+ilang/__init__.py
+ilang/injector.py
+ilang/loader.py
+ilang_protocol.egg-info/PKG-INFO
+ilang_protocol.egg-info/SOURCES.txt
+ilang_protocol.egg-info/dependency_links.txt
+ilang_protocol.egg-info/top_level.txt
+tests/test_ilang.py

ilang_protocol-1.0.0/ilang_protocol.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ilang_protocol-1.0.0/ilang_protocol.egg-info/top_level.txt

@@ -0,0 +1 @@
+ilang

ilang_protocol-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ilang-protocol"
+version = "1.0.0"
+description = "The iLang loader: fetches the official iLang runtime, verifies it, caches it and puts it in front of any model's context. Don't learn iLang. Your AI should."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Long Quan Zhu" }]
+keywords = ["ilang", "iLang", "ai", "llm", "prompt", "protocol", "agent", "openai", "anthropic", "gemini", "deepseek"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Homepage = "https://ilang.ai"
+Source = "https://github.com/ilang-ai/ilang"
+Specification = "https://github.com/ilang-ai/ilang-spec"
+
+[tool.setuptools]
+packages = ["ilang"]

ilang_protocol-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ilang_protocol-1.0.0/tests/test_ilang.py

@@ -0,0 +1,195 @@
+"""Offline tests: a local HTTP server plays the official runtime. Standard library only.
+
+    python -m unittest discover -s tests          (from the python/ directory)
+    ILANG_NETWORK_TESTS=1 ...                     also checks the real official runtime
+"""
+import hashlib
+import http.server
+import json
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+import ilang  # noqa: E402
+from ilang.injector import inject  # noqa: E402
+from ilang.loader import Loader, LoaderError  # noqa: E402
+
+
+class FakeRuntime:
+    """Serves runtime/manifest.json, bundles and versions/<v>/ from a temp directory."""
+
+    def __init__(self):
+        self.root = tempfile.mkdtemp()
+        handler = lambda *a, **k: http.server.SimpleHTTPRequestHandler(*a, directory=self.root, **k)
+        http.server.SimpleHTTPRequestHandler.log_message = lambda *a: None
+        self.server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), handler)
+        threading.Thread(target=self.server.serve_forever, daemon=True).start()
+        self.base = "http://127.0.0.1:%d/runtime" % self.server.server_address[1]
+
+    def publish(self, version, texts, corrupt=None):
+        bundles = {}
+        for name, text in texts.items():
+            data = text.encode("utf-8")
+            self._put(data, "runtime", name + ".md")
+            self._put(data, "runtime", "versions", version, name + ".md")
+            served = b"tampered" if corrupt == name else data
+            if corrupt == name:
+                self._put(served, "runtime", name + ".md")
+            bundles[name] = {"url": "%s/%s.md" % (self.base, name), "bytes": len(data),
+                             "sha256": hashlib.sha256(data).hexdigest()}
+        manifest = {"brand": "iLang", "runtime_schema": 1, "version": version,
+                    "source_commit": "c0ffee" + version, "bundles": bundles}
+        self._put(json.dumps(manifest).encode(), "runtime", "manifest.json")
+        pinned = dict(manifest, bundles={n: dict(b, url="%s/versions/%s/%s.md" % (self.base, version, n))
+                                         for n, b in bundles.items()})
+        self._put(json.dumps(pinned).encode(), "runtime", "versions", version, "manifest.json")
+
+    def _put(self, data, *parts):
+        path = os.path.join(self.root, *parts)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "wb") as f:
+            f.write(data)
+
+    def stop(self):
+        self.server.shutdown()
+        self.server.server_close()
+        shutil.rmtree(self.root, ignore_errors=True)
+
+
+class LoaderTests(unittest.TestCase):
+    def setUp(self):
+        self.remote = FakeRuntime()
+        self.remote.publish("v1", {"core": "CORE ONE", "media": "MEDIA ONE"})
+        self.cache = tempfile.mkdtemp()
+
+    def tearDown(self):
+        self.remote.stop()
+        shutil.rmtree(self.cache, ignore_errors=True)
+
+    def loader(self, ttl=3600):
+        return Loader(runtime=self.remote.base, cache_dir=self.cache, ttl=ttl, allow_custom_source=True)
+
+    def test_loads_verifies_and_caches(self):
+        ld = self.loader()
+        self.assertEqual(ld.load(), "CORE ONE")
+        self.assertEqual(ld.state["source"], "remote")
+        self.assertEqual(ld.state["version"], "v1")
+        self.assertTrue(os.path.exists(os.path.join(self.cache, "latest", "core.md")))
+
+    def test_within_ttl_the_network_is_not_used(self):
+        self.loader().load()
+        self.remote.stop()
+        ld = self.loader()
+        self.assertEqual(ld.load(), "CORE ONE")
+        self.assertEqual(ld.state["source"], "cache")
+
+    def test_remote_down_after_ttl_uses_last_known_good(self):
+        self.loader(ttl=0).load()
+        self.remote.stop()
+        ld = self.loader(ttl=0)
+        self.assertEqual(ld.load(), "CORE ONE")
+        self.assertEqual(ld.state["source"], "cache")
+        self.assertIsNotNone(ld.state["error"])
+
+    def test_no_cache_and_no_network_fails_open_or_raises_when_strict(self):
+        self.remote.stop()
+        ld = self.loader()
+        self.assertIsNone(ld.load())
+        self.assertFalse(ld.state["loaded"])
+        with self.assertRaises(LoaderError):
+            self.loader().load(strict=True)
+
+    def test_a_bundle_failing_its_hash_never_replaces_last_known_good(self):
+        self.loader(ttl=0).load()
+        self.remote.publish("v2", {"core": "CORE TWO", "media": "MEDIA TWO"}, corrupt="core")
+        ld = self.loader(ttl=0)
+        self.assertEqual(ld.load(), "CORE ONE")
+        self.assertIn("sha256", ld.state["error"])
+        with open(os.path.join(self.cache, "latest", "core.md"), encoding="utf-8") as f:
+            self.assertEqual(f.read(), "CORE ONE")
+
+    def test_a_new_version_replaces_the_cache(self):
+        self.loader(ttl=0).load()
+        self.remote.publish("v2", {"core": "CORE TWO", "media": "MEDIA TWO"})
+        ld = self.loader(ttl=0)
+        self.assertEqual(ld.load(), "CORE TWO")
+        self.assertEqual(ld.state["version"], "v2")
+
+    def test_pinned_version_is_immutable_and_works_offline(self):
+        self.remote.publish("v2", {"core": "CORE TWO", "media": "MEDIA TWO"})
+        self.assertEqual(self.loader().load(version="v1"), "CORE ONE")
+        self.remote.stop()
+        self.assertEqual(self.loader().load(version="v1"), "CORE ONE")
+
+    def test_extensions_are_loaded_on_request(self):
+        self.assertEqual(self.loader().load(extensions=["media"]), "CORE ONE\n\nMEDIA ONE")
+
+    def test_only_official_sources_by_default(self):
+        with self.assertRaises(ValueError):
+            Loader(runtime="https://example.com/runtime")
+
+
+class InjectorTests(unittest.TestCase):
+    def setUp(self):
+        self.remote = FakeRuntime()
+        self.remote.publish("v1", {"core": "CORE ONE"})
+        self.cache = tempfile.mkdtemp()
+        ilang.configure(runtime=self.remote.base, cache_dir=self.cache, allow_custom_source=True)
+
+    def tearDown(self):
+        self.remote.stop()
+        shutil.rmtree(self.cache, ignore_errors=True)
+
+    def test_runtime_goes_first_and_user_messages_are_untouched(self):
+        msgs = [{"role": "system", "content": "app rules"}, {"role": "user", "content": "帮我完成这个任务"}]
+        original = json.dumps(msgs)
+        out = ilang.wrap(msgs)
+        self.assertEqual(json.dumps(msgs), original)          # input not mutated
+        self.assertEqual(out[0]["role"], "system")
+        self.assertIn('<ilang-runtime version="v1">', out[0]["content"])
+        self.assertIn("CORE ONE", out[0]["content"])
+        self.assertEqual(out[1:], msgs)
+
+    def test_runtime_is_added_only_once(self):
+        once = ilang.wrap([{"role": "user", "content": "hi"}])
+        again = ilang.wrap(once + [{"role": "assistant", "content": "ok"}, {"role": "user", "content": "next"}])
+        self.assertEqual(sum("<ilang-runtime" in m["content"] for m in again), 1)
+
+    def test_content_parts_are_recognised(self):
+        msgs = [{"role": "system", "content": [{"type": "text", "text": "<ilang-runtime version=x>"}]}]
+        self.assertEqual(inject(msgs, "block"), msgs)
+
+    def test_fail_open_returns_the_messages_unchanged(self):
+        self.remote.stop()
+        ilang.configure(runtime=self.remote.base, cache_dir=tempfile.mkdtemp(), allow_custom_source=True)
+        msgs = [{"role": "user", "content": "hi"}]
+        self.assertEqual(ilang.wrap(msgs), msgs)
+        self.assertEqual(ilang.system(), "")
+        self.assertFalse(ilang.status()["loaded"])
+
+    def test_status_reports_version_and_commit(self):
+        ilang.wrap([{"role": "user", "content": "hi"}])
+        s = ilang.status()
+        self.assertEqual((s["brand"], s["version"], s["source_commit"]), ("iLang", "v1", "c0ffeev1"))
+
+
+@unittest.skipUnless(os.environ.get("ILANG_NETWORK_TESTS"), "set ILANG_NETWORK_TESTS=1")
+class OfficialRuntimeTests(unittest.TestCase):
+    def test_the_official_runtime_loads_and_verifies(self):
+        cache = tempfile.mkdtemp()
+        try:
+            ld = Loader(cache_dir=cache)
+            text = ld.load(extensions=["media"], strict=True)
+            self.assertIn("iLang runtime bundle (core)", text)
+            self.assertIn("iLang runtime bundle (media)", text)
+            self.assertEqual(ld.state["source"], "remote")
+        finally:
+            shutil.rmtree(cache, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    unittest.main()