两个工具都返回 amount，为什么助手把支出加错了？

"""Two fictional read-only tool contracts; no API, FX, floats or real payments.

All fixture rows describe distinct settled expenses in one declared scope.
Source contract IDs are attached by the host, not inferred from payload text.
"""
from copy import deepcopy
from dataclasses import asdict, dataclass
import json
from pathlib import Path
import re


@dataclass(frozen=True)
class Contract:
    encoding: str
    exponents: tuple[tuple[str, int], ...]


# Local exercise policies, NOT a worldwide currency or provider registry.
CONTRACTS = {
    "checkout-minor-v1": Contract("minor_integer", (("USD", 2), ("JPY", 0))),
    "expense-major-v1": Contract("major_text", (("USD", 2), ("JPY", 0))),
}
MAX_MINOR = 10**12


@dataclass(frozen=True)
class Envelope:
    source_contract: str
    payload: dict


@dataclass(frozen=True)
class MoneyRow:
    source_contract: str
    record_id: str
    currency: str
    exponent: int
    amount_minor: int
    original_amount: int | str


def normalize(envelope: Envelope) -> MoneyRow:
    contract = CONTRACTS.get(envelope.source_contract)
    if contract is None:
        raise ValueError("unknown_source_contract")
    row = envelope.payload
    if not isinstance(row, dict) or set(row) != {"id", "currency", "amount"}:
        raise ValueError("unexpected_record_fields")
    if not isinstance(row["id"], str) or not row["id"]:
        raise ValueError("missing_record_identity")
    if not isinstance(row["currency"], str):
        raise ValueError("missing_currency")
    exponents = dict(contract.exponents)
    if row["currency"] not in exponents:
        raise ValueError("unsupported_currency")
    exponent = exponents[row["currency"]]
    raw = row["amount"]
    if contract.encoding == "minor_integer":
        # bool is an int subclass in Python; it is not a valid amount here.
        if type(raw) is not int:
            raise ValueError("minor_amount_must_be_integer")
        amount = raw
    elif contract.encoding == "major_text":
        if not isinstance(raw, str) or not 1 <= len(raw) <= 32:
            raise ValueError("major_amount_must_be_decimal_text")
        if not re.fullmatch(r"(?:0|[1-9][0-9]*)(?:\.[0-9]+)?", raw):
            raise ValueError("invalid_decimal_text")
        whole, _, fraction = raw.partition(".")
        if len(fraction) > exponent:
            raise ValueError("precision_exceeds_source_contract")
        amount = int(whole) * 10**exponent + int(fraction.ljust(exponent, "0") or "0")
    else:
        raise ValueError("unsupported_amount_encoding")
    if not 0 <= amount <= MAX_MINOR:
        raise ValueError("amount_out_of_fixture_range")
    return MoneyRow(envelope.source_contract, row["id"], row["currency"], exponent, amount, raw)


def display_amount(amount_minor: int, exponent: int) -> str:
    whole, fraction = divmod(amount_minor, 10**exponent)
    return str(whole) if exponent == 0 else f"{whole}.{fraction:0{exponent}d}"


def build_report(envelopes: list[Envelope]) -> dict:
    ledger, rejected = [], []
    seen = set()
    totals: dict[tuple[str, int], int] = {}
    for index, envelope in enumerate(envelopes, start=1):
        try:
            normalized = normalize(envelope)
            key = (normalized.source_contract, normalized.record_id)
            if key in seen:
                raise ValueError("duplicate_source_record")
            seen.add(key)
            group = (normalized.currency, normalized.exponent)
            totals[group] = totals.get(group, 0) + normalized.amount_minor
            ledger.append({**asdict(normalized), "display": display_amount(normalized.amount_minor, normalized.exponent)})
        except ValueError as error:
            rejected.append({"input_index": index, "source_contract": envelope.source_contract,
                             "original_payload": deepcopy(envelope.payload), "reason": str(error)})
    # Group includes exponent, so a future mismatched policy cannot silently add units.
    groups = [{"currency": currency, "exponent": exponent, "amount_minor": amount,
               "display": display_amount(amount, exponent)}
              for (currency, exponent), amount in sorted(totals.items())]
    return {"status": "partial" if rejected else ("accepted_fixture" if envelopes else "empty_input"),
            "scope": "distinct settled fixture expenses; only accepted rows included",
            "ledger": ledger, "rejected": rejected, "groups": groups,
            "combined_total": None, "combined_total_reason": "no_currency_conversion_contract"}


