fix(scoring): show N/A instead of 0% for unavailable entity/schema scores

Root cause: When the evaluate step couldn't compute any per-field confidence (e.g.
logprobs unavailable on reasoning models like gpt-5/o1/o3, or image-only flow with
no Content Understanding signal), save_handler emitted entity_score=0.0,
schema_score=0.0. These `0.0`s flowed through Cosmos -> API -> UI and rendered as
`0%` (red), indistinguishable from a genuine zero confidence.

Fix: Treat `total_evaluated_fields_count == 0` (or no comparison items) as
*unavailable* and propagate `None` through the ContentProcessor, ContentProcessorAPI
and ContentProcessorWorkflow models. The frontend percentage cell renderer now shows
`N/A` for null/undefined and `0%` only for a genuine numeric zero.

Files changed:
- ContentProcessor: save_handler.py (extracted _derive_aggregate_scores helper)
- ContentProcessor: content_process.py default scores -> None
- ContentProcessorAPI: ContentProcess + Content_Process default scores -> None
- ContentProcessorWorkflow: ContentProcessRecord + Content_Process default scores -> None
- ContentProcessorWorkflow: document_process_executor preserves None instead of
  coercing to 0.0
- ContentProcessorWeb: ProcessQueueGridTypes types scores nullable;
  ProcessQueueGrid passes undefined for null/undefined; CustomCellRender renders
  `N/A` when valueText is null/undefined and only `...` while still processing

Tests:
- New: ContentProcessor/tests/unit/pipeline/test_save_handler_scores.py (5 cases:
  valid scores, missing per-field signal, no comparison items, genuine zero,
  all-fields-above-threshold)
- Updated existing default-value tests in Workflow + src/tests to assert None
- Added tests for explicit zero preservation and Failed status -> None

Author: Prachig-Microsoft

src/ContentProcessor/src/libs/models/content_process.py

@@ -67,9 +67,9 @@ class ContentProcess(BaseModel):
     last_modified_time: datetime.datetime = datetime.datetime.now(datetime.UTC)
     last_modified_by: Optional[str] = None
     status: str
-    entity_score: Optional[float] = 0.0
-    min_extracted_entity_score: Optional[float] = 0.0
-    schema_score: Optional[float] = 0.0
+    entity_score: Optional[float] = None
+    min_extracted_entity_score: Optional[float] = None
+    schema_score: Optional[float] = None
     result: Optional[dict] = None
     confidence: Optional[dict] = None
     target_schema: Optional[Schema] = None

src/ContentProcessor/src/libs/pipeline/handlers/save_handler.py

@@ -112,20 +112,15 @@ def find_process_result(step_name: str):
             )
         )
 
