Build a used car finder with the Agents SDK

criteria.json → AutoScout24 search → filters → cost of ownership → ranked
   → for each car, cheapest first: open the page → listing-reviewer agent → shortlist

class Review(BaseModel):
    verdict: str = Field(description="PASS or FAIL")
    why: str = Field(description="One line")
    evidence: str = Field(
        description="For FAIL: an exact sentence copied from page_text that proves it. Empty for PASS"
    )
    abstract: str = Field(description="Two or three short sentences: what it is, its history and condition, the catch")
    maintenance_history: str
    controle_technique: str
    owners: str
    questions_for_seller: list[str] = Field(description="2 to 4 questions to ask before driving there")

REVIEWER = agents.Agent(
    model="mistral-medium-latest",
    name="listing-reviewer",
    instructions=f"""You vet one used car listing for a buyer who keeps it {BUYER["years"]} years and wants no big
repair. You get the listing data, what this model should be (target), and the text of the listing page, already
fetched. Report only what the page says; write 'not stated' otherwise. Never invent facts.
The engine and gearbox were already checked; do not judge them.
FAIL only if the page itself says: a price or km different from the listing data; the car was damaged or in an
accident, does not run, has no papers, is for export or for parts; or it looks like a scam (payment by transfer,
seller abroad, mandatory extra fees). Equipment lists ("airbag en cas d'accident", "kit de réparation",
"pare-chocs") are not evidence.
For a FAIL, copy the exact sentence that proves it into evidence. Otherwise PASS.
Write the abstract and questions in English. The engine has a timing chain unless the target says otherwise.""",
    output_type=Review,  # the model answers with a Review, and Completed.output is one
    max_iterations=2,
)

async def review(car: dict, model: dict, text: str) -> Review | None:
    listing = {k: v for k, v in car.items() if k != "tco"}
    prompt = json.dumps({"listing": listing, "target": model["target"], "page_text": text}, ensure_ascii=False)
    for attempt in (1, 2):
        match await REVIEWER.run(prompt, timeout=300):
            case agents.Completed(output=Review() as rev):
                pass
            case agents.Running(session_id=session_id, turn_id=turn_id):
                log(f"review attempt {attempt}: no answer after 300 s")
                await REVIEWER.session(session_id).turn(turn_id).interrupt()  # the timeout only left the wait
                continue
            case other:  # Completed(output=InvalidOutput(...)), Failed, ...
                log(f"review attempt {attempt} failed: {other!r}"[:300])
                continue
        # A FAIL must quote the page. An unquoted worry is kept as a question rather than dropping the car.
        if rev.verdict.upper().startswith("FAIL") and _normalise(rev.evidence or "∅") not in _normalise(text):
            rev.verdict = "PASS*"
            rev.questions_for_seller.insert(0, f"Reviewer worried, unproven: {rev.why}")
        return rev
    return None

uv sync
export MISTRAL_API_KEY=...
uv run python -m car_finder.main

"""The listing reviewer with a scripted model: no API key, no network."""

import json

import pytest
from car_finder import main

from mistralai import agents

CAR = {"title": "Peugeot 108 1.0 VTi 72 Active", "price_eur": 6_900, "km": 61_000, "tco": None}
MODEL = {"target": "Peugeot 108 1.0 VTi, 68 to 73 ch, timing chain"}
PAGE = "Peugeot 108 1.0 VTi 72 Active. Carnet d'entretien complet. Contrôle technique OK."

def verdict(verdict: str, evidence: str) -> str:
    return json.dumps(
        {
            "verdict": verdict,
            "why": "Accident damage",
            "evidence": evidence,
            "abstract": "A 108 with a full service book.",
            "maintenance_history": "full service book",
            "controle_technique": "OK",
            "owners": "not stated",
            "questions_for_seller": ["When was the clutch changed?"],
        }
    )

async def test_a_fail_needs_a_quote_from_the_page(monkeypatch: pytest.MonkeyPatch) -> None:
    model = agents.testing.ScriptedModel([agents.testing.reply(verdict("FAIL", "Véhicule accidenté."))])
    monkeypatch.setattr(main, "REVIEWER", main.REVIEWER.override(model=model))
    rev = await main.review(CAR, MODEL, PAGE)
    model.assert_consumed()
    assert rev is not None
    assert rev.verdict == "PASS*"  # the quote is not on the page: kept, with a question
    assert rev.questions_for_seller[0] == "Reviewer worried, unproven: Accident damage"

async def test_a_quoted_fail_stays_a_fail(monkeypatch: pytest.MonkeyPatch) -> None:
    model = agents.testing.ScriptedModel([agents.testing.reply(verdict("FAIL", "Contrôle technique OK."))])
    monkeypatch.setattr(main, "REVIEWER", main.REVIEWER.override(model=model))
    rev = await main.review(CAR, MODEL, PAGE)
    assert rev is not None
    assert rev.verdict == "FAIL"

uv run pytest