def must_reject(envelope: Envelope, reason: str) -> None:
    try:
        normalize(envelope)
    except ValueError as error:
        assert str(error) == reason, (str(error), reason)
    else:
        raise AssertionError("expected rejection")


def main() -> None:
    minor, major = "checkout-minor-v1", "expense-major-v1"
    records = [
        Envelope(minor, {"id": "A1", "currency": "USD", "amount": 1999}),
        Envelope(major, {"id": "B1", "currency": "USD", "amount": "19.99"}),
        Envelope(minor, {"id": "A2", "currency": "JPY", "amount": 1000}),
        Envelope(major, {"id": "B2", "currency": "JPY", "amount": "500"}),
        Envelope(major, {"id": "B0", "currency": "USD", "amount": "0.00"}),
        Envelope(major, {"id": "B3", "currency": "USD", "amount": "1.005"}),
        Envelope(minor, {"id": "A3", "currency": "JPY", "amount": "250"}),
        Envelope(major, {"id": "B4", "currency": None, "amount": "7.00"}),
        Envelope("unregistered-tool", {"id": "X1", "currency": "USD", "amount": 12}),
    ]
    original = deepcopy(records)
    report = build_report(records)
    assert records == original
    assert len(report["ledger"]) == 5 and len(report["rejected"]) == 4
    assert report["status"] == "partial" and report["combined_total"] is None
    assert [(row["currency"], row["amount_minor"], row["display"]) for row in report["groups"]] == [
        ("JPY", 1500, "1500"), ("USD", 3998, "39.98")]
    assert report["ledger"][0]["amount_minor"] == report["ledger"][1]["amount_minor"] == 1999
    assert report["ledger"][4]["amount_minor"] == 0
    assert [row["reason"] for row in report["rejected"]] == [
        "precision_exceeds_source_contract", "minor_amount_must_be_integer", "missing_currency", "unknown_source_contract"]
    must_reject(Envelope(minor, {"id": "bool", "currency": "USD", "amount": True}), "minor_amount_must_be_integer")
    must_reject(Envelope(major, {"id": "unknown", "currency": "EUR", "amount": "1.00"}), "unsupported_currency")
    must_reject(Envelope(major, {"id": "fraction-yen", "currency": "JPY", "amount": "1.1"}), "precision_exceeds_source_contract")
    must_reject(Envelope(major, {"id": "exponent", "currency": "USD", "amount": "1e2"}), "invalid_decimal_text")
    must_reject(Envelope(minor, {"id": "negative", "currency": "USD", "amount": -1}), "amount_out_of_fixture_range")
    must_reject(Envelope(minor, {"id": "huge", "currency": "USD", "amount": MAX_MINOR + 1}), "amount_out_of_fixture_range")
    duplicate = build_report([records[0], records[0]])
    assert len(duplicate["ledger"]) == 1 and duplicate["rejected"][0]["reason"] == "duplicate_source_record"
    assert build_report([])["groups"] == [] and build_report([])["status"] == "empty_input"
    assert build_report([records[0]])["status"] == "accepted_fixture"
    Path("normalized-expense-report.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print("Accepted normalization ledger:")
    for row in report["ledger"]:
        print(f"{row['source_contract']}/{row['record_id']}: raw={row['original_amount']!r} -> "
              f"{row['amount_minor']} x 10^-{row['exponent']} {row['currency']} = {row['display']} {row['currency']}")
    print("Rejected input rows:")
    for row in report["rejected"]:
        print(f"row {row['input_index']}: {row['reason']}")
    print("Accepted-only subtotals: JPY 1500; USD 39.98")
    print("status=partial; accepted=5/9; combined_total=None")
    print("PASS: source-bound units, exact integer normalization, currency-separated totals, rejection ledger")


if __name__ == "__main__":
    main()