Tutorial D4: Structured Outputs & Schema Design for Industrial Agents

from enum import Enum
from pydantic import BaseModel, Field

# --- D3's flat schema (unchanged from Tutorial D3 Cell 3) ---
class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class FaultDiagnosis(BaseModel):
    alarm_code: str = Field(description="The alarm code being analysed")
    severity: Severity = Field(description="Classified severity level")
    root_cause: str = Field(description="One-sentence root cause explanation")
    affected_tags: list[str] = Field(description="PLC tags that support the diagnosis")
    recommended_action: str = Field(description="Advisory action — no PLC writes")
    confidence: float = Field(description="Confidence score 0.0-1.0", ge=0.0, le=1.0)

# --- Try to represent a 3-alarm scenario ---
# Filling Line 3, last hour:
#   E-421 overtemp at 02:10 (MotorTemp=92°C)
#   E-419 overcurrent at 01:55 (LoadCurrent=18A, rated 15A)
#   E-422 vibration at 02:15 (BearingVib=4.2mm/s, threshold 3.5)

diagnosis = FaultDiagnosis(
    alarm_code="E-421",  # Only ONE alarm code fits — E-419 and E-422 are lost
    severity=Severity.HIGH,
    root_cause="Motor overtemperature caused by sustained overcurrent and bearing degradation",
    affected_tags=["MotorTemp", "LoadCurrent", "BearingVib", "AmbientTemp"],
    # Which tags belong to which alarm? No way to tell.
    # What are the actual values? Lost.
    # When did each reading occur? Lost.
    recommended_action="Inspect motor bearings and ventilation; reduce line throughput",
    # Should the line shut down? No field for that.
    # What priority? No field for that.
    confidence=0.82,
)

print(f"Alarm code : {diagnosis.alarm_code}")
print(f"  → But E-419 and E-422 are lost — only one alarm_code field")
print(f"\nAffected tags: {diagnosis.affected_tags}")
print(f"  → No association: which tag belongs to which alarm?")
print(f"  → No values: MotorTemp was 92°C but we only stored the name")
print(f"\nRoot cause: {diagnosis.root_cause}")
print(f"  → One sentence for a 3-alarm correlation — not enough structure")
print(f"\nRecommended action: {diagnosis.recommended_action}")
print(f"  → No shutdown flag, no priority, no estimated downtime")

from enum import Enum
from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os

# --- Same schema as D3 ---
class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class FaultDiagnosis(BaseModel):
    alarm_code: str = Field(description="The alarm code being analysed")
    severity: Severity = Field(description="Classified severity level")
    root_cause: str = Field(description="One-sentence root cause explanation")
    affected_tags: list[str] = Field(description="PLC tags that support the diagnosis")
    recommended_action: str = Field(description="Advisory action — no PLC writes")
    confidence: float = Field(description="Confidence score 0.0-1.0", ge=0.0, le=1.0)

# --- with_structured_output() replaces PydanticOutputParser ---
# No parser object. No format_instructions. No .partial().
llm = ChatOpenAI(
    model="gpt-4o-mini",
    temperature=0,
    api_key=os.environ["OPENAI_API_KEY"],
)

# This creates a new Runnable that returns a FaultDiagnosis directly
structured_llm = llm.with_structured_output(FaultDiagnosis)

# --- Prompt (no {format_instructions} needed) ---
prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an industrial fault-triage assistant. Advisory only."),
    ("human", (
        "Alarm E-421 on Filling Line 3.\n"
        "Tags: MotorTemp=92°C, LoadCurrent=18A (rated 15A), AmbientTemp=28°C.\n"
        "Prior alarms last hour: E-419 overcurrent at 01:50, E-421 overtemp at 01:55."
    )),
])

# --- Chain with | pipe (same composability as D3) ---
chain = prompt | structured_llm

# --- Invoke ---
diagnosis = chain.invoke({})

# diagnosis is a FaultDiagnosis instance — not a string, not raw JSON
print(f"Type   : {type(diagnosis).__name__}")
print(f"Alarm  : {diagnosis.alarm_code}")
print(f"Severity: {diagnosis.severity.value}")
print(f"Root cause: {diagnosis.root_cause}")
print(f"Confidence: {diagnosis.confidence:.0%}")

