tewip-ai 0.4.0

package/dist/engine/import/blob.js

@@ -0,0 +1,165 @@
+// Imports Playwright blob reports as triage records in the same shape the reporter writes,
+// plus one run summary with every attempt. Two sources: a CI artifact zip holding one
+// report-N.zip per shard (harvesting public repos), or a local blob-report/ directory (the
+// GitHub Action, right after the tests ran). Consumers only need Playwright's built-in
+// `blob` reporter, no Tewip code in their config.
+import { mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join, relative, sep } from 'node:path';
+import { stripVTControlCharacters } from 'node:util';
+import { PROJECT_ROOT } from '../../reporters/store.js';
+import { SCHEMA_VERSION } from '../../reporters/types.js';
+import { readZipBuffer } from '../trace/zip.js';
+// Screenshots and videos are skipped: the diagnosis layers read traces and error-context only.
+const KEPT_ATTACHMENTS = new Set(['trace', 'error-context']);
+const MAX_ERROR_CHARS = 8000;
+const clip = (s) => (s.length <= MAX_ERROR_CHARS ? s : `${s.slice(0, MAX_ERROR_CHARS)}…`);
+const slash = (p) => p.split(sep).join('/');
+/** testId hash -> readable test id ("project > file > describe > title") and spec file. */
+function titlesOf(events, workspace) {
+    const out = new Map();
+    const walk = (entries = [], path, file, testDir) => {
+        for (const e of entries) {
+            const f = e.location?.file ?? file;
+            if (e.testId) {
+                const abs = isAbsolute(f) ? f : join(testDir, f);
+                const shown = workspace && testDir ? slash(relative(workspace, abs)) : f;
+                out.set(e.testId, { id: [...path, e.title].filter(Boolean).join(' > '), file: shown });
+            }
+            else
+                walk(e.entries, [...path, e.title], f, testDir);
+        }
+    };
+    // Blob reports store suite paths relative to config.rootDir (absolute) and the project's testDir
+    // relative to that root, often empty.
+    const rootDir = events.find((x) => x.method === 'onConfigure')?.params.config.rootDir ?? '';
+    for (const e of events.filter((x) => x.method === 'onProject')) {
+        const testDir = e.params.project.testDir ?? '';
+        walk(e.params.project.suites, [e.params.project.name], '', rootDir ? join(rootDir, testDir) : testDir);
+    }
+    return out;
+}
+function parseEvents(buf) {
+    return buf
+        .toString('utf8')
+        .split(/\r?\n/)
+        .filter((l) => l.trim())
+        .map((l) => JSON.parse(l));
+}
+/** A CI artifact zip: one report-N.zip per shard, or a single shard's report.jsonl directly. */
+export function importBlobArtifact(artifact, meta, filesDir) {
+    return importShards(shardsOf(artifact, 'artifact'), meta, filesDir);
+}
+/**
+ * Several CI artifacts that belong to one run, e.g. one blob-report-N per shard (Supabase,
+ * Penpot) instead of one merged artifact (Gutenberg): imported as a single run.
+ */
+export function importBlobArtifacts(artifacts, meta, filesDir) {
+    return importShards(artifacts.flatMap(([name, buf]) => shardsOf(buf, name)), meta, filesDir);
+}
+function shardsOf(artifact, name) {
+    const outer = readZipBuffer(artifact, (n) => n.endsWith('.zip') || n === 'report.jsonl');
+    return outer.has('report.jsonl') ? [[name, artifact]] : [...outer.entries()].filter(([n]) => n.endsWith('.zip')).map(([n, b]) => [`${name}/${n}`, b]);
+}
+/** A local blob-report/ directory as the blob reporter writes it (report*.zip per shard). */
+export function importBlobReportDir(dir, meta, filesDir) {
+    const shards = readdirSync(dir)
+        .filter((n) => n.endsWith('.zip'))
+        .map((n) => [n, readFileSync(join(dir, n))]);
+    return importShards(shards, meta, filesDir);
+}
+function importShards(shards, meta, filesDir) {
+    const records = [];
+    const attempts = {};
+    const skippedShards = [];
+    let startedAt = Number.POSITIVE_INFINITY;
+    let finishedAt = 0;
+    let runStatus = 'passed';
+    mkdirSync(filesDir, { recursive: true });
+    for (const [shardName, shard] of shards) {
+        let events;
+        try {
+            events = parseEvents(readZipBuffer(shard, (n) => n === 'report.jsonl').get('report.jsonl') ?? Buffer.alloc(0));
+        }
+        catch {
+            // Seen in real artifacts: a shard blob truncated at upload. Keep the other shards.
+            skippedShards.push(shardName);
+            continue;
+        }
+        const titles = titlesOf(events, meta.workspace);
+        const begins = new Map();
+        const attachmentsByResult = new Map();
+        for (const e of events) {
+            if (e.method === 'onTestBegin')
+                begins.set(e.params.result.id, { retry: e.params.result.retry, startTime: e.params.result.startTime });
+            if (e.method === 'onAttach')
+                attachmentsByResult.set(e.params.resultId, [...(attachmentsByResult.get(e.params.resultId) ?? []), ...e.params.attachments]);
+            if (e.method === 'onEnd') {
+                startedAt = Math.min(startedAt, e.params.result.startTime);
+                finishedAt = Math.max(finishedAt, e.params.result.startTime + e.params.result.duration);
+                if (e.params.result.status !== 'passed')
+                    runStatus = e.params.result.status;
+            }
+        }
+        const failed = [];
+        for (const e of events.filter((x) => x.method === 'onTestEnd')) {
+            const { test, result } = e.params;
+            const title = titles.get(test.testId) ?? { id: test.testId, file: '' };
+            if (result.status !== 'skipped' && result.status !== 'interrupted')
+                attempts[title.id] = (attempts[title.id] ?? 0) + 1;
+            if (result.status !== 'failed' && result.status !== 'timedOut')
+                continue;
+            const begin = begins.get(result.id) ?? { retry: 0, startTime: startedAt };
+            const error = result.errors?.[0] ?? {};
+            const all = (attachmentsByResult.get(result.id) ?? []).filter((a) => KEPT_ATTACHMENTS.has(a.name) && a.path);
+            failed.push({
+                wanted: all.filter((a, i) => all.findIndex((b) => b.path === a.path) === i),
+                record: {
+                    schemaVersion: SCHEMA_VERSION,
+                    testId: title.id,
+                    file: title.file,
+                    status: result.status,
+                    errorMessage: clip(stripVTControlCharacters(error.message ?? '')),
+                    errorStack: clip(stripVTControlCharacters(error.stack ?? '')),
+                    duration: result.duration,
+                    retry: begin.retry,
+                    attachments: [],
+                    runId: meta.runId,
+                    gitSha: meta.gitSha,
+                    timestamp: new Date(begin.startTime + result.duration).toISOString(),
+                },
+            });
+        }
+        // Only the resources failed attempts point at are extracted; the rest of the shard is skipped.
+        const needed = new Set(failed.flatMap((f) => f.wanted.map((a) => a.path)));
+        let resources = new Map();
+        try {
+            resources = readZipBuffer(shard, (n) => needed.has(n));
+        }
+        catch {
+            // A damaged resource leaves the records without attachments rather than dropping them.
+        }
+        for (const { record, wanted } of failed) {
+            for (const a of wanted) {
+                const data = resources.get(a.path);
+                if (!data)
+                    continue;
+                const target = join(filesDir, basename(a.path));
+                writeFileSync(target, data);
+                const attachment = { name: a.name, contentType: a.contentType, path: slash(relative(PROJECT_ROOT, target)) };
+                record.attachments.push(attachment);
+            }
+            records.push(record);
+        }
+    }
+    const summary = {
+        schemaVersion: SCHEMA_VERSION,
+        runId: meta.runId,
+        gitSha: meta.gitSha,
+        ...(meta.branch ? { branch: meta.branch } : {}),
+        startedAt: new Date(Number.isFinite(startedAt) ? startedAt : 0).toISOString(),
+        finishedAt: new Date(finishedAt).toISOString(),
+        status: runStatus,
+        attempts,
+    };
+    return { records, summary, skippedShards };
+}

