大模型自纠错实战：反馈、验证循环与回归控制

package main

import (
	"context"
	"fmt"
	"math"
	"time"
)

type Source struct {
	Currency string
	Subtotal int64
	Tax      int64
}

type Draft struct {
	Currency string
	Total    int64
}

type Check struct {
	Name string
	Pass bool
}

type Outcome struct {
	Draft     Draft
	Checks    []Check
	Accepted  bool
	Revisions int
	Rejected  int
	Stop      string
}

type Repair func(context.Context, Draft, []string) (Draft, error)

func assess(ctx context.Context, source Source, draft Draft) ([]Check, error) {
	if err := ctx.Err(); err != nil {
		return nil, err
	}
	if source.Currency == "" || source.Subtotal < 0 || source.Tax < 0 ||
		source.Subtotal > math.MaxInt64-source.Tax {
		return nil, fmt.Errorf("invalid source")
	}
	return []Check{
		{"currency_matches_source", draft.Currency == source.Currency},
		{"total_nonnegative", draft.Total >= 0},
		{"total_matches_source", draft.Total == source.Subtotal+source.Tax},
	}, nil
}

func failures(checks []Check) []string {
	var names []string
	for _, check := range checks {
		if !check.Pass {
			names = append(names, check.Name)
		}
	}
	return names
}

func improves(previous, next []Check) bool {
	if len(previous) != len(next) {
		return false
	}
	gained := false
	for i, check := range previous {
		if check.Name != next[i].Name || check.Pass && !next[i].Pass {
			return false
		}
		gained = gained || !check.Pass && next[i].Pass
	}
	return gained
}

func revise(ctx context.Context, source Source, initial Draft, limit int, repair Repair) (Outcome, error) {
	result := Outcome{Draft: initial}
	if limit < 0 || repair == nil {
		return result, fmt.Errorf("invalid configuration")
	}
	checks, err := assess(ctx, source, initial)
	if err != nil {
		return result, err
	}
	result.Checks = checks
	seen := map[Draft]bool{initial: true}
	for {
		if err := ctx.Err(); err != nil {
			return result, err
		}
		failed := failures(result.Checks)
		if len(failed) == 0 {
			result.Accepted, result.Stop = true, "checks_passed"
			return result, nil
		}
		if result.Revisions == limit {
			result.Stop = "revision_limit"
			return result, nil
		}
		result.Revisions++
		next, err := repair(ctx, result.Draft, failed)
		if err != nil {
			return result, fmt.Errorf("repair failed: %w", err)
		}
		nextChecks, err := assess(ctx, source, next)
		if err != nil {
			return result, err
		}
		if seen[next] {
			result.Stop = "repeated_candidate"
			return result, nil
		}
		seen[next] = true
		if !improves(result.Checks, nextChecks) {
			result.Rejected++
			continue
		}
		result.Draft, result.Checks = next, nextChecks
	}
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
	defer cancel()
	source := Source{"CNY", 10000, 800}
	proposals := []Draft{{"USD", 10800}, {"CNY", 10800}}
	index := 0
	repair := func(ctx context.Context, current Draft, failed []string) (Draft, error) {
		if err := ctx.Err(); err != nil {
			return Draft{}, err
		}
		if len(failed) == 0 || index >= len(proposals) {
			return Draft{}, fmt.Errorf("no scripted repair")
		}
		next := proposals[index]
		index++
		return next, nil
	}
	result, err := revise(ctx, source, Draft{"CNY", 10700}, 2, repair)
	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Printf("accepted=%t revisions=%d rejected=%d currency=%s total=%d stop=%s\n",
		result.Accepted, result.Revisions, result.Rejected,
		result.Draft.Currency, result.Draft.Total, result.Stop)
}

accepted=true revisions=2 rejected=1 currency=CNY total=10800 stop=checks_passed