# Compare to D3:
# D3: parser = PydanticOutputParser(pydantic_object=FaultDiagnosis)
#     prompt = ...partial(format_instructions=parser.get_format_instructions())
#     chain = prompt | llm | parser
# D4: structured_llm = llm.with_structured_output(FaultDiagnosis)
#     chain = prompt | structured_llm
# → No parser, no format_instructions, same typed result

from enum import Enum
from pydantic import BaseModel, Field
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os

# --- Sub-models: each represents one logical entity ---

class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class AlarmEvent(BaseModel):
    """A single alarm occurrence with timestamp and severity."""
    alarm_code: str = Field(description="Alarm code, e.g. E-421")
    timestamp: str = Field(description="When the alarm fired, e.g. 02:10")
    severity: Severity = Field(description="Classified severity")
    description: str = Field(description="One-line description of the alarm")

class TagReading(BaseModel):
    """A single PLC tag reading from a specific source."""
    tag_name: str = Field(description="Tag name, e.g. MotorTemp")
    value: float = Field(description="Numeric value at time of reading")
    unit: str = Field(description="Engineering unit, e.g. °C, A, mm/s")
    source: str = Field(description="Data source, e.g. OPC UA, historian")

class DiagnosisResult(BaseModel):
    """Structured diagnosis with evidence and confidence."""
    root_cause: str = Field(description="Primary root cause explanation")
    contributing_factors: list[str] = Field(description="Secondary factors")
    confidence: float = Field(description="Confidence 0.0-1.0", ge=0.0, le=1.0)
    evidence: list[str] = Field(description="Specific evidence supporting the diagnosis")

class RecommendedAction(BaseModel):
    """Structured recommendation with priority and shutdown flag."""
    action: str = Field(description="Advisory action for the engineer")
    priority: Severity = Field(description="Action priority")
    requires_shutdown: bool = Field(description="Whether line shutdown is recommended")
    estimated_downtime_min: int | None = Field(
        default=None, description="Estimated downtime in minutes if shutdown required"
    )

# --- Composed top-level model ---
class FaultReport(BaseModel):
    """Complete fault report composing all sub-models."""
    line_id: str = Field(description="Production line identifier")
    alarms: list[AlarmEvent] = Field(description="All alarm events in the analysis window")
    tag_readings: list[TagReading] = Field(description="Relevant PLC tag readings")
    diagnosis: DiagnosisResult = Field(description="Structured diagnosis")
    recommendation: RecommendedAction = Field(description="Advisory recommendation")

# --- Extract with with_structured_output() ---
llm = ChatOpenAI(
    model="gpt-4o-mini", temperature=0, api_key=os.environ["OPENAI_API_KEY"]
)
structured_llm = llm.with_structured_output(FaultReport)

prompt = ChatPromptTemplate.from_messages([
    ("system", (
        "You are an industrial fault-triage assistant. Advisory only. "
        "Analyse all alarms and tags to produce a complete FaultReport."
    )),
    ("human", (
        "Filling Line 3, last hour summary:\n"
        "Alarms:\n"
        "  E-419 overcurrent at 01:55 (LoadCurrent=18A, rated 15A)\n"
        "  E-421 overtemperature at 02:10 (MotorTemp=92°C)\n"
        "  E-422 vibration at 02:15 (BearingVib=4.2mm/s, threshold 3.5)\n"
        "Tag readings:\n"
        "  MotorTemp=92°C (OPC UA), LoadCurrent=18A (OPC UA),\n"
        "  AmbientTemp=28°C (historian), BearingVib=4.2mm/s (historian)"
    )),
])

chain = prompt | structured_llm
report = chain.invoke({})

# --- Access nested data ---
print(f"Line: {report.line_id}")
print(f"\nAlarms ({len(report.alarms)}):")
for a in report.alarms:
    print(f"  {a.alarm_code} [{a.severity.value}] at {a.timestamp}: {a.description}")
print(f"\nTag readings ({len(report.tag_readings)}):")
for t in report.tag_readings:
    print(f"  {t.tag_name} = {t.value} {t.unit} (source: {t.source})")
print(f"\nDiagnosis:")
print(f"  Root cause: {report.diagnosis.root_cause}")
print(f"  Confidence: {report.diagnosis.confidence:.0%}")
print(f"  Evidence: {report.diagnosis.evidence}")
print(f"\nRecommendation:")
print(f"  Action: {report.recommendation.action}")
print(f"  Priority: {report.recommendation.priority.value}")
print(f"  Requires shutdown: {report.recommendation.requires_shutdown}")