package/dist/engine/import/junit.js

@@ -0,0 +1,235 @@
+// Imports test reports from any language or framework into the agent's records: JUnit XML, which
+// pytest, Jest, Vitest, Mocha, node:test, Maven Surefire, Gradle, gotestsum, PHPUnit, RSpec,
+// cargo-nextest and Cypress write, and .NET's own TRX. Playwright keeps its own importer
+// (blob.ts), which also reads traces.
+//
+// What these reports can and cannot say: each test's name, outcome, failure message and stack,
+// and duration; retries when the runner records them. They carry no page snapshot or trace, so
+// selector drift is not diagnosed from them. Every format below was checked against a report its
+// real runner wrote (fixtures/polyglot, run by .github/workflows/polyglot-fixtures.yml).
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { SCHEMA_VERSION } from '../../reporters/types.js';
+import { descendants, parseXml } from './xml.js';
+const PASSED = { failed: false, message: '', stack: '' };
+const FAILURE = new Set(['failure', 'error']);
+/** Maven Surefire's records of earlier attempts: flaky* when a later one passed, rerun* when not. */
+const RETRY_FAILURE = new Set(['flakyFailure', 'flakyError', 'rerunFailure', 'rerunError']);
+/** A failure's message and detail; runners disagree on which of the two holds what. */
+function failure(rawMessage, rawDetail) {
+    // Terminal colour codes: XML cannot hold the escape character, so runners often write what is left
+    // of them ("[2mexpect([22m"); both forms are noise to the rules.
+    const plain = (s) => s.replace(/\u001b?\[(?:\d{1,3};)*\d{1,3}m/g, '');
+    const message = plain(rawMessage);
+    const detail = plain(rawDetail);
+    const head = message.trim() || detail.split('\n').find((l) => l.trim() !== '') || 'failed';
+    const stack = detail.trim();
+    // The full detail goes into the message too: outside Playwright the useful part (the assertion,
+    // the exception) is usually in the detail, and the rules read the message.
+    return { failed: true, message: stack && !stack.includes(head) ? `${head}\n${stack}` : stack || head, stack };
+}
+const fromElement = (e) => failure(e.attrs.message ?? e.attrs.type ?? '', e.children.find((c) => c.name === 'stackTrace')?.text ?? e.text);
+/** The attempts one <testcase> records: earlier failed retries first, then the final outcome. */
+function attemptsOf(testcase) {
+    const retries = testcase.children.filter((c) => RETRY_FAILURE.has(c.name)).map(fromElement);
+    const final = testcase.children.find((c) => FAILURE.has(c.name));
+    // No final failure means the last attempt passed: after flakyFailure retries, "failed, then passed".
+    return [...retries, final ? fromElement(final) : PASSED];
+}
+/** A file path relative to the checkout, so the same test has the same id on every machine. */
+function relativeFile(file, workspace) {
+    const f = file.trim().replaceAll('\\', '/');
+    const ws = workspace?.replaceAll('\\', '/').replace(/\/?$/, '/');
+    if (ws && f.toLowerCase().startsWith(ws.toLowerCase()))
+        return f.slice(ws.length);
+    return f;
+}
+function junitCases(root, workspace) {
+    const out = [];
+    const walk = (e, suite) => {
+        for (const c of e.children) {
+            if (c.name === 'testcase')
+                add(c, suite);
+            else
+                walk(c, c.name === 'testsuite' ? c : suite);
+        }
+    };
+    const add = (testcase, suite) => {
+        if (testcase.children.some((c) => c.name === 'skipped'))
+            return;
+        const file = relativeFile(testcase.attrs.file ?? suite?.attrs.file ?? '', workspace);
+        const parts = [file, testcase.attrs.classname, testcase.attrs.name].map((p) => (p ?? '').trim()).filter(Boolean);
+        if (parts.length === 1 && suite?.attrs.name)
+            parts.unshift(suite.attrs.name.trim());
+        const testId = [...new Set(parts)].join(' > ');
+        const seconds = Number(testcase.attrs.time);
+        const attempts = attemptsOf(testcase);
+        const previous = out.at(-1);
+        if (previous?.testId === testId) {
+            // Rerun plugins (pytest-rerunfailures and others) write every attempt as its own entry and
+            // only re-run after a failure, so an earlier entry of the same test is a failed attempt even
+            // when the plugin left its error out. Only adjacent entries are merged.
+            const earlier = previous.attempts.at(-1);
+            if (!earlier.failed)
+                previous.attempts[previous.attempts.length - 1] = { failed: true, message: '', stack: '' };
+            previous.attempts.push(...attempts);
+            return;
+        }
+        out.push({ testId, file: file || (testcase.attrs.classname ?? '').trim(), duration: Number.isFinite(seconds) ? Math.round(seconds * 1000) : 0, attempts });
+    };
+    walk(root, root.name === 'testsuite' ? root : undefined);
+    // Attempts whose error the runner did not record borrow the final one's, when there is one.
+    for (const c of out) {
+        const known = [...c.attempts].reverse().find((a) => a.failed && a.message);
+        for (const [i, a] of c.attempts.entries()) {
+            if (a.failed && !a.message)
+                c.attempts[i] = known ?? failure('failed and was re-run; the runner did not record this attempt\'s error', '');
+        }
+    }
+    return out;
+}
+/** "00:00:01.2340000" -> 1234 ms. */
+const trxDuration = (d) => {
+    const m = d?.match(/^(\d+):(\d+):(\d+(?:\.\d+)?)$/);
+    return m ? Math.round(((Number(m[1]) * 60 + Number(m[2])) * 60 + Number(m[3])) * 1000) : 0;
+};
+/** .NET's native TRX report (dotnet test --logger trx). */
+function trxCases(root) {
+    const methods = new Map();
+    for (const unit of descendants(root, 'UnitTest')) {
+        const method = unit.children.find((c) => c.name === 'TestMethod');
+        if (unit.attrs.id && method)
+            methods.set(unit.attrs.id, { className: method.attrs.className ?? '', name: method.attrs.name ?? '' });
+    }
+    return descendants(root, 'UnitTestResult')
+        .filter((r) => r.attrs.outcome !== 'NotExecuted')
+        .map((r) => {
+        const method = methods.get(r.attrs.testId ?? '');
+        const testId = method?.className ? `${method.className} > ${method.name}` : (r.attrs.testName ?? '').trim();
+        const info = descendants(r, 'ErrorInfo')[0];
+        const text = (name) => info?.children.find((c) => c.name === name)?.text ?? '';
+        const failed = r.attrs.outcome === 'Failed' || r.attrs.outcome === 'Error' || r.attrs.outcome === 'Timeout';
+        return {
+            testId,
+            file: method?.className ?? testId,
+            duration: trxDuration(r.attrs.duration),
+            attempts: [failed ? failure(text('Message'), text('StackTrace')) : PASSED],
+        };
+    });
+}
+/**
+ * NUnit 3's own result file (`nunit3-console --result=x.xml`), whose root is <test-run>. NUnit does
+ * not write JUnit XML at all - its console offers only the nunit3 and nunit2 formats - so a .NET
+ * team on NUnit has nothing else to hand Tewip.
+ */
+function nunitCases(root) {
+    return descendants(root, 'test-case')
+        .filter((t) => t.attrs.result !== 'Skipped' && t.attrs.result !== 'Inconclusive')
+        .map((t) => {
+        const failureEl = t.children.find((c) => c.name === 'failure');
+        const child = (parent, name) => parent?.children.find((c) => c.name === name)?.text ?? '';
+        const testId = (t.attrs.fullname ?? '').trim() || [t.attrs.classname, t.attrs.methodname ?? t.attrs.name].filter(Boolean).join(' > ');
+        const seconds = Number(t.attrs.duration);
+        return {
+            testId,
+            file: (t.attrs.classname ?? '').trim(),
+            duration: Number.isFinite(seconds) ? Math.round(seconds * 1000) : 0,
+            attempts: [t.attrs.result === 'Failed' ? failure(child(failureEl, 'message'), child(failureEl, 'stack-trace')) : PASSED],
+        };
+    });
+}
+const REPORT_FILE = /\.(xml|trx)$/i;
+/** Report files under `path` (a file, or a directory searched recursively). */
+export function junitFiles(path) {
+    if (!statSync(path).isDirectory())
+        return [path];
+    return readdirSync(path, { recursive: true, withFileTypes: true })
+        .filter((d) => d.isFile() && REPORT_FILE.test(d.name))
+        .map((d) => join(d.parentPath, d.name))
+        .sort();
+}
+/**
+ * Imports one or more reports as a single run. Only failed attempts become records, as with
+ * Playwright; every test, passing or failing, is counted in the run summary so its history
+ * shows the passes too.
+ */
+export function importJunit(path, meta) {
+    const records = [];
+    const attempts = {};
+    const now = new Date().toISOString();
+    let startedAt = '';
+    let anyFailed = false;
+    const unread = [];
+    let parsedFiles = 0;
+    for (const file of junitFiles(path)) {
+        const root = parseXml(readFileSync(file, 'utf8'));
+        let cases;
+        if (root.name === 'TestRun') {
+            cases = trxCases(root);
+            const start = descendants(root, 'Times')[0]?.attrs.start;
+            if (start && (!startedAt || start < startedAt))
+                startedAt = start;
+        }
+        else if (root.name === 'testsuites' || root.name === 'testsuite') {
+            cases = junitCases(root, meta.workspace);
+            const stamp = root.attrs.timestamp ?? root.children.find((c) => c.name === 'testsuite')?.attrs.timestamp;
+            if (stamp && (!startedAt || stamp < startedAt))
+                startedAt = stamp;
+        }
+        else if (root.name === 'test-run') {
+            cases = nunitCases(root);
+            const start = root.attrs['start-time'];
+            if (start && (!startedAt || start < startedAt))
+                startedAt = start;
+        }
+        else {
+            // Not a report Tewip knows. Staying silent here would report a failing run as clean, so the
+            // file is remembered and, if nothing at all could be read, the caller is told.
+            unread.push(`${file} (root <${root.name}>)`);
+            continue;
+        }
+        parsedFiles++;
+        for (const c of cases) {
+            attempts[c.testId] = (attempts[c.testId] ?? 0) + c.attempts.length;
+            c.attempts.forEach((attempt, retry) => {
+                if (!attempt.failed)
+                    return;
+                anyFailed = true;
+                records.push({
+                    schemaVersion: SCHEMA_VERSION,
+                    testId: c.testId,
+                    file: c.file,
+                    status: 'failed',
+                    errorMessage: attempt.message,
+                    errorStack: attempt.stack,
+                    duration: c.duration,
+                    retry,
+                    attachments: [],
+                    runId: meta.runId,
+                    gitSha: meta.gitSha,
+                    timestamp: now,
+                });
+            });
+        }
+    }
+    const summary = {
+        schemaVersion: SCHEMA_VERSION,
+        runId: meta.runId,
+        gitSha: meta.gitSha,
+        ...(meta.branch ? { branch: meta.branch } : {}),
+        startedAt: startedAt ? new Date(startedAt).toISOString() : now,
+        finishedAt: now,
+        status: anyFailed ? 'failed' : 'passed',
+        attempts,
+    };
+    // Never let an unreadable report look like a clean run: a run that failed would pass the gate.
+    if (unread.length > 0) {
+        const list = unread.slice(0, 5).join(', ');
+        if (parsedFiles === 0) {
+            throw new Error(`no test report Tewip can read in ${path}: ${list}. It reads JUnit XML (<testsuites>/<testsuite>), NUnit 3 (<test-run>) and .NET TRX (<TestRun>). ` +
+                'Most runners can write JUnit XML; for TestNG use the Surefire report, and for NUnit use --result=x.xml.');
+        }
+        console.error(`[tewip] ignored ${unread.length} file(s) that are not a test report: ${list}`);
+    }
+    return { records, summary, skippedShards: [] };
+}

package/dist/engine/import/xml.js

@@ -0,0 +1,104 @@
+// A small XML reader, enough for JUnit reports: elements, attributes, text, CDATA, comments and
+// entities. Test reports are machine-written and well-formed, so this avoids a dependency; it is
+// not a general-purpose parser (no DTDs, no namespaces beyond keeping prefixed names as written).
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'" };
+export function decodeEntities(s) {
+    return s.replace(/&(#x[0-9a-fA-F]+|#\d+|[a-zA-Z]+);/g, (whole, body) => {
+        if (body.startsWith('#x'))
+            return String.fromCodePoint(Number.parseInt(body.slice(2), 16));
+        if (body.startsWith('#'))
+            return String.fromCodePoint(Number.parseInt(body.slice(1), 10));
+        return ENTITIES[body] ?? whole;
+    });
+}
+const ATTRIBUTE = /([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
+/** Parses a document and returns its root element; throws on input that is not XML. */
+export function parseXml(source) {
+    const root = { name: '#document', attrs: {}, children: [], text: '' };
+    const stack = [root];
+    let i = 0;
+    while (i < source.length) {
+        const lt = source.indexOf('<', i);
+        const top = stack[stack.length - 1];
+        if (lt < 0) {
+            top.text += decodeEntities(source.slice(i));
+            break;
+        }
+        if (lt > i)
+            top.text += decodeEntities(source.slice(i, lt));
+        if (source.startsWith('<!--', lt)) {
+            i = end(source, '-->', lt) + 3;
+        }
+        else if (source.startsWith('<![CDATA[', lt)) {
+            const close = end(source, ']]>', lt);
+            top.text += source.slice(lt + 9, close);
+            i = close + 3;
+        }
+        else if (source.startsWith('<?', lt) || source.startsWith('<!', lt)) {
+            i = end(source, '>', lt) + 1;
+        }
+        else if (source.startsWith('</', lt)) {
+            const close = end(source, '>', lt);
+            const name = source.slice(lt + 2, close).trim();
+            // Tolerate a stray closing tag rather than corrupting the tree.
+            const at = stack.map((e) => e.name).lastIndexOf(name);
+            if (at > 0)
+                stack.length = at;
+            i = close + 1;
+        }
+        else {
+            const close = tagEnd(source, lt);
+            const raw = source.slice(lt + 1, close);
+            const selfClosing = raw.endsWith('/');
+            const body = selfClosing ? raw.slice(0, -1) : raw;
+            const name = body.match(/^[^\s/>]+/)?.[0] ?? '';
+            const attrs = {};
+            for (const [, key, dq, sq] of body.slice(name.length).matchAll(ATTRIBUTE))
+                attrs[key] = decodeEntities(dq ?? sq ?? '');
+            const element = { name, attrs, children: [], text: '' };
+            top.children.push(element);
+            if (!selfClosing)
+                stack.push(element);
+            i = close + 1;
+        }
+    }
+    const first = root.children[0];
+    if (!first)
+        throw new Error('not an XML document: no root element');
+    return first;
+}
+function end(source, token, from) {
+    const at = source.indexOf(token, from);
+    if (at < 0)
+        throw new Error(`unterminated XML near offset ${from}`);
+    return at;
+}
+/** The end of a start tag, skipping '>' characters inside quoted attribute values. */
+function tagEnd(source, from) {
+    let quote = '';
+    for (let i = from + 1; i < source.length; i++) {
+        const c = source[i];
+        if (quote) {
+            if (c === quote)
+                quote = '';
+        }
+        else if (c === '"' || c === "'")
+            quote = c;
+        else if (c === '>')
+            return i;
+    }
+    throw new Error(`unterminated tag near offset ${from}`);
+}
+/** Every descendant element with this name, depth first. */
+export function descendants(element, name) {
+    const out = [];
+    const walk = (e) => {
+        for (const c of e.children) {
+            if (c.name === name)
+                out.push(c);
+            walk(c);
+        }
+    };
+    walk(element);
+    return out;
+}

package/dist/engine/llm/anthropic.js

@@ -0,0 +1,59 @@
+// Anthropic's own API, for teams who have Claude rather than OpenAI. It has no "JSON schema
+// response format", so the schema is given as a single tool the model must call: the arguments it
+// passes back are the JSON Tewip asked for. Same LlmClient shape as every other provider, so the
+// engine cannot tell the difference.
+import { truncate } from '../signature.js';
+import { recordCall } from './usage.js';
+const VERSION = '2023-06-01';
+const REQUEST_TIMEOUT_MS = 90_000;
+const MAX_ATTEMPTS = 3;
+const MAX_TOKENS = 4096;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+export function anthropicClient({ apiKey, model, baseUrl = 'https://api.anthropic.com/v1' }) {
+    return {
+        model,
+        async complete({ system, user, schemaName, schema }) {
+            const body = JSON.stringify({
+                model,
+                max_tokens: MAX_TOKENS,
+                system,
+                messages: [{ role: 'user', content: user }],
+                // One tool, and the model must use it: its arguments are the answer in the shape asked for.
+                tools: [{ name: schemaName, description: 'Return the answer in this shape.', input_schema: schema }],
+                tool_choice: { type: 'tool', name: schemaName },
+            });
+            const startedAt = Date.now();
+            for (let attempt = 1;; attempt++) {
+                let res;
+                try {
+                    res = await fetch(`${baseUrl}/messages`, {
+                        method: 'POST',
+                        headers: { 'x-api-key': apiKey, 'anthropic-version': VERSION, 'Content-Type': 'application/json' },
+                        body,
+                        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+                    });
+                }
+                catch (error) {
+                    if (attempt >= MAX_ATTEMPTS)
+                        throw new Error(`Anthropic request failed: ${String(error)}`);
+                    await sleep(2000 * attempt);
+                    continue;
+                }
+                if (res.ok) {
+                    const json = (await res.json());
+                    recordCall(Date.now() - startedAt, { prompt: json.usage?.input_tokens, completion: json.usage?.output_tokens, cached: json.usage?.cache_read_input_tokens }, model);
+                    const call = json.content?.find((c) => c.type === 'tool_use' && c.input !== undefined);
+                    if (!call) {
+                        const refusal = json.content?.find((c) => c.type === 'text')?.text;
+                        throw new Error(refusal ? `model refused: ${truncate(refusal, 200)}` : 'model returned no answer in the shape asked for');
+                    }
+                    return JSON.stringify(call.input);
+                }
+                const detail = truncate(await res.text(), 300);
+                if ((res.status !== 429 && res.status < 500) || attempt >= MAX_ATTEMPTS)
+                    throw new Error(`Anthropic API ${res.status}: ${detail}`);
+                await sleep(2000 * attempt);
+            }
+        },
+    };
+}