Make module-stage LLM handling resilient and report warnings

internal/framework/proposal_generation/generate.go

@@ -15,6 +15,7 @@ import (
 	"gitea.maximumdirect.net/eric/audita/internal/framework/llm"
 	"gitea.maximumdirect.net/eric/audita/internal/framework/proposals"
 	"gitea.maximumdirect.net/eric/audita/internal/framework/responseschema"
+	stagewarnings "gitea.maximumdirect.net/eric/audita/internal/framework/warnings"
 )
 
 // InteractionDiagnosticsWriter writes machine-readable prompt/response artifacts.
@@ -68,6 +69,7 @@ type Request struct {
 type Result struct {
 	Corrections []proposals.CorrectionProposal         `json:"corrections"`
 	Enriched    []proposals.EnrichedCorrectionProposal `json:"enriched"`
+	Warnings    []stagewarnings.StageWarning           `json:"warnings,omitempty"`
 	Artifacts   InteractionArtifacts                   `json:"artifacts,omitempty"`
 }
 
@@ -156,6 +158,12 @@ func GenerateCandidates(ctx context.Context, req Request) (Result, error) {
 	}
 
 	if callErr != nil {
+		if isMalformedStructuredOutputError(callErr) {
+			return Result{
+				Warnings:  []stagewarnings.StageWarning{newMalformedProposalWarning(req.Section, artifacts, callErr)},
+				Artifacts: artifacts,
+			}, nil
+		}
 		return Result{}, fmt.Errorf("proposal generation completion failed: %w", callErr)
 	}
 
@@ -168,9 +176,6 @@ func GenerateCandidates(ctx context.Context, req Request) (Result, error) {
 			CorrectedText:   raw.CorrectedText,
 			Confidence:      raw.Confidence,
 		}
-		if err := candidate.Validate(); err != nil {
-			return Result{}, fmt.Errorf("invalid structured correction at index %d: %w", i, err)
-		}
 
 		corrections = append(corrections, candidate)
 		enrichedCandidate := proposals.EnrichedCorrectionProposal{
@@ -191,6 +196,7 @@ func GenerateCandidates(ctx context.Context, req Request) (Result, error) {
 	return Result{
 		Corrections: corrections,
 		Enriched:    enriched,
+		Warnings:    nil,
 		Artifacts:   artifacts,
 	}, nil
 }
@@ -240,6 +246,48 @@ func errPayload(err error) any {
 	return map[string]any{"error": err.Error()}
 }
 
+func isMalformedStructuredOutputError(err error) bool {
+	if err == nil {
+		return false
+	}
+	msg := err.Error()
+	for _, marker := range []string{
+		"malformed structured output",
+		"decode structured output:",
+		"decode provider response envelope:",
+		"provider response missing choices",
+		"provider response missing assistant message content",
+		"provider response assistant message content is empty",
+		"provider response assistant message content is not valid JSON",
+	} {
+		if strings.Contains(msg, marker) {
+			return true
+		}
+	}
+	return false
+}
+
+func newMalformedProposalWarning(section *contracts.SectionMetadata, artifacts InteractionArtifacts, err error) stagewarnings.StageWarning {
+	warning := stagewarnings.StageWarning{
+		Scope:                  stagewarnings.ScopeProposalGeneration,
+		ReasonCode:             "proposal_response_malformed",
+		Message:                strings.TrimSpace(err.Error()),
+		DiagnosticArtifactPath: diagnosticArtifactPath(artifacts),
+	}
+	if section != nil {
+		sectionIndex := section.Index
+		warning.SectionIndex = &sectionIndex
+	}
+	return warning
+}
+
+func diagnosticArtifactPath(artifacts InteractionArtifacts) string {
+	if artifacts.ErrorPayloadPath != "" {
+		return artifacts.ErrorPayloadPath
+	}
+	return artifacts.ResponsePayloadPath
+}
+
 type diagnosticsWriterAdapter struct {
 	writer *llm.DiagnosticsWriter
 }

internal/framework/proposal_generation/generate_test.go

@@ -224,12 +224,12 @@ func TestGenerateCandidatesDiagnosticsIncludeSchemaMetadata(t *testing.T) {
 	}
 }
 
-func TestGenerateCandidatesMalformedStructuredResponse(t *testing.T) {
+func TestGenerateCandidatesInvalidCorrectionIsPreservedForLaterValidation(t *testing.T) {
 	client := &fakeStructuredClient{
 		responses: []StructuredCorrectionSet{
 			{
 				Corrections: []StructuredCorrectionProposal{
-					{TargetSegmentID: 1, OriginalText: "x", CorrectedText: "", Confidence: 0.9},
+					{TargetSegmentID: 0, OriginalText: "x", CorrectedText: "", Confidence: 1.2},
 				},
 			},
 		},
@@ -237,9 +237,38 @@ func TestGenerateCandidatesMalformedStructuredResponse(t *testing.T) {
 	req := defaultRequest(t)
 	req.LLMClient = client
 
-	_, err := GenerateCandidates(context.Background(), req)
-	if err == nil || !strings.Contains(err.Error(), "invalid structured correction") {
-		t.Fatalf("expected structured response validation failure, got %v", err)
+	result, err := GenerateCandidates(context.Background(), req)
+	if err != nil {
+		t.Fatalf("expected invalid correction to survive generation, got %v", err)
+	}
+	if len(result.Corrections) != 1 {
+		t.Fatalf("expected one correction, got %+v", result)
+	}
+	if result.Corrections[0].TargetSegmentID != 0 || result.Corrections[0].Confidence != 1.2 {
+		t.Fatalf("unexpected preserved correction: %+v", result.Corrections[0])
+	}
+	if len(result.Warnings) != 0 {
+		t.Fatalf("did not expect warnings for individually invalid corrections, got %+v", result.Warnings)
+	}
+}
+
+func TestGenerateCandidatesMalformedStructuredOutputReturnsWarning(t *testing.T) {
+	client := &fakeStructuredClient{err: errors.New("malformed structured output")}
+	req := defaultRequest(t)
+	req.LLMClient = client
+
+	result, err := GenerateCandidates(context.Background(), req)
+	if err != nil {
+		t.Fatalf("expected malformed structured output to downgrade to warning, got %v", err)
+	}
+	if len(result.Corrections) != 0 || len(result.Enriched) != 0 {
+		t.Fatalf("expected no proposals on malformed response, got %+v", result)
+	}
+	if len(result.Warnings) != 1 {
+		t.Fatalf("expected one warning, got %+v", result.Warnings)
+	}
+	if result.Warnings[0].ReasonCode != "proposal_response_malformed" {
+		t.Fatalf("unexpected warning: %+v", result.Warnings[0])
 	}
 }