# Assume 'report' is the FaultReport from Cell 3

# --- 1. Filter alarms by severity ---
critical_alarms = [a for a in report.alarms if a.severity.value == "CRITICAL"]
high_alarms = [a for a in report.alarms if a.severity.value == "HIGH"]
print(f"Critical alarms: {len(critical_alarms)}")
print(f"High alarms: {len(high_alarms)}")

# --- 2. Check if any tag exceeds a physical threshold ---
motor_overtemp = any(
    t.value > 85.0
    for t in report.tag_readings
    if t.tag_name == "MotorTemp"
)
print(f"\nMotor over 85°C: {motor_overtemp}")

bearing_alert = any(
    t.value > 3.5
    for t in report.tag_readings
    if t.tag_name == "BearingVib"
)
print(f"Bearing above threshold: {bearing_alert}")

# --- 3. Route based on recommendation ---
if report.recommendation.requires_shutdown:
    print(f"\n⚠️  LINE SHUTDOWN RECOMMENDED")
    print(f"   Estimated downtime: {report.recommendation.estimated_downtime_min} min")
else:
    print(f"\n✅ No shutdown required — continue with monitoring")
    print(f"   Priority: {report.recommendation.priority.value}")

# --- 4. Build an audit trail entry ---
severity_rank = {
    "LOW": 1,
    "MEDIUM": 2,
    "HIGH": 3,
    "CRITICAL": 4,
}

max_severity = max(report.alarms, key=lambda a: severity_rank[a.severity.value]).severity.value

audit_entry = {
    "line": report.line_id,
    "alarm_codes": [a.alarm_code for a in report.alarms],
    "max_severity": max_severity,
    "diagnosis_confidence": report.diagnosis.confidence,
    "shutdown_recommended": report.recommendation.requires_shutdown,
    "evidence_count": len(report.diagnosis.evidence),
}
print(f"\nAudit entry: {audit_entry}")

from pydantic import BaseModel, Field, ValidationError
from dataclasses import dataclass
from typing import TypedDict

# --- 1. BaseModel: validates at construction ---
class AlarmEventModel(BaseModel):
    alarm_code: str = Field(description="Alarm code")
    severity: str = Field(description="CRITICAL | HIGH | MEDIUM | LOW")
    temperature: float = Field(ge=-40, le=200, description="Motor temp °C")

# Valid data
alarm_bm = AlarmEventModel(alarm_code="E-421", severity="HIGH", temperature=92.0)
print(f"BaseModel   : {alarm_bm}")

# Invalid data — catches the error at construction
try:
    bad = AlarmEventModel(alarm_code="E-421", severity="HIGH", temperature=500.0)
except ValidationError as e:
    print(f"BaseModel   : ❌ Validation error — {e.errors()[0]['msg']}")

# JSON Schema (used by with_structured_output())
schema = AlarmEventModel.model_json_schema()
print(f"JSON Schema : {list(schema['properties'].keys())}")

# --- 2. @dataclass: no validation ---
@dataclass
class AlarmEventDC:
    alarm_code: str
    severity: str
    temperature: float

alarm_dc = AlarmEventDC(alarm_code="E-421", severity="HIGH", temperature=500.0)
print(f"\ndataclass   : {alarm_dc}")
print(f"dataclass   : ⚠️ temperature=500 accepted silently (no validation)")

# --- 3. TypedDict: no runtime behavior ---
class AlarmEventTD(TypedDict):
    alarm_code: str
    severity: str
    temperature: float

alarm_td: AlarmEventTD = {
    "alarm_code": "E-421",
    "severity": "HIGH",
    "temperature": 500.0,
}
print(f"\nTypedDict   : {alarm_td}")
print(f"TypedDict   : ⚠️ Just a dict — no validation, no methods")
print(f"TypedDict   : ✅ But this is what LangGraph uses for state")

import re
from enum import Enum
from pydantic import BaseModel, Field, field_validator, ValidationError

class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class AlarmEvent(BaseModel):
    alarm_code: str = Field(description="Alarm code, e.g. E-421")
    timestamp: str = Field(description="When the alarm fired")
    severity: Severity
    description: str

    @field_validator("alarm_code")
    @classmethod
    def validate_alarm_code(cls, v: str) -> str:
        """Alarm codes must match E-NNN format."""
        if not re.match(r"^E-\d{3}$", v):
            raise ValueError(f"Invalid alarm code format: '{v}'. Expected E-NNN (e.g. E-421)")
        return v

