chore(main): release jacobian 0.12.0 (#1186)

* chore(main): release jacobian 0.12.0

* chore(release): synchronize uv and npm lockfiles

* docs(release): include merged operation features

* docs(release): match changelog issue links

* fix(runtime): accept tuple-shaped JSON model fields

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>

Author: github-actions[bot]

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.11.0"
+  ".": "0.12.0"
 }

CHANGELOG.md

@@ -1,6 +1,6 @@
 {
   "name": "jacobian",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "mcpName": "io.github.morluto/jacobian",
   "description": "Composable mathematical capabilities for AI agents, exposed through MCP and a CLI",
   "license": "MIT",

npm/package-lock.json

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "jacobian"
-version = "0.11.0"
+version = "0.12.0"
 description = "Atomic mathematical tools for agents over MCP and Python"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"

npm/package.json

@@ -7,13 +7,13 @@
     "url": "https://github.com/morluto/jacobian",
     "source": "github"
   },
-  "version": "0.11.0",
+  "version": "0.12.0",
   "packages": [
     {
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "jacobian",
-      "version": "0.11.0",
+      "version": "0.12.0",
       "runtimeHint": "npx",
       "transport": {
         "type": "stdio"

pyproject.toml

@@ -2,9 +2,10 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from typing import Any, Protocol, TypeVar
 
-from pydantic import BaseModel
+from pydantic import BaseModel, ValidationError
 
 from jacobian.canonical import CanonicalizationError, encode_strict_json
 from jacobian.capability_errors import CapabilityInvocationError
@@ -19,6 +20,86 @@
 PreparedT = TypeVar("PreparedT")
 
 
+def _restore_json_tuple_paths(
+    value: Any,
+    paths: tuple[tuple[Any, ...], ...],
+) -> Any:
+    """Restore tuple-shaped model fields after JSON parsing.
+
+    JSON arrays are the wire representation for both lists and tuples. Pydantic
+    strict JSON validation accepts the former, but rejects some constrained
+    tuple annotations even though their JSON representation is valid. Only the
+    paths identified by that precise validation error are adapted; all scalar
+    values remain subject to strict Python-mode validation below.
+    """
+
+    if any(not path for path in paths):
+        return tuple(value) if isinstance(value, list) else value
+
+    if isinstance(value, Mapping):
+        restored_mapping = dict(value)
+        for key in restored_mapping:
+            child_paths = tuple(path[1:] for path in paths if path and path[0] == key)
+            if child_paths:
+                restored_mapping[key] = _restore_json_tuple_paths(
+                    restored_mapping[key], child_paths
+                )
+        return restored_mapping
+
+    if isinstance(value, (list, tuple)):
+        restored_sequence = list(value)
+        for index in range(len(restored_sequence)):
+            child_paths = tuple(path[1:] for path in paths if path and path[0] == index)
+            if child_paths:
+                restored_sequence[index] = _restore_json_tuple_paths(
+                    restored_sequence[index], child_paths
+                )
+        return (
+            tuple(restored_sequence) if isinstance(value, tuple) else restored_sequence
+        )
+
+    return value
+
+
+def _validate_strict_json_model[ModelT: BaseModel](
+    model: type[ModelT], encoded: bytes, wire_payload: object
+) -> ModelT:
+    """Validate JSON strictly while honoring tuple fields' array wire form."""
+
+    try:
+        parsed = model.model_validate_json(encoded, strict=True)
+    except ValidationError as exc:
+        # Pydantic's strict JSON path treats some constrained tuple fields as
+        # Python-only tuples, although JSON arrays are their valid wire form.
+        # Normalize only paths reported as tuple mismatches and retry the whole
+        # model in strict Python mode. Nested tuple fields are reported only
+        # after their containing tuple has been normalized, so repeat until the
+        # model validates or a non-tuple error remains.
+        normalized_payload = wire_payload
+        for _ in range(64):
+            errors = exc.errors()
+            tuple_paths = tuple(
+                tuple(error["loc"]) for error in errors if error["type"] == "tuple_type"
+            )
+            if not tuple_paths:
+                raise exc
+            updated_payload = _restore_json_tuple_paths(
+                normalized_payload,
+                tuple_paths,
+            )
+            if updated_payload == normalized_payload:
+                raise exc
+            normalized_payload = updated_payload
+            try:
+                parsed = model.model_validate(normalized_payload, strict=True)
+            except ValidationError as retry_exc:
+                exc = retry_exc
+            else:
+                return parsed
+        raise exc
+    return parsed
+
+
 def parse_capability_input[ModelT: BaseModel](
     model: type[ModelT], payload: dict[str, Any]
 ) -> ModelT:
@@ -57,7 +138,7 @@ def parse_capability_input[ModelT: BaseModel](
                 ),
             )
         ) from exc
-    parsed = model.model_validate_json(encoded, strict=True)
+    parsed = _validate_strict_json_model(model, encoded, wire_payload)
     if typed_values:
         # Parse all ordinary fields through the strict JSON boundary, then
         # restore the already-validated port values. This preserves identity

server.json

@@ -8,7 +8,10 @@
 
 from pydantic import ValidationError
 
-from jacobian.capability_adapters import CapabilityAdapter
+from jacobian.capability_adapters import (
+    CapabilityAdapter,
+    _validate_strict_json_model,
+)
 from jacobian.capability_errors import (
     CapabilityError,
     CapabilityInvocationError,
@@ -291,8 +294,10 @@ def _adapter_output_model_failure(
             # PrimeFieldMatrix) into mappings, which strict model validation
             # quite correctly rejects even though the published output is
             # already a valid typed model.
-            output_type.model_validate_json(
-                output.model_dump_json(warnings="error"), strict=True
+            _validate_strict_json_model(
+                output_type,
+                output.model_dump_json(warnings="error").encode(),
+                output.model_dump(mode="json"),
             )
         except (TypeError, ValueError, ValidationError):
             pass

src/jacobian/capability_adapters.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import pytest
+from pydantic import StringConstraints, ValidationError
+
+from jacobian.capability_adapters import parse_capability_input
+from jacobian.contracts.results import ContractModel
+
+
+class _TupleRequest(ContractModel):
+    labels: tuple[Annotated[str, StringConstraints(strict=True)], ...]
+    limit: int
+
+
+def test_parse_capability_input_accepts_json_arrays_for_constrained_tuples() -> None:
+    parsed = parse_capability_input(
+        _TupleRequest,
+        {"labels": ["left", "right"], "limit": 2},
+    )
+
+    assert parsed.labels == ("left", "right")
+    assert isinstance(parsed.labels, tuple)
+
+
+def test_tuple_normalization_does_not_enable_scalar_coercion() -> None:
+    with pytest.raises(ValidationError):
+        parse_capability_input(
+            _TupleRequest,
+            {"labels": ["left"], "limit": "1"},
+        )