feat: infer/validate monetary_fields object_name from structure, slim report

object_name in the optional monetary_fields config is now optional for
mode=json: inferred from the single structure parent key and validated
against the structure when provided (clear per-item errors on mismatch or
when ambiguous). Slim the per-field report to generic fields only
(object_name/field/item_index/status/value/parsed_value/error) — drop
currency/currency_code/confidence and rename amount to parsed_value. The
flow is fully user-driven with no hardcoded field names.

Generated with Codebuff 🤖
Co-Authored-By: Codebuff <noreply@codebuff.com>

app/api/v1/json_extract.py

@@ -165,11 +165,13 @@ class NoAiExtractRequest(BaseModel):
         default=None,
         description=(
             "OPTIONAL. Declare which extracted fields hold monetary values so they "
-            "are price-parsed in place: `object_name` selects the container key in "
-            "the extracted `data` (e.g. 'invoice') and `field_names` lists the "
-            "monetary fields inside each object (e.g. ['total']). Found values are "
-            "replaced with their parsed numeric amount; missing/blank/unparseable "
-            "values are skipped. Omit to leave the extracted data untouched."
+            "are price-parsed in place: `field_names` lists the monetary fields "
+            "inside each object (e.g. ['total']) and `object_name` selects the "
+            "container key in the extracted `data` -- it is inferred from the "
+            "`structure` parent key when omitted (mode='json') and validated "
+            "against the structure when provided. Found values are replaced with "
+            "their parsed numeric amount; missing/blank/unparseable values are "
+            "reported per field. Omit to leave the extracted data untouched."
         ),
     )
 
@@ -177,10 +179,14 @@ class NoAiExtractRequest(BaseModel):
 class MonetaryFieldsConfig(BaseModel):
     """Declares which extracted fields are monetary so they are price-parsed."""
 
-    object_name: str = Field(
-        ...,
-        min_length=1,
-        description="Key in the extracted `data` whose value holds the objects to process, e.g. 'invoice'.",
+    object_name: Optional[str] = Field(
+        default=None,
+        description=(
+            "Container key in the extracted `data` whose value holds the objects to "
+            "process, e.g. 'invoice'. OPTIONAL for mode='json': inferred from the "
+            "single parent key of `structure`. When provided it must match a "
+            "structure object name. Required for mode='entities'."
+        ),
     )
     field_names: List[str] = Field(
         ...,
@@ -201,8 +207,8 @@ class NoAiExtractResponse(BaseModel):
         description=(
             "Per-field outcome of the optional `monetary_fields` config: status "
             "is 'parsed', 'not_found', 'not_parsable' or 'skipped', with the "
-            "parsed amount and a human-readable error. Empty when no config "
-            "was sent."
+            "raw `value`, the `parsed_value` and a human-readable error. Empty "
+            "when no config was sent."
         ),
     )
 
@@ -311,6 +317,55 @@ async def no_ai_extract_endpoint(
                 ),
             )
 
+        # Resolve the monetary-fields target object name. It is optional for
+        # mode='json' (inferred from the single `structure` parent key) and
+        # validated against the structure when provided.
+        monetary_config = item.monetary_fields
+        object_name: Optional[str] = None
+        if monetary_config is not None:
+            object_name = monetary_config.object_name
+            if item.mode == "json" and isinstance(item.structure, dict):
+                structure_names = [k for k in item.structure if isinstance(k, str)]
+                if object_name is None:
+                    if len(structure_names) == 1:
+                        object_name = structure_names[0]
+                    else:
+                        return NoAiExtractResponse(
+                            success=False,
+                            time_ms=round((time.perf_counter() - start) * 1000, 3),
+                            mode=item.mode,
+                            data=None,
+                            count=0,
+                            error_message=(
+                                "monetary_fields.object_name is required when the structure "
+                                "has multiple object names: " + ", ".join(structure_names)
+                            ),
+                        )
+                elif object_name not in structure_names:
+                    return NoAiExtractResponse(
+                        success=False,
+                        time_ms=round((time.perf_counter() - start) * 1000, 3),
+                        mode=item.mode,
+                        data=None,
+                        count=0,
+                        error_message=(
+                            f"monetary_fields.object_name '{object_name}' does not match "
+                            "the structure object name(s): " + ", ".join(structure_names)
+                        ),
+                    )
+            elif item.mode == "entities" and object_name is None:
+                return NoAiExtractResponse(
+                    success=False,
+                    time_ms=round((time.perf_counter() - start) * 1000, 3),
+                    mode=item.mode,
+                    data=None,
+                    count=0,
+                    error_message=(
+                        "monetary_fields.object_name is required for mode='entities' "
+                        "(no structure to infer it from)"
+                    ),
+                )
+
         try:
             if item.mode == "json":
                 result = await run_in_executor(
@@ -341,7 +396,7 @@ async def no_ai_extract_endpoint(
         if item.monetary_fields is not None:
             monetary_report = apply_monetary_fields(
                 result,
-                item.monetary_fields.object_name,
+                object_name or "",
                 item.monetary_fields.field_names,
             )
             parsed_monetary = sum(1 for s in monetary_report if s.status == "parsed")

app/services/monetary_field_service.py

@@ -19,7 +19,7 @@ Extracted data::
 After :func:`apply_monetary_fields` the same dict has ``"total": 1250.75``
 (price-parsed) and the returned report explains each field:
 
-* ``total``      -> status ``parsed``, amount 1250.75
+* ``total``      -> status ``parsed``, parsed_value 1250.75
 * ``invoice_no`` -> status ``not_found`` (no such field in the object)
 """
 
@@ -47,14 +47,8 @@ class MonetaryFieldStatus(BaseModel):
     )
     value: Optional[str] = None
     """The raw value as extracted (string form), when present."""
-    amount: Optional[float] = None
+    parsed_value: Optional[float] = None
     """Parsed numeric amount when status == 'parsed'."""
-    currency: Optional[str] = None
-    """Currency marker found in the value, when parsed."""
-    currency_code: Optional[str] = None
-    """ISO 4217 code when determinable, else None."""
-    confidence: float = 0.0
-    """Parser confidence in [0, 1] when parsed."""
     error: Optional[str] = None
     """Human-readable reason when the field was not parsed."""
 
@@ -168,10 +162,7 @@ def apply_monetary_fields(data: Any, object_name: str, field_names: List[str]) -
                     idx,
                     status="parsed",
                     value=str(value),
-                    amount=parsed.amount_float,
-                    currency=parsed.currency,
-                    currency_code=parsed.currency_code,
-                    confidence=parsed.confidence,
+                    parsed_value=parsed.amount_float,
                 )
             )
     return report