class TagReading(BaseModel):
    tag_name: str
    value: float = Field(ge=-40, le=500, description="Physical range: -40 to 500")
    unit: str
    source: str

class DiagnosisResult(BaseModel):
    root_cause: str
    contributing_factors: list[str] = Field(default_factory=list)
    confidence: float = Field(ge=0.0, le=1.0, description="Must be 0.0 to 1.0")
    evidence: list[str] = Field(min_length=1, description="At least one evidence item")

class RecommendedAction(BaseModel):
    action: str
    priority: Severity
    requires_shutdown: bool
    estimated_downtime_min: int | None = Field(
        default=None, ge=0, description="Non-negative minutes"
    )

# --- Test the validators with bad data ---
print("=== Testing validators ===\n")

# 1. Bad alarm code format
try:
    AlarmEvent(alarm_code="ALARM421", timestamp="02:10",
               severity=Severity.HIGH, description="test")
except ValidationError as e:
    print(f"❌ Alarm code: {e.errors()[0]['msg']}")

# 2. Temperature out of physical range
try:
    TagReading(tag_name="MotorTemp", value=5000.0, unit="°C", source="OPC UA")
except ValidationError as e:
    print(f"❌ Temperature: {e.errors()[0]['msg']}")

# 3. Confidence out of range
try:
    DiagnosisResult(
        root_cause="test", confidence=1.5,
        evidence=["some evidence"]
    )
except ValidationError as e:
    print(f"❌ Confidence: {e.errors()[0]['msg']}")

# 4. Negative downtime
try:
    RecommendedAction(
        action="test", priority=Severity.HIGH,
        requires_shutdown=True, estimated_downtime_min=-30
    )
except ValidationError as e:
    print(f"❌ Downtime: {e.errors()[0]['msg']}")

# 5. Empty evidence list
try:
    DiagnosisResult(root_cause="test", confidence=0.8, evidence=[])
except ValidationError as e:
    print(f"❌ Evidence: {e.errors()[0]['msg']}")

print("\n=== All validators working ===")

from enum import Enum
from pydantic import BaseModel, Field, ValidationError, field_validator
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os
import logging
import re

logging.basicConfig(level=logging.WARNING)
logger = logging.getLogger("fault_pipeline")

# Minimal self-contained schema setup for this cell
class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class AlarmEvent(BaseModel):
    alarm_code: str
    timestamp: str
    severity: Severity
    description: str

    @field_validator("alarm_code")
    @classmethod
    def validate_alarm_code(cls, v: str) -> str:
        if not re.match(r"^E-\d{3}$", v):
            raise ValueError(f"Invalid alarm code format: '{v}'. Expected E-NNN (e.g. E-421)")
        return v

class TagReading(BaseModel):
    tag_name: str
    value: float = Field(ge=-40, le=500)
    unit: str
    source: str

class DiagnosisResult(BaseModel):
    root_cause: str
    contributing_factors: list[str] = Field(default_factory=list)
    confidence: float = Field(ge=0.0, le=1.0)
    evidence: list[str] = Field(min_length=1)

class RecommendedAction(BaseModel):
    action: str
    priority: Severity
    requires_shutdown: bool
    estimated_downtime_min: int | None = Field(default=None, ge=0)

class FaultReport(BaseModel):
    line_id: str
    alarms: list[AlarmEvent]
    tag_readings: list[TagReading]
    diagnosis: DiagnosisResult
    recommendation: RecommendedAction

llm = ChatOpenAI(
    model="gpt-4o-mini", temperature=0, api_key=os.environ["OPENAI_API_KEY"]
)
structured_llm = llm.with_structured_output(FaultReport)

prompt = ChatPromptTemplate.from_messages([
    ("system", (
        "You are an industrial fault-triage assistant. Advisory only. "
        "Analyse all alarms and tags to produce a complete FaultReport."
    )),
    ("human", "{alarm_context}"),
])

chain = prompt | structured_llm

def safe_extract(alarm_context: str, max_retries: int = 2) -> FaultReport | None:
    """Extract a FaultReport with validation error handling and retry."""
    for attempt in range(max_retries + 1):
        try:
            report = chain.invoke({"alarm_context": alarm_context})
            # with_structured_output() returns a validated Pydantic instance
            # If we get here, validation passed
            return report

        except ValidationError as e:
            logger.warning(
                f"Attempt {attempt + 1}: Validation failed — "
                f"{len(e.errors())} error(s): {e.errors()[0]['msg']}"
            )
            if attempt == max_retries:
                logger.error("All retries exhausted. Returning None.")
                return None
            # Blind retries are not enough for persistent schema failures.
            # In production, prefer changing the prompt, relaxing/fixing the
            # schema, or switching to a fallback model/extractor.

        except Exception as e:
            logger.error(f"Unexpected error: {e}")
            return None

# --- Use the safe extractor ---
context = (
    "Filling Line 3, last hour:\n"
    "E-419 overcurrent at 01:55, E-421 overtemp at 02:10.\n"
    "Tags: MotorTemp=92°C, LoadCurrent=18A."
)

report = safe_extract(context)
if report:
    print(f"✅ Extraction successful: {len(report.alarms)} alarms, "
          f"confidence {report.diagnosis.confidence:.0%}")
else:
    print("❌ Extraction failed after retries — log and escalate")

from typing import TypedDict

# Assume FaultReport and sub-models defined as in Cells 3/6

# --- D5 preview: AgentState as TypedDict ---
# LangGraph state uses TypedDict because nodes need dict-like access:
#   state["report"], state["status"], etc.

class DiagnosisAgentState(TypedDict):
    """Shared state for a fault diagnosis graph (D5 preview)."""
    line_id: str                        # Which production line
    alarm_context: str                  # Raw alarm text from shift
    report: FaultReport | None          # ← Your D4 schema becomes a state field
    status: str                         # "pending" | "triaged" | "diagnosed" | "reported"
    node_history: list[str]             # Audit trail of which nodes ran

# --- What a node function looks like (preview) ---
# In D5, each node reads state and returns a partial update

def triage_node(state: DiagnosisAgentState) -> dict:
    """Triage node: extract a FaultReport from alarm context."""
    # In D5, this will use with_structured_output(FaultReport)
    # to populate state["report"]
    return {
        "report": "... FaultReport instance from with_structured_output() ...",
        "status": "triaged",
        "node_history": state["node_history"] + ["triage_node"],
    }

# --- The connection ---
print("DiagnosisAgentState fields:")
for field, type_hint in DiagnosisAgentState.__annotations__.items():
    print(f"  {field}: {type_hint}")

print("\nThe 'report' field is your FaultReport from D4.")
print("The triage_node populates it using with_structured_output().")
print("Other nodes (diagnosis, report) read and extend it.")
print("\n→ Full implementation in D5: LangGraph Fundamentals (StateGraph)")

from pydantic import BaseModel, Field, ConfigDict, ValidationError

# --- Version 1.0: original FaultReport ---
class FaultReportV1(BaseModel):
    model_config = ConfigDict(extra="ignore")  # Forward-compatible: ignore unknown fields

    schema_version: str = "1.0"
    line_id: str
    root_cause: str
    confidence: float = Field(ge=0.0, le=1.0)

# --- Version 1.1: add an OPTIONAL field (backward-compatible) ---
class FaultReportV1_1(BaseModel):
    model_config = ConfigDict(extra="ignore")

    schema_version: str = "1.1"
    line_id: str
    root_cause: str
    confidence: float = Field(ge=0.0, le=1.0)
    operator_notes: str | None = None  # ← Optional: old data still validates

# --- Test backward compatibility ---
old_data = {
    "schema_version": "1.0",
    "line_id": "Filling Line 3",
    "root_cause": "Motor overtemperature from sustained overcurrent",
    "confidence": 0.82,
}

# V1.0 data validates against V1.1 schema (operator_notes defaults to None)
report = FaultReportV1_1(**old_data)
print(f"V1.0 data → V1.1 schema: ✅ (operator_notes={report.operator_notes})")

# --- Version 2.0: add a REQUIRED field (breaking change) ---
class FaultReportV2(BaseModel):
    schema_version: str = "2.0"
    line_id: str
    root_cause: str
    confidence: float = Field(ge=0.0, le=1.0)
    shift_id: str  # ← Required: old data will fail validation

try:
    FaultReportV2(**old_data)
except ValidationError as e:
    print(f"V1.0 data → V2.0 schema: ❌ {e.errors()[0]['msg']}")

print("\nRule: optional fields with defaults are safe additions.")
print("Required fields without defaults are breaking changes.")

import re
from enum import Enum
from pydantic import BaseModel, Field, field_validator, ValidationError
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
import os

# --- Complete validated schema (Sections 3 + 5 combined) ---
class Severity(str, Enum):
    CRITICAL = "CRITICAL"
    HIGH = "HIGH"
    MEDIUM = "MEDIUM"
    LOW = "LOW"

class AlarmEvent(BaseModel):
    alarm_code: str = Field(description="Alarm code, e.g. E-421")
    timestamp: str = Field(description="When the alarm fired")
    severity: Severity
    description: str

    @field_validator("alarm_code")
    @classmethod
    def validate_alarm_code(cls, v: str) -> str:
        if not re.match(r"^E-\d{3}$", v):
            raise ValueError(f"Invalid alarm code: '{v}'. Expected E-NNN")
        return v

class TagReading(BaseModel):
    tag_name: str
    value: float = Field(ge=-40, le=500)
    unit: str
    source: str

class DiagnosisResult(BaseModel):
    root_cause: str
    contributing_factors: list[str] = Field(default_factory=list)
    confidence: float = Field(ge=0.0, le=1.0)
    evidence: list[str] = Field(min_length=1)

class RecommendedAction(BaseModel):
    action: str
    priority: Severity
    requires_shutdown: bool
    estimated_downtime_min: int | None = Field(default=None, ge=0)

class FaultReport(BaseModel):
    line_id: str
    alarms: list[AlarmEvent]
    tag_readings: list[TagReading]
    diagnosis: DiagnosisResult
    recommendation: RecommendedAction

# --- Pipeline ---
llm = ChatOpenAI(
    model="gpt-4o-mini", temperature=0, api_key=os.environ["OPENAI_API_KEY"]
)
structured_llm = llm.with_structured_output(FaultReport)

prompt = ChatPromptTemplate.from_messages([
    ("system", (
        "You are an industrial fault-triage assistant. Advisory only. "
        "Analyse all alarms and tags to produce a complete FaultReport."
    )),
    ("human", "{alarm_context}"),
])

chain = prompt | structured_llm

# --- Extract with error handling ---
alarm_context = (
    "Filling Line 3, last hour:\n"
    "Alarms:\n"
    "  E-419 overcurrent at 01:55 (LoadCurrent=18A, rated 15A)\n"
    "  E-421 overtemperature at 02:10 (MotorTemp=92°C)\n"
    "  E-422 vibration at 02:15 (BearingVib=4.2mm/s, threshold 3.5)\n"
    "Tags: MotorTemp=92°C, LoadCurrent=18A, AmbientTemp=28°C, BearingVib=4.2mm/s"
)

try:
    report = chain.invoke({"alarm_context": alarm_context})

    # --- Summary using nested access ---
    print(f"{'='*50}")
    print(f"FAULT REPORT — {report.line_id}")
    print(f"{'='*50}")
    print(f"\nAlarms ({len(report.alarms)}):")
    for a in report.alarms:
        print(f"  [{a.severity.value:>8}] {a.alarm_code} at {a.timestamp}")
    print(f"\nTag readings ({len(report.tag_readings)}):")
    for t in report.tag_readings:
        print(f"  {t.tag_name:>15} = {t.value:>6.1f} {t.unit}")
    print(f"\nDiagnosis (confidence: {report.diagnosis.confidence:.0%}):")
    print(f"  {report.diagnosis.root_cause}")
    print(f"  Evidence: {len(report.diagnosis.evidence)} items")
    print(f"\nRecommendation [{report.recommendation.priority.value}]:")
    print(f"  {report.recommendation.action}")
    print(f"  Shutdown: {'YES' if report.recommendation.requires_shutdown else 'No'}")
    print(f"\n{'='*50}")
    print(f"✅ Schema validated. Ready for D5 StateGraph.")

except ValidationError as e:
    print(f"❌ Validation failed: {len(e.errors())} error(s)")
    for err in e.errors():
        print(f"   {err['loc']}: {err['msg']}")
except Exception as e:
    print(f"❌ Pipeline error: {e}")