agentversion 0.2.3__tar.gz → 0.2.4__tar.gz

{agentversion-0.2.3 → agentversion-0.2.4}/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 > **Package version ≠ spec version.** This file tracks the **package** version. The on-the-wire `spec_version` is independent and frozen at `1.0.0`; a pre-1.0 package can implement a stable 1.0 spec, which is exactly the situation today.
 
+## [Unreleased]
+
+## [0.2.4] - 2026-11-10
+
+### Changed
+- **Filling in a `model_runtime` value the old manifest never recorded is no longer a
+  change of it.** A blank `provider`, `model` or `tool_calling_mode` becoming known grades
+  `minor` and `non_breaking`. It used to read as a provider change: `major`, `breaking`.
+  A manifest that follows the spec always carries `provider` and `model`, so this affects
+  partial baselines only. Conformance scenarios and hash vectors are unchanged.
+
 ## [0.2.3] - 2026-08-14
 
 Packaging and documentation only. **No code, schema, or `spec_version` change** — the

{agentversion-0.2.3 → agentversion-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentversion
-Version: 0.2.3
+Version: 0.2.4
 Summary: An open specification for versioning agent runtimes and keeping datasets valid.
 Project-URL: Homepage, https://github.com/decimal-labs/agentversion
 Project-URL: Documentation, https://github.com/decimal-labs/agentversion/tree/main/spec
@@ -23,7 +23,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0
 Requires-Dist: jcs<1,>=0.2
-Requires-Dist: pydantic>=2.0
+Requires-Dist: pydantic>=2.1
 Requires-Dist: rich>=13.0
 Provides-Extra: dev
 Requires-Dist: jsonschema>=4.0; extra == 'dev'

{agentversion-0.2.3 → agentversion-0.2.4}/agentversion/cli.py

@@ -141,7 +141,9 @@ def init() -> None:
     provider = click.prompt("Model provider (e.g. openai, anthropic, google)", type=str)
     model = click.prompt("Model name (e.g. gpt-4o, claude-opus-4, gemini-2.0-flash)", type=str)
 
-    manifest = {
+    # Typed explicitly: since click 8.5 types `click.prompt` as returning str, mypy infers this literal
+    # as dict[str, Collection[str]] and rejects the nested lookups below.
+    manifest: dict[str, Any] = {
         "spec_version": SPEC_VERSION,
         "kind": "agent_manifest",
         "manifest_id": mint_id("agent_manifest"),

{agentversion-0.2.3 → agentversion-0.2.4}/agentversion/diff.py

@@ -70,6 +70,64 @@ def _max_severity(*levels: Severity) -> Severity:
 # ── Per-surface severity classifiers ────────────────────
 
 
+_PROMPT_TOKEN_RE = re.compile(r"\w+|[^\w\s]+")
+# Past this many tokens on both sides of one changed stretch, let difflib skip
+# its most frequent tokens again (autojunk): an unbroken run that long is rare
+# in a prompt, and without it a repetitive one costs seconds per comparison.
+_PROMPT_REGION_AUTOJUNK_AT = 4000
+
+
+def _matched_chars(old_tokens: list[str], new_tokens: list[str]) -> int:
+    autojunk = len(old_tokens) + len(new_tokens) > _PROMPT_REGION_AUTOJUNK_AT
+    matcher = difflib.SequenceMatcher(None, old_tokens, new_tokens, autojunk=autojunk)
+    return sum(
+        len(token)
+        for block in matcher.get_matching_blocks()
+        for token in old_tokens[block.a:block.a + block.size]
+    )
+
+
+def _prompt_diff_pct(old_text: str, new_text: str) -> float:
+    """Percent of the prompt's text that changed, 0-100.
+
+    Measured on words and punctuation, weighted by their characters, so
+    re-wrapping or re-indenting a prompt changes nothing and a one-word edit
+    counts about that word's share of the text. Lines are aligned first, which
+    is cheap (lines are nearly all distinct) and keeps a long prompt's edits
+    from being matched against the wrong copy of a repeated phrase; words are
+    then compared only inside the lines that changed.
+
+    It used to be ``difflib.SequenceMatcher(None, old, new).ratio()`` over
+    characters. SequenceMatcher's default "autojunk" ignores every element
+    that makes up more than 1% of a sequence of 200 or more, which in prose is
+    nearly every letter: a one-word edit to a 217-character prompt read 33%
+    changed and to a 1,320-character one 99.2%, so every edit to a real
+    prompt graded major.
+    """
+    old_lines = [_PROMPT_TOKEN_RE.findall(line) for line in old_text.splitlines()]
+    new_lines = [_PROMPT_TOKEN_RE.findall(line) for line in new_text.splitlines()]
+    old_lines = [tokens for tokens in old_lines if tokens]
+    new_lines = [tokens for tokens in new_lines if tokens]
+    total = sum(len(t) for line in old_lines for t in line) + sum(
+        len(t) for line in new_lines for t in line
+    )
+    if old_lines == new_lines or not total:
+        return 0.0
+    old_keys = ["\x00".join(line) for line in old_lines]
+    new_keys = ["\x00".join(line) for line in new_lines]
+    matched = 0
+    lines = difflib.SequenceMatcher(None, old_keys, new_keys, autojunk=False)
+    for tag, i1, i2, j1, j2 in lines.get_opcodes():
+        if tag == "equal":
+            matched += sum(len(t) for line in old_lines[i1:i2] for t in line)
+        elif tag == "replace":
+            matched += _matched_chars(
+                [t for line in old_lines[i1:i2] for t in line],
+                [t for line in new_lines[j1:j2] for t in line],
+            )
+    return round((1 - 2 * matched / total) * 100, 1)
+
+
 def prompt_severity(old_text: str, new_text: str) -> tuple[Severity, float]:
     """Classify prompt change severity using text diff ratio.
 
@@ -81,10 +139,7 @@ def prompt_severity(old_text: str, new_text: str) -> tuple[Severity, float]:
     changes from hashes/versions alone (no inline text), so they do NOT call
     this — the ratio tiers here are not part of the manifest diff pipeline.
     """
-    if not old_text and not new_text:
-        return "minor", 0.0
-    ratio = difflib.SequenceMatcher(None, old_text, new_text).ratio()
-    diff_pct = round((1 - ratio) * 100, 1)
+    diff_pct = _prompt_diff_pct(old_text or "", new_text or "")
     if diff_pct <= 5:
         return "minor", diff_pct
     elif diff_pct <= 30:
@@ -101,6 +156,8 @@ def model_severity(
     - Same model, config tweak (temp/top_p) → minor
     - Version bump within same family → moderate
     - Provider or family change → major
+    - A provider, model or tool_calling_mode the old side never recorded being
+      filled in → minor. It says what was running; nothing changed.
     """
     details: list[str] = []
     severity: Severity = "minor"
@@ -110,10 +167,10 @@ def model_severity(
     old_model = str(old.get("model", ""))
     new_model = str(new.get("model", ""))
 
-    if old_provider != new_provider:
+    if old_provider and old_provider != new_provider:
         details.append(f"provider: {old_provider!r} → {new_provider!r}")
         severity = "major"
-    elif old_model != new_model:
+    elif old_model and old_model != new_model:
         # Check if same family (e.g. gpt-4o vs gpt-4o-mini)
         old_family = _extract_model_family(old_model)
         new_family = _extract_model_family(new_model)
@@ -123,13 +180,19 @@ def model_severity(
         else:
             details.append(f"model version: {old_model!r} → {new_model!r}")
             severity = "moderate"
+    else:
+        if old_provider != new_provider:
+            details.append(f"provider: {old_provider!r} → {new_provider!r}")
+        if old_model != new_model:
+            details.append(f"model: {old_model!r} → {new_model!r}")
 
     # tool_calling_mode lives at the top level of model_runtime.
     if old.get("tool_calling_mode") != new.get("tool_calling_mode"):
         details.append(
             f"tool_calling_mode: {old.get('tool_calling_mode')!r} → {new.get('tool_calling_mode')!r}"
         )
-        severity = _max_severity(severity, "moderate")
+        if old.get("tool_calling_mode"):
+            severity = _max_severity(severity, "moderate")
 
     # Generation params are nested under generation_config (not top-level).
     old_gc = old.get("generation_config") or {}
@@ -676,7 +739,7 @@ def _adapt_model_runtime(old: dict[str, Any], new: dict[str, Any]) -> tuple[
     Literal["breaking", "non_breaking"], Severity, list[str]
 ]:
     sev, details = model_severity(old, new)
-    is_breaking = any(old.get(k) != new.get(k) for k in _BREAKING_MODEL_FIELDS)
+    is_breaking = any(old.get(k) and old.get(k) != new.get(k) for k in _BREAKING_MODEL_FIELDS)
     return ("breaking" if is_breaking else "non_breaking"), sev, details
 
 

{agentversion-0.2.3 → agentversion-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentversion"
-version = "0.2.3"
+version = "0.2.4"
 description = "An open specification for versioning agent runtimes and keeping datasets valid."
 readme = "README.md"
 license = "Apache-2.0"
@@ -26,7 +26,11 @@ classifiers = [
     "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = [
-    "pydantic>=2.0",
+    # 2.1 is the real floor: this package declares `model_config_hash`, which sits
+    # in pydantic's protected `model_` namespace. 2.0 raises NameError on it at
+    # class-definition time; 2.1 downgraded that to a warning. Verified 2026-08-17
+    # by the floors CI job, which failed on exactly this.
+    "pydantic>=2.1",
     "click>=8.0",
     "rich>=13.0",
     # Upper-pinned: jcs does the RFC 8785 canonicalization that every overall_hash

{agentversion-0.2.3 → agentversion-0.2.4}/tests/test_diff.py

@@ -227,6 +227,66 @@ class TestPromptSeverity:
         assert sev == "major"
         assert pct > 30
 
+    # difflib's "autojunk" heuristic ignores every character that makes up more
+    # than 1% of a text of 200+ characters, which in prose is nearly every
+    # letter. A one-word edit to a 217-character prompt then read 33% changed,
+    # and to a 1,320-character one 99.2% — every real prompt edit graded major.
+    _SUPPORT_PROMPT = (
+        "You are the order-support agent for an online store. Look up the order with "
+        "lookup_order before you answer anything about it. Be concise and friendly. "
+        "Never promise a refund; tell the customer a person will review it."
+    )
+
+    def test_one_word_edit_to_a_realistic_prompt_is_minor(self):
+        from agentversion.diff import prompt_severity
+        tweaked = self._SUPPORT_PROMPT.replace("concise and friendly", "concise and warm")
+        sev, pct = prompt_severity(self._SUPPORT_PROMPT, tweaked)
+        assert sev == "minor", pct
+        assert pct < 5
+
+    def test_one_word_edit_to_a_long_prompt_is_minor(self):
+        from agentversion.diff import prompt_severity
+        long_prompt = "\n".join(
+            f"{i}. {self._SUPPORT_PROMPT}" for i in range(1, 7)
+        )
+        assert len(long_prompt) > 1200
+        sev, pct = prompt_severity(long_prompt, long_prompt.replace("friendly", "warm", 1))
+        assert sev == "minor", pct
+        assert pct < 1
+
+    def test_added_paragraph_is_moderate(self):
+        from agentversion.diff import prompt_severity
+        added = self._SUPPORT_PROMPT + (
+            " If the order shipped more than ten days ago, apologise and offer to open a trace."
+        )
+        sev, pct = prompt_severity(self._SUPPORT_PROMPT, added)
+        assert sev == "moderate", pct
+
+    def test_rewrite_of_a_realistic_prompt_is_major(self):
+        from agentversion.diff import prompt_severity
+        sev, pct = prompt_severity(
+            self._SUPPORT_PROMPT,
+            "You handle shipping questions only. Reply in exactly two sentences, quote "
+            "the tracking number, and hand anything about money to the billing team.",
+        )
+        assert sev == "major", pct
+
+    def test_identical_prompts_are_unchanged(self):
+        from agentversion.diff import prompt_severity
+        assert prompt_severity(self._SUPPORT_PROMPT, self._SUPPORT_PROMPT) == ("minor", 0.0)
+
+    def test_large_prompt_is_graded_quickly(self):
+        import time
+
+        from agentversion.diff import prompt_severity
+        words = [f"word{i % 997}" for i in range(6000)]  # ~50k characters
+        old = " ".join(words)
+        new = " ".join(words[:3000] + ["inserted"] * 20 + words[3000:])
+        start = time.perf_counter()
+        sev, pct = prompt_severity(old, new)
+        assert sev == "minor", pct
+        assert time.perf_counter() - start < 2.0
+
 
 class TestModelSeverity:
     def test_config_only_is_minor(self):
@@ -254,6 +314,31 @@ class TestModelSeverity:
         )
         assert sev == "major"
 
+    def test_filling_in_what_was_never_recorded_is_minor(self):
+        # A baseline made before the agent first ran has no model on it.
+        from agentversion.diff import model_severity
+        sev, details = model_severity(
+            {}, {"provider": "openai", "model": "gpt-4o", "tool_calling_mode": "auto"},
+        )
+        assert sev == "minor"
+        assert details == [
+            "provider: '' → 'openai'",
+            "model: '' → 'gpt-4o'",
+            "tool_calling_mode: None → 'auto'",
+        ]
+
+    def test_losing_a_recorded_provider_is_still_major(self):
+        from agentversion.diff import model_severity
+        sev, _ = model_severity(
+            {"provider": "openai", "model": "gpt-4o"}, {"model": "gpt-4o"},
+        )
+        assert sev == "major"
+
+    def test_a_blank_provider_does_not_hide_a_family_change(self):
+        from agentversion.diff import model_severity
+        sev, _ = model_severity({"model": "gpt-4o"}, {"provider": "google", "model": "gemini-2.0-flash"})
+        assert sev == "major"
+
     def test_tool_calling_mode_change_is_moderate(self):
         from agentversion.diff import model_severity
         sev, details = model_severity(