-        total_evaluated_fields_count = evaluated_result.confidence.get(
-            "total_evaluated_fields_count", 0
-        )
-        schema_score = (
-            0
-            if total_evaluated_fields_count == 0
-            else round(
-                (
-                    len(evaluated_result.comparison_result.items)
-                    - evaluated_result.confidence["zero_confidence_fields_count"]
-                )
-                / len(evaluated_result.comparison_result.items),
-                3,
-            )
+        # Determine whether per-field confidence could actually be computed.
+        # When `total_evaluated_fields_count == 0`, no field-level confidence
+        # signal was produced (e.g. logprobs unavailable on reasoning models, or
+        # an image flow with no Content Understanding signal). In that case the
+        # entity/schema scores are *unavailable* rather than genuinely zero, and
+        # we propagate ``None`` so downstream consumers (API + UI) can render
+        # an explicit "N/A" instead of a misleading "0%".
+        entity_score, schema_score, min_extracted_entity_score = (
+            self._derive_aggregate_scores(evaluated_result)
         )
 
         processed_result = ContentProcess(
@@ -143,11 +138,9 @@ def find_process_result(step_name: str):
                 self._current_message_context.data_pipeline.pipeline_status.creation_time,
                 "%Y-%m-%dT%H:%M:%S.%fZ",
             ),
-            entity_score=evaluated_result.confidence["overall_confidence"],
+            entity_score=entity_score,
             schema_score=schema_score,
-            min_extracted_entity_score=evaluated_result.confidence[
-                "min_extracted_field_confidence"
-            ],
+            min_extracted_entity_score=min_extracted_entity_score,
             prompt_tokens=evaluated_result.prompt_tokens,
             completion_tokens=evaluated_result.completion_tokens,
             target_schema=Schema.get_schema(
@@ -241,3 +234,41 @@ def _summarize_processed_time(self, step_results: list[StepResult]) -> str:
         # Format the total elapsed time as a string
         formatted_elapsed_time = f"{total_hours:02}:{total_minutes:02}:{total_seconds:02}.{total_milliseconds:03}"
         return formatted_elapsed_time
+
+    @staticmethod
+    def _derive_aggregate_scores(
+        evaluated_result: DataExtractionResult,
+    ) -> tuple[float | None, float | None, float | None]:
+        """Compute ``(entity_score, schema_score, min_extracted_entity_score)``.
+
+        Returns ``(None, None, None)`` when no per-field confidence signal was
+        produced (i.e. ``total_evaluated_fields_count == 0`` or there are no
+        comparison items). This happens, for example, when the LLM call could
+        not return logprobs (reasoning models) and there is no Content
+        Understanding signal to fall back on. Treating that case as "unknown"
+        rather than ``0.0`` lets the API and UI render "N/A" instead of a
+        misleading "0%".
+
+        A genuine zero confidence (e.g. a model that emitted fields but
+        every token had ``logprob == -inf``) is preserved verbatim.
+        """
+        confidence = evaluated_result.confidence or {}
+        total_evaluated_fields_count = confidence.get(
+            "total_evaluated_fields_count", 0
+        )
+        comparison_items = (
+            evaluated_result.comparison_result.items
+            if evaluated_result.comparison_result is not None
+            else []
+        )
+        if total_evaluated_fields_count == 0 or not comparison_items:
+            return (None, None, None)
+
+        zero_count = confidence.get("zero_confidence_fields_count", 0)
+        schema_score = round(
+            (len(comparison_items) - zero_count) / len(comparison_items),
+            3,
+        )
+        entity_score = confidence.get("overall_confidence")
+        min_extracted_entity_score = confidence.get("min_extracted_field_confidence")
+        return (entity_score, schema_score, min_extracted_entity_score)

src/ContentProcessor/tests/unit/pipeline/test_save_handler_scores.py

@@ -0,0 +1,137 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+"""Tests for ``SaveHandler._derive_aggregate_scores``.
+
+Covers the score-availability semantics:
+- valid scores flow through verbatim
+- missing per-field signal yields ``None`` (rendered as "N/A" in the UI)
+- a genuine zero is preserved as ``0`` (rendered as "0%")
+- failed processing (no comparison items) yields ``None``
+"""
+
+from __future__ import annotations
+
+from libs.pipeline.handlers.logics.evaluate_handler.comparison import (
+    ExtractionComparisonData,
+    ExtractionComparisonItem,
+)
+from libs.pipeline.handlers.logics.evaluate_handler.model import DataExtractionResult
+from libs.pipeline.handlers.save_handler import SaveHandler
+
+
+def _make_result(
+    *,
+    items: list[ExtractionComparisonItem],
+    confidence: dict,
+) -> DataExtractionResult:
+    return DataExtractionResult(
+        extracted_result={},
+        confidence=confidence,
+        comparison_result=ExtractionComparisonData(items=items),
+        prompt_tokens=0,
+        completion_tokens=0,
+        execution_time=0,
+    )
+
+
+class TestDeriveAggregateScores:
+    def test_valid_scores_flow_through(self):
+        """A normal evaluate-step result must produce numeric scores."""
+        items = [
+            ExtractionComparisonItem(
+                Field="a", Extracted="x", Confidence="90.00%", IsAboveThreshold="True"
+            ),
+            ExtractionComparisonItem(
+                Field="b", Extracted="y", Confidence="80.00%", IsAboveThreshold="True"
+            ),
+            ExtractionComparisonItem(
+                Field="c", Extracted="z", Confidence="0.00%", IsAboveThreshold="False"
+            ),
+        ]
+        confidence = {
+            "total_evaluated_fields_count": 3,
+            "overall_confidence": 0.567,
+            "min_extracted_field_confidence": 0.0,
+            "zero_confidence_fields_count": 1,
+        }
+        entity, schema, min_score = SaveHandler._derive_aggregate_scores(
+            _make_result(items=items, confidence=confidence)
+        )
+        assert entity == 0.567
+        # 2 of 3 fields above threshold → 0.667
+        assert schema == round(2 / 3, 3)
+        assert min_score == 0.0
+
+    def test_missing_per_field_signal_returns_none(self):
+        """Reasoning-model / image-only flow: no signal → ``None`` everywhere."""
+        items: list[ExtractionComparisonItem] = []
+        confidence = {
+            "total_evaluated_fields_count": 0,
+            "overall_confidence": 0.0,
+            "min_extracted_field_confidence": 0.0,
+            "zero_confidence_fields_count": 0,
+        }
+        entity, schema, min_score = SaveHandler._derive_aggregate_scores(
+            _make_result(items=items, confidence=confidence)
+        )
+        assert entity is None
+        assert schema is None
+        assert min_score is None
+
+    def test_no_comparison_items_returns_none(self):
+        """Even if confidence claims fields exist, an empty comparison list is unknown."""
+        confidence = {
+            "total_evaluated_fields_count": 5,
+            "overall_confidence": 0.9,
+            "min_extracted_field_confidence": 0.5,
+            "zero_confidence_fields_count": 0,
+        }
+        entity, schema, min_score = SaveHandler._derive_aggregate_scores(
+            _make_result(items=[], confidence=confidence)
+        )
+        assert entity is None
+        assert schema is None
+        assert min_score is None
+
+    def test_genuine_zero_score_preserved(self):
+        """A real ``0`` confidence (e.g. all fields below threshold) must NOT become ``None``."""
+        items = [
+            ExtractionComparisonItem(
+                Field="a", Extracted="x", Confidence="0.00%", IsAboveThreshold="False"
+            ),
+        ]
+        confidence = {
+            "total_evaluated_fields_count": 1,
+            "overall_confidence": 0.0,
+            "min_extracted_field_confidence": 0.0,
+            "zero_confidence_fields_count": 1,
+        }
+        entity, schema, min_score = SaveHandler._derive_aggregate_scores(
+            _make_result(items=items, confidence=confidence)
+        )
+        assert entity == 0.0
+        assert schema == 0.0
+        assert min_score == 0.0
+
+    def test_all_fields_above_threshold(self):
+        items = [
+            ExtractionComparisonItem(
+                Field="a", Extracted="x", Confidence="95.00%", IsAboveThreshold="True"
+            ),
+            ExtractionComparisonItem(
+                Field="b", Extracted="y", Confidence="90.00%", IsAboveThreshold="True"
+            ),
+        ]
+        confidence = {
+            "total_evaluated_fields_count": 2,
+            "overall_confidence": 0.925,
+            "min_extracted_field_confidence": 0.9,
+            "zero_confidence_fields_count": 0,
+        }
+        entity, schema, min_score = SaveHandler._derive_aggregate_scores(
+            _make_result(items=items, confidence=confidence)
+        )
+        assert entity == 0.925
+        assert schema == 1.0
+        assert min_score == 0.9

src/ContentProcessorAPI/app/routers/models/contentprocessor/claim_process.py

@@ -53,13 +53,13 @@ class Content_Process(EntityBase):
     mime_type: Optional[str] = Field(
         description="MIME type of the processed content file", default=None
     )
-    entity_score: float = Field(
-        description="Score indicating the quality of entity extraction from the content",
-        default=0.0,
+    entity_score: Optional[float] = Field(
+        description="Score indicating the quality of entity extraction from the content. ``None`` means the score was not available (e.g. logprobs unavailable on reasoning models).",
+        default=None,
     )
-    schema_score: float = Field(
-        description="Score indicating the quality of schema matching for the content",
-        default=0.0,
+    schema_score: Optional[float] = Field(
+        description="Score indicating the quality of schema matching for the content. ``None`` means the score was not available.",
+        default=None,
     )
     status: Optional[str] = Field(
         description="Indicates the current status in the content processing pipeline",

src/ContentProcessorAPI/app/routers/models/contentprocessor/content_process.py

@@ -134,9 +134,9 @@ class ContentProcess(BaseModel):
     )
     last_modified_by: Optional[str] = None
     status: Optional[str] = None
-    entity_score: Optional[float] = 0.0
-    min_extracted_entity_score: Optional[float] = 0.0
-    schema_score: Optional[float] = 0.0
+    entity_score: Optional[float] = None
+    min_extracted_entity_score: Optional[float] = None
+    schema_score: Optional[float] = None
     result: Optional[dict] = None
     confidence: Optional[dict] = None
     target_schema: Optional[Schema] = None

src/ContentProcessorWeb/src/Pages/DefaultPage/Components/ProcessQueueGrid/CustomCellRender.tsx

@@ -29,7 +29,12 @@ interface DeleteItem {
 interface CellRendererExtraProps {
   readonly txt?: string;
   readonly timeString?: string;
-  readonly valueText?: string;
+  /**
+   * Stringified score value. ``undefined`` (or ``null``) means the score is
+   * not available — the percentage renderer will show "N/A" instead of "0%"
+   * to distinguish "unavailable" from a genuine zero.
+   */
+  readonly valueText?: string | null;
   readonly status?: string;
   readonly lastModifiedBy?: string;
   readonly text?: string | number;
@@ -91,9 +96,31 @@ const CellRenderer: React.FC<CellRendererProps> = ({ type, props }) => {
   };
 
   // Render for percentage
-  const renderPercentage = (valueText: string, status: string) => {
+  const renderPercentage = (valueText: string | null | undefined, status: string) => {
+    // ``null``/``undefined``/empty string === score unavailable. Render an
+    // explicit "N/A" so users can distinguish missing scores from a genuine
+    // zero. (Backends emit ``None``/``null`` when, for example, logprobs were
+    // unavailable on a reasoning model and confidence couldn't be computed.)
+    if (valueText === null || valueText === undefined || valueText === '') {
+      return (
+        <div className="percentageContainer" title="Score not available">
+          <span className="textClass">N/A</span>
+        </div>
+      );
+    }
+
     const decimalValue = Number(valueText);
-    if (isNaN(decimalValue) || status !== 'Completed') {
+    if (isNaN(decimalValue)) {
+      return (
+        <div className="percentageContainer" title="Score not available">
+          <span className="textClass">N/A</span>
+        </div>
+      );
+    }
+
+    // Score is numeric (including a genuine 0): only show "..." while the
+    // document is still being processed.
+    if (status !== 'Completed') {
       return <div className="percentageContainer"><span className="textClass">...</span></div>;
     }
 
@@ -124,7 +151,7 @@ const CellRenderer: React.FC<CellRendererProps> = ({ type, props }) => {
   };
 
   // Render for schema score
-  const calculateSchemaScore = (valueText: string, lastModifiedBy: string, status: string) => {
+  const calculateSchemaScore = (valueText: string | null | undefined, lastModifiedBy: string, status: string) => {
     if (lastModifiedBy === 'user') {
       return (
         <div className="percentageContainer">
@@ -186,9 +213,9 @@ const CellRenderer: React.FC<CellRendererProps> = ({ type, props }) => {
     case 'processTime':
       return renderProcessTimeInSeconds(timeString || '');
     case 'percentage':
-      return renderPercentage(valueText || '', status || '');
+      return renderPercentage(valueText, status || '');
     case 'schemaScore':
-      return calculateSchemaScore(valueText || '', lastModifiedBy || '', status || '');
+      return calculateSchemaScore(valueText, lastModifiedBy || '', status || '');
     case 'text':
       return renderText(text ?? '', 'center');
     case 'date':

src/ContentProcessorWeb/src/Pages/DefaultPage/Components/ProcessQueueGrid/ProcessQueueGrid.tsx

@@ -373,7 +373,11 @@ const ProcessQueueGrid: React.FC<GridComponentProps> = () => {
                                                         <CustomCellRender
                                                             type="percentage"
                                                             props={{
-                                                                valueText: doc.entity_score.toString(),
+                                                                valueText:
+                                                                    doc.entity_score === null ||
+                                                                    doc.entity_score === undefined
+                                                                        ? undefined
+                                                                        : doc.entity_score.toString(),
                                                                 status: doc.status,
                                                             }}
                                                         />
@@ -382,7 +386,11 @@ const ProcessQueueGrid: React.FC<GridComponentProps> = () => {
                                                         <CustomCellRender
                                                             type="percentage"
                                                             props={{
-                                                                valueText: doc.schema_score.toString(),
+                                                                valueText:
+                                                                    doc.schema_score === null ||
+                                                                    doc.schema_score === undefined
+                                                                        ? undefined
+                                                                        : doc.schema_score.toString(),
                                                                 status: doc.status,
                                                             }}
                                                         />

src/ContentProcessorWeb/src/Pages/DefaultPage/Components/ProcessQueueGrid/ProcessQueueGridTypes.ts

@@ -17,10 +17,23 @@ export interface ProcessedDocument {
     readonly file_name: string;
     /** MIME type of the document. */
     readonly mime_type: string;
-    /** Entity extraction confidence score (0–1). */
-    readonly entity_score: number;
-    /** Schema compliance score (0–1). */
-    readonly schema_score: number;
+    /**
+     * Entity extraction confidence score in the range 0–1.
+     *
+     * ``null``/``undefined`` means the score was not produced by the backend
+     * (for example: logprobs were unavailable on a reasoning model, or the
+     * pipeline didn't reach the evaluate step). In that case the UI shows
+     * "N/A" rather than a misleading "0%". A genuine numeric ``0`` is still
+     * rendered as ``0%``.
+     */
+    readonly entity_score: number | null | undefined;
+    /**
+     * Schema compliance score in the range 0–1.
+     *
+     * ``null``/``undefined`` means the score was not produced. See
+     * {@link entity_score} for rendering semantics.
+     */
+    readonly schema_score: number | null | undefined;
     /** Current processing status. */
     readonly status: string;
     /** Duration string for processing time (HH:MM:SS). */