metaobjects 0.19.5__tar.gz → 0.19.7__tar.gz

{metaobjects-0.19.5 → metaobjects-0.19.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.19.5
+Version: 0.19.7
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.19.5 → metaobjects-0.19.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.19.5"
+version = "0.19.7"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.19.5 → metaobjects-0.19.7}/src/metaobjects/loader/validation_passes.py

@@ -110,6 +110,7 @@ from ..meta.core.relationship.relationship_constants import (
 from ..meta.core.identity.identity_constants import (
     IDENTITY_SUBTYPE_REFERENCE,
     IDENTITY_REFERENCE_ATTR_REFERENCES,
+    IDENTITY_REFERENCE_ATTR_ENFORCE,
 )
 from ..shared.separators import PACKAGE_SEP
 from ..meta.core.object.object_constants import (
@@ -123,21 +124,23 @@ from ..meta.core.index.index_constants import INDEX_ATTR_FIELDS, INDEX_SUBTYPE_L
 from ..source import resolved_source
 from ..naming_refs import did_you_mean_hint, resolve_object_ref
 
-# A subtype-specific template attr is valid ONLY on the subtype it is registered
+# A subtype-specific template attr is valid ONLY on the subtype(s) it is registered
 # for. The metamodel registers these per-subtype (see the core_types template block),
 # but the lenient loader does not reject a misplaced one — _validate_templates does.
 # Mirrors the per-subtype TEMPLATE_ATTRS_MAP split across the other ports.
-_TEMPLATE_SUBTYPE_ONLY_ATTRS: dict[str, str] = {
-    tc.TEMPLATE_ATTR_MAX_TOKENS: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_REQUIRED_SLOTS: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_MODEL: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_RESPONSE_REF: tc.TEMPLATE_SUBTYPE_PROMPT,
-    tc.TEMPLATE_ATTR_PROMPT_STYLE: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_KIND: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_SUBJECT_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_HTML_BODY_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_TEXT_BODY_REF: tc.TEMPLATE_SUBTYPE_OUTPUT,
-    tc.TEMPLATE_ATTR_TOOL_NAME: tc.TEMPLATE_SUBTYPE_TOOLCALL,
+# #237: @maxTokens is registered on BOTH prompt AND toolcall (a vendor-agnostic token
+# budget), so the value is a SET of allowed subtypes, not a single one.
+_TEMPLATE_SUBTYPE_ONLY_ATTRS: dict[str, frozenset[str]] = {
+    tc.TEMPLATE_ATTR_MAX_TOKENS: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT, tc.TEMPLATE_SUBTYPE_TOOLCALL}),
+    tc.TEMPLATE_ATTR_REQUIRED_SLOTS: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_MODEL: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_RESPONSE_REF: frozenset({tc.TEMPLATE_SUBTYPE_PROMPT}),
+    tc.TEMPLATE_ATTR_PROMPT_STYLE: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_KIND: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_SUBJECT_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_HTML_BODY_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_TEXT_BODY_REF: frozenset({tc.TEMPLATE_SUBTYPE_OUTPUT}),
+    tc.TEMPLATE_ATTR_TOOL_NAME: frozenset({tc.TEMPLATE_SUBTYPE_TOOLCALL}),
 }
 
 # ---------------------------------------------------------------------------
@@ -436,18 +439,22 @@ def _validate_attr_schema(
 
         # --- Check 1: required attrs must be present (uses node.attrs() = effective,
         #     so an inherited attr from the super chain satisfies the requirement) ---
-        present_attrs = node.attrs()
-        for schema in schemas:
-            if not schema.required:
-                continue
-            if schema.name not in present_attrs:
-                errors.append(
-                    MetaError(
-                        f"{_node_label(node)} is missing required attribute '@{schema.name}'",
-                        ErrorCode.ERR_MISSING_REQUIRED_ATTR,
-                        envelope=node.source,
+        # #236: an ABSTRACT node is a template, not instantiated — it may omit a required
+        # attr for concrete subtypes / `extends` to supply. Enforcement stays at the
+        # concrete level (a concrete's resolving attrs() must satisfy it). ADR-0039.
+        if not node.is_abstract:
+            present_attrs = node.attrs()
+            for schema in schemas:
+                if not schema.required:
+                    continue
+                if schema.name not in present_attrs:
+                    errors.append(
+                        MetaError(
+                            f"{_node_label(node)} is missing required attribute '@{schema.name}'",
+                            ErrorCode.ERR_MISSING_REQUIRED_ATTR,
+                            envelope=node.source,
+                        )
                     )
-                )
 
         # --- Checks 2 + 3: own attrs only (inherited attrs were already checked on
         #     the node that declared them; re-checking would double-report) ---
@@ -2290,6 +2297,20 @@ def _validate_relationships(root: MetaData, errors: list[MetaError]) -> None:
                     ),
                 ))
                 continue
+            # A junction is a physical join table — it MUST be an object.entity.
+            # ADR-0046 lets a value carry navigation-only references, so value-purity
+            # no longer implicitly guarantees a two-reference junction is an entity;
+            # assert it here. (A value/projection has no table to join through.)
+            if junction.sub_type != OBJECT_SUBTYPE_ENTITY:
+                errors.append(MetaError(
+                    f'relationship "{obj.name}.{rel.name}" '
+                    f'@{RELATIONSHIP_ATTR_THROUGH} "{through}" resolves to '
+                    f"{junction.type}.{junction.sub_type}, not an entity — a junction is a "
+                    f"persisted join table and must be object.entity.",
+                    ErrorCode.ERR_INVALID_RELATIONSHIP,
+                    envelope=rel.source,
+                ))
+                continue
             ref_count = _count_junction_references(junction)
             if ref_count != 2:
                 errors.append(MetaError(
@@ -2619,12 +2640,31 @@ def _validate_max_occurs(
                 )
 
 
-# FR-024 value purity (ADR-0028): a value object is a pure data shape — it
-# carries NO identity of any subtype and NO source. Mirrors TS subtype-rules.ts
-# validateValuePurity (effective children; envelope = the offending child).
+# FR-024 value purity (ADR-0028): a value object owns NO identity and NO source.
+# ADR-0046 admits ONE exception: a navigation-only identity.reference with explicit
+# @enforce: false — an outbound pointer to an entity (a DTO/message referencing X by
+# id) is not persistence. Its target still resolves (dangling → ERR_INVALID_REFERENCE
+# via the registry-derived pass) and codegen emits no FK/DDL. The value's OWN identity
+# (primary/secondary) and any enforced reference (a physical FK it has no table to
+# hold) stay banned. Mirrors TS subtype-rules.ts validateValuePurity.
 def _validate_value_purity(node: MetaObject, errors: list[MetaError]) -> None:
     for child in node.children():
         if child.type == TYPE_IDENTITY:
+            if child.sub_type == IDENTITY_SUBTYPE_REFERENCE:
+                # ADR-0046: navigation-only reference is the sanctioned exception.
+                if child.get_meta_attr(IDENTITY_REFERENCE_ATTR_ENFORCE) is False:
+                    continue
+                errors.append(
+                    MetaError(
+                        f"value object '{node.fqn()}' has an enforced reference "
+                        f"({TYPE_IDENTITY}.{child.sub_type} '{child.name}') — a value is not "
+                        f"persisted and has no table to hold a physical FK; declare a "
+                        f"navigation-only reference with @enforce: false (FR-024, ADR-0028, ADR-0046)",
+                        ErrorCode.ERR_SUBTYPE_RULE_VIOLATION,
+                        envelope=child.source,
+                    )
+                )
+                continue
             errors.append(
                 MetaError(
                     f"value object '{node.fqn()}' must not have an identity "
@@ -2968,13 +3008,14 @@ def _validate_templates(root: MetaData, errors: list[MetaError]) -> None:
         # e.g. @maxTokens (prompt-only) on a template.output, or @promptStyle
         # (output-only) on a template.prompt. ADR-0039: resolving — a subtype-only
         # attr may be inherited via extends, so read the effective value.
-        for attr_name, allowed_sub in _TEMPLATE_SUBTYPE_ONLY_ATTRS.items():
-            if tpl.get_meta_attr(attr_name) is not None and tpl.sub_type != allowed_sub:
+        for attr_name, allowed_subs in _TEMPLATE_SUBTYPE_ONLY_ATTRS.items():
+            if tpl.get_meta_attr(attr_name) is not None and tpl.sub_type not in allowed_subs:
+                valid_on = " / ".join(f"template.{s}" for s in sorted(allowed_subs))
                 errors.append(MetaError(
                     code=ErrorCode.ERR_INVALID_TEMPLATE,
                     message=(
                         f'template.{tpl.sub_type} "{tpl.name}" carries @{attr_name}, '
-                        f"which is only valid on template.{allowed_sub}"
+                        f"which is only valid on {valid_on}"
                     ),
                     envelope=tpl.source,
                 ))

{metaobjects-0.19.5 → metaobjects-0.19.7}/src/metaobjects/spec_metamodel/prompt.json

@@ -69,7 +69,8 @@
         { "type": "attr", "subType": "string", "name": "toolName", "min": 1, "max": 1, "description": "Wire tool name surfaced to the LLM (vendor-specific format)." },
         { "type": "attr", "subType": "string", "name": "payloadRef", "min": 1, "max": 1, "description": "Output value-object the tool produces (resolved against the metamodel)." },
         { "type": "attr", "subType": "string", "name": "owner", "min": 0, "max": 1, "description": "Governance: the owner of this toolcall." },
-        { "type": "attr", "subType": "string", "name": "since", "min": 0, "max": 1, "description": "Governance: the version this toolcall was introduced in." }
+        { "type": "attr", "subType": "string", "name": "since", "min": 0, "max": 1, "description": "Governance: the version this toolcall was introduced in." },
+        { "type": "attr", "subType": "int", "name": "maxTokens", "min": 0, "max": 1, "description": "Per-call token budget for the tool-call's structured response (LLM-specific). Vendor-agnostic config; peer of @maxTokens on template.prompt (#237)." }
       ]
     }
   ]

{metaobjects-0.19.5 → metaobjects-0.19.7}/tests/unit/test_template_toolcall.py

@@ -51,6 +51,7 @@ def test_template_toolcall_attr_schema_does_not_inherit_generic_attrs() -> None:
         tc.TEMPLATE_ATTR_PAYLOAD_REF,
         tc.TEMPLATE_ATTR_OWNER,
         tc.TEMPLATE_ATTR_SINCE,
+        tc.TEMPLATE_ATTR_MAX_TOKENS,  # #237 — vendor-agnostic per-call token budget
     }
     assert tc.TEMPLATE_ATTR_TEXT_REF not in attrs, "toolcall must NOT carry @textRef"
     assert tc.TEMPLATE_ATTR_FORMAT not in attrs, "toolcall must NOT carry @format"
@@ -59,6 +60,7 @@ def test_template_toolcall_attr_schema_does_not_inherit_generic_attrs() -> None:
     assert attrs[tc.TEMPLATE_ATTR_PAYLOAD_REF].required is True
     assert attrs[tc.TEMPLATE_ATTR_OWNER].required is False
     assert attrs[tc.TEMPLATE_ATTR_SINCE].required is False
+    assert attrs[tc.TEMPLATE_ATTR_MAX_TOKENS].required is False
 
 
 # ---------------------------------------------------------------------------

{metaobjects-0.19.5 → metaobjects-0.19.7}/uv.lock

@@ -250,7 +250,7 @@ wheels = [
 
 [[package]]
 name = "metaobjects"
-version = "0.19.1"
+version = "0.19.6"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },