@relvehq/agent-ready 0.0.0-stage → 0.2.1

package/dist/proof/stats.js

@@ -0,0 +1,127 @@
+"use strict";
+// Proof: the numbers. HitEvents -> one summary for the dashboard and the CLI.
+// EDGE-SAFE (pure).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarize = summarize;
+exports.formatSummary = formatSummary;
+const bots_1 = require("./bots");
+const VIA_LABEL = {
+    accept: "Accept: text/markdown",
+    suffix: ".md URL",
+    query: "?format=md",
+    llms: "llms.txt",
+    direct: "direct",
+};
+const SOURCE_LABEL = {
+    native: "template",
+    stored: "saved file",
+    convert: "live conversion",
+    llms: "llms.txt",
+};
+const KIND_LABEL = {
+    ai_assistant: "AI assistant",
+    ai_search: "AI search",
+    ai_training: "AI training",
+    search: "Search engine",
+    tool: "Script",
+    unknown: "Other",
+};
+function summarize(events, opts = {}) {
+    const sorted = events.slice().sort((a, b) => (a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0));
+    const bots = new Map();
+    const kinds = new Map();
+    const paths = new Map();
+    const vias = new Map();
+    const sources = new Map();
+    const statuses = new Map();
+    const days = new Map();
+    let served = 0;
+    let answer = 0;
+    let tokensServed = 0;
+    const durations = [];
+    const bump = (m, key, label, tokens) => {
+        const c = m.get(key) ?? { key, label, hits: 0, tokens: 0 };
+        c.hits++;
+        c.tokens += tokens;
+        m.set(key, c);
+    };
+    for (const e of sorted) {
+        const ok = (e.status >= 200 && e.status < 300) || e.status === 304;
+        const tokens = ok ? e.tokens ?? 0 : 0;
+        if (ok)
+            served++;
+        tokensServed += tokens;
+        if (Number.isFinite(e.durationMs))
+            durations.push(e.durationMs);
+        const bot = (0, bots_1.classifyAgent)(e.userAgent);
+        if ((0, bots_1.isAnswerBot)(bot))
+            answer++;
+        const b = bots.get(bot.id) ?? { key: bot.id, label: bot.label, operator: bot.operator, kind: bot.kind, hits: 0, tokens: 0 };
+        b.hits++;
+        b.tokens += tokens;
+        bots.set(bot.id, b);
+        bump(kinds, bot.kind, KIND_LABEL[bot.kind], tokens);
+        bump(paths, e.path, e.path, tokens);
+        bump(vias, e.via, VIA_LABEL[e.via] ?? e.via, tokens);
+        bump(sources, e.source ?? "none", e.source ? SOURCE_LABEL[e.source] ?? e.source : "nothing served", tokens);
+        bump(statuses, String(e.status), String(e.status), tokens);
+        const day = e.ts.slice(0, 10);
+        const d = days.get(day) ?? { hits: 0, tokens: 0 };
+        d.hits++;
+        d.tokens += tokens;
+        days.set(day, d);
+    }
+    const rank = (m, top) => {
+        const list = Array.from(m.values()).sort((a, b) => b.hits - a.hits || a.label.localeCompare(b.label));
+        return top ? list.slice(0, top) : list;
+    };
+    durations.sort((a, b) => a - b);
+    const from = sorted[0]?.ts ?? null;
+    const to = sorted[sorted.length - 1]?.ts ?? null;
+    return {
+        from,
+        to,
+        total: sorted.length,
+        served,
+        answerBotHits: answer,
+        tokensServed,
+        medianMs: durations.length ? durations[Math.floor((durations.length - 1) / 2)] : null,
+        byBot: rank(bots),
+        byKind: rank(kinds),
+        byPath: rank(paths, opts.topPaths ?? 20),
+        byVia: rank(vias),
+        bySource: rank(sources),
+        byStatus: rank(statuses),
+        daily: fillDays(days, from, to),
+    };
+}
+function fillDays(days, from, to) {
+    if (!from || !to)
+        return [];
+    const out = [];
+    const end = Date.parse(to.slice(0, 10) + "T00:00:00Z");
+    for (let t = Date.parse(from.slice(0, 10) + "T00:00:00Z"); t <= end && out.length < 400; t += 86400000) {
+        const day = new Date(t).toISOString().slice(0, 10);
+        out.push({ day, ...(days.get(day) ?? { hits: 0, tokens: 0 }) });
+    }
+    return out;
+}
+/** The summary as terminal lines (`agent-ready stats`). */
+function formatSummary(s) {
+    if (!s.total)
+        return "No agent visits recorded yet.";
+    const n = (x) => x.toLocaleString("en-US");
+    const table = (title, rows, max = 10) => [title, ...rows.slice(0, max).map((r) => `  ${String(r.hits).padStart(6)}  ${r.label}${r.tokens ? `  (${n(r.tokens)} tokens)` : ""}`)].join("\n");
+    return [
+        `Agent visits ${s.from?.slice(0, 10)} to ${s.to?.slice(0, 10)}`,
+        `  ${n(s.total)} requests · ${n(s.served)} served · ${n(s.answerBotHits)} from AI assistants and AI search · ${n(s.tokensServed)} tokens served${s.medianMs !== null ? ` · median ${s.medianMs} ms` : ""}`,
+        "",
+        table("By bot", s.byBot),
+        "",
+        table("Top pages", s.byPath),
+        "",
+        table("How agents asked", s.byVia),
+        "",
+        table("Where the Markdown came from", s.bySource),
+    ].join("\n");
+}

package/dist/refine/check.d.ts

@@ -0,0 +1,17 @@
+import type { PageInput } from "./types";
+import type { PromptSettings } from "./prompts";
+export type IssueKind = "number" | "url" | "frontmatter" | "hash" | "section" | "h1" | "html" | "placeholder" | "tokens" | "empty";
+export interface CheckIssue {
+    kind: IssueKind;
+    detail: string;
+}
+export interface CheckResult {
+    ok: boolean;
+    issues: CheckIssue[];
+    tokens: number;
+}
+export interface CheckOptions {
+    /** Token counter. Default chars/4; pass a real tokenizer for exact budgets. */
+    countTokens?: (text: string) => number;
+}
+export declare function checkDoc(doc: string, input: PageInput, settings: PromptSettings, opts?: CheckOptions): CheckResult;

package/dist/refine/check.js

@@ -0,0 +1,134 @@
+"use strict";
+// Refine, step 4: check the model's document before it is stored.
+// The POC's mechanical fact check, as code (the model's own checking is not
+// trusted). A document passes only with no issues:
+//
+//   number       a number in the body that is not in the input
+//   url          a URL in the body that is not in the input (the page URL and
+//                input URLs with their query removed are allowed)
+//   frontmatter  missing, or `canonical` is not the page URL
+//   hash         `source_hash` is not the input's fingerprint
+//   section      a required section (prompt settings) is missing
+//   h1           not exactly one H1
+//   html         HTML tags in the document
+//   placeholder  a {{PLACEHOLDER}} or <Template field> left in
+//   tokens       over the prompt's token budget
+//   empty        no real body
+//
+// Frontmatter values are not number-checked: they hold the hash, timestamps
+// and dates reformatted as YYYY-MM-DD by design.
+// EDGE-SAFE (pure). It cannot catch a reworded claim; people still read.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDoc = checkDoc;
+const enrich_1 = require("../core/enrich");
+const URL_RE = /https?:\/\/[^\s<>()[\]|"'`]+/g;
+const NUM_RE = /\d+(?:[.,]\d+)*/g;
+const HTML_RE = /<\/?(?:a|b|br|div|em|h[1-6]|i|img|li|ol|p|script|span|strong|style|table|td|th|tr|ul)\b[^>]*>/i;
+function checkDoc(doc, input, settings, opts = {}) {
+    const issues = [];
+    const add = (kind, detail) => issues.push({ kind, detail });
+    const md = doc.replace(/\r\n?/g, "\n").trim();
+    const tokens = (opts.countTokens ?? enrich_1.estimateTokens)(md);
+    // Frontmatter.
+    const fm = /^---\n([\s\S]*?)\n---\n?/.exec(md);
+    const body = fm ? md.slice(fm[0].length) : md;
+    if (!fm) {
+        add("frontmatter", "no frontmatter block");
+    }
+    else {
+        const meta = Object.fromEntries(fm[1]
+            .split("\n")
+            .map((l) => /^([\w-]+):\s*(.*)$/.exec(l))
+            .filter((m) => !!m)
+            .map((m) => [m[1], m[2].replace(/^["']|["']$/g, "").trim()]));
+        if (!meta.canonical)
+            add("frontmatter", "no canonical");
+        else if (normUrl(meta.canonical) !== normUrl(input.url))
+            add("frontmatter", `canonical ${meta.canonical} is not ${input.url}`);
+        if (meta.source_hash !== input.sourceHash)
+            add("hash", `source_hash ${meta.source_hash ?? "(none)"} does not match the input`);
+    }
+    const prose = body.replace(/^```[\s\S]*?^```/gm, "");
+    if (prose.replace(/[#|\-\s>*_]/g, "").length < 40)
+        add("empty", "the body is (almost) empty");
+    const h1s = (prose.match(/^# \S/gm) ?? []).length;
+    if (h1s !== 1)
+        add("h1", `${h1s} H1 headings`);
+    for (const name of settings.requiredSections) {
+        if (!new RegExp(`^##\\s+${escapeRe(name)}\\s*$`, "m").test(prose))
+            add("section", `missing "## ${name}"`);
+    }
+    if (HTML_RE.test(prose))
+        add("html", "HTML tags in the document");
+    const left = /\{\{[A-Z_]+\}\}|<(?:Tool|Event|Agent|Post|page) name>|<the kind you chose>/.exec(md);
+    if (left)
+        add("placeholder", `left in: ${left[0]}`);
+    if (tokens > settings.tokenBudget)
+        add("tokens", `${tokens} tokens, budget ${settings.tokenBudget}`);
+    // Facts: everything the input contains, as one haystack.
+    const haystack = [input.text, input.links.map((l) => `${l.url} ${l.text}`).join("\n"), JSON.stringify(input.jsonLd), input.url].join("\n");
+    const known = new Set();
+    const knownNoQuery = new Set();
+    for (const u of haystack.match(URL_RE) ?? []) {
+        known.add(normUrl(trimUrl(u)));
+        knownNoQuery.add(noQuery(trimUrl(u)));
+    }
+    known.add(normUrl(input.url));
+    // Relative links in the input (e.g. "[x](/events/y)" inside JSON-LD): the
+    // prompt asks for absolute URLs, so the model is right to resolve them.
+    for (const m of haystack.matchAll(/(?:\]\(|href=\\?["']|^|\s)(\/[A-Za-z0-9][^\s)"'\\<>|]*)/gm)) {
+        try {
+            const abs = new URL(m[1], input.url).href;
+            known.add(normUrl(abs));
+            knownNoQuery.add(noQuery(abs));
+        }
+        catch {
+            // not a path
+        }
+    }
+    for (const raw of body.match(URL_RE) ?? []) {
+        const u = trimUrl(raw);
+        if (!known.has(normUrl(u)) && !knownNoQuery.has(noQuery(u)))
+            add("url", u);
+    }
+    const knownNums = new Set((haystack.match(NUM_RE) ?? []).map(canonNum));
+    const seen = new Set();
+    for (const n of body.replace(URL_RE, " ").match(NUM_RE) ?? []) {
+        const c = canonNum(n);
+        if (knownNums.has(c) || seen.has(c))
+            continue;
+        seen.add(c);
+        add("number", n);
+    }
+    return { ok: issues.length === 0, issues, tokens };
+}
+/** "1,400" = "1400", "0.10" = "0.1", "05" = "5". */
+function canonNum(s) {
+    const plain = s.replace(/,(?=\d{3}\b)/g, "");
+    const n = Number(plain);
+    return Number.isFinite(n) ? String(n) : plain;
+}
+function trimUrl(u) {
+    return u.replace(/[.,;:!?*_]+$/, "");
+}
+function normUrl(u) {
+    try {
+        const x = new URL(u);
+        return `${x.protocol}//${x.host.toLowerCase()}${x.pathname.replace(/\/+$/, "")}${x.search}`;
+    }
+    catch {
+        return u;
+    }
+}
+function noQuery(u) {
+    try {
+        const x = new URL(u);
+        return `${x.protocol}//${x.host.toLowerCase()}${x.pathname.replace(/\/+$/, "")}`;
+    }
+    catch {
+        return u;
+    }
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/refine/extract.d.ts

@@ -0,0 +1,7 @@
+import type { PageInput } from "./types";
+export { formatLinks, type PageInput, type PageLink } from "./types";
+export declare function extractInput(html: string, opts: {
+    url: string;
+}): Promise<PageInput>;
+/** The page fingerprint: SHA-256 hex of the text and the JSON-LD. */
+export declare function sourceHashOf(text: string, jsonLd: unknown[]): Promise<string>;

package/dist/refine/extract.js

@@ -0,0 +1,120 @@
+"use strict";
+// Refine, step 1: a page's HTML -> the model's input (changes/agent-ready-engine,
+// "refine"). The same recipe as the Markdown POC:
+//
+//   text       the page's <main> (<article>, then <body>, when there is none),
+//              late-loading Next.js sections put back first, as readable
+//              lines; table cells joined with " | "; images as [image: alt]
+//   links      every http(s) link inside it, absolute, "url | text", deduped
+//   jsonLd     every JSON-LD block on the page (top-level arrays flattened)
+//   sourceHash SHA-256 of `text + "\n" + JSON.stringify(jsonLd)`: the page's
+//              fingerprint; a new hash means the page changed
+//
+// Unlike convert, nothing is judged here: buttons and labels stay in, and the
+// writing step decides what to leave out. NODE ONLY (linkedom).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatLinks = void 0;
+exports.extractInput = extractInput;
+exports.sourceHashOf = sourceHashOf;
+const linkedom_1 = require("linkedom");
+const convert_1 = require("../core/convert");
+var types_1 = require("./types");
+Object.defineProperty(exports, "formatLinks", { enumerable: true, get: function () { return types_1.formatLinks; } });
+const DROP = "script,style,noscript,template,svg,canvas,iframe,object,embed,[hidden]";
+const BLOCK = new Set("address article aside blockquote dd details div dl dt fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 header hr li main nav ol p pre section summary table tbody thead tfoot tr ul".split(" "));
+async function extractInput(html, opts) {
+    // linkedom needs a whole document to give a <body>.
+    const { document } = (0, linkedom_1.parseHTML)(/<html[\s>]/i.test(html) ? html : `<!doctype html><html><head></head>${html}</html>`);
+    // JSON-LD first: the <script> tags are dropped below.
+    const jsonLd = [];
+    for (const s of Array.from(document.querySelectorAll('script[type="application/ld+json"]'))) {
+        try {
+            const v = JSON.parse(s.textContent || "");
+            if (Array.isArray(v))
+                jsonLd.push(...v);
+            else
+                jsonLd.push(v);
+        }
+        catch {
+            // Broken JSON-LD is skipped, as in convert.
+        }
+    }
+    (0, convert_1.unfoldNextStreaming)(document);
+    for (const el of Array.from(document.querySelectorAll(DROP)))
+        el.parentNode?.removeChild(el);
+    for (const el of Array.from(document.querySelectorAll('[style*="display:none"], [style*="display: none"]'))) {
+        el.parentNode?.removeChild(el);
+    }
+    const main = document.querySelector("main");
+    const article = main ? null : document.querySelector("article");
+    const root = main || article || document.body || document.documentElement;
+    const mainSource = main ? "main" : article ? "article" : "body";
+    const text = readableText(root);
+    const links = collectLinks(root, opts.url);
+    return { url: opts.url, text, links, jsonLd, sourceHash: await sourceHashOf(text, jsonLd), mainSource };
+}
+/** The page fingerprint: SHA-256 hex of the text and the JSON-LD. */
+async function sourceHashOf(text, jsonLd) {
+    const bytes = new TextEncoder().encode(`${text}\n${JSON.stringify(jsonLd)}`);
+    const digest = await crypto.subtle.digest("SHA-256", bytes);
+    return Array.from(new Uint8Array(digest), (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function readableText(root) {
+    const out = [];
+    const walk = (node) => {
+        if (node.nodeType === 3) {
+            // Source newlines are layout, not content: only blocks and <br> break lines.
+            out.push(String(node.data).replace(/\s+/g, " "));
+            return;
+        }
+        if (node.nodeType !== 1)
+            return;
+        const tag = String(node.nodeName).toLowerCase();
+        if (tag === "br")
+            return void out.push("\n");
+        if (tag === "img") {
+            const alt = (node.getAttribute("alt") || "").trim();
+            if (alt)
+                out.push(` [image: ${alt}] `);
+            return;
+        }
+        const block = BLOCK.has(tag);
+        if (block)
+            out.push("\n");
+        for (const child of Array.from(node.childNodes))
+            walk(child);
+        if (tag === "td" || tag === "th")
+            out.push("\t");
+        if (block)
+            out.push("\n");
+    };
+    walk(root);
+    return out
+        .join("")
+        .split("\n")
+        .map((line) => line
+        .split("\t")
+        .map((cell) => cell.replace(/\s+/g, " ").trim())
+        .filter(Boolean)
+        .join(" | "))
+        .filter(Boolean)
+        .join("\n");
+}
+function collectLinks(root, pageUrl) {
+    const seen = new Set();
+    const links = [];
+    for (const a of Array.from(root.querySelectorAll("a[href]"))) {
+        let url;
+        try {
+            url = new URL(String(a.getAttribute("href")).trim(), pageUrl).href;
+        }
+        catch {
+            continue;
+        }
+        if (!/^https?:/i.test(url) || seen.has(url))
+            continue;
+        seen.add(url);
+        links.push({ url, text: String(a.textContent || "").replace(/\s+/g, " ").trim() });
+    }
+    return links;
+}

package/dist/refine/file-store.d.ts

@@ -0,0 +1,6 @@
+import type { MarkdownStore } from "../core/config";
+import type { RefineStore } from "./run";
+export interface FileStore extends RefineStore, MarkdownStore {
+    dir: string;
+}
+export declare function fileStore(dir: string): FileStore;

package/dist/refine/file-store.js

@@ -0,0 +1,87 @@
+"use strict";
+// A folder of refined docs, like the POC's changes/markdown-poc/md/:
+//
+//   <dir>/tool/notion.md     the document
+//   <dir>/tool/notion.json   { url, sourceHash, promptId, generatedAt, tokens }
+//   <dir>/index.md           the home page
+//
+// It is a RefineStore (the runner writes it) and a MarkdownStore (the engine's
+// "stored" step can read it): `store: fileStore(".agent-ready/md")` in the
+// config. Rejected docs are not written here; review them from the run report.
+//
+// NODE ONLY. node:fs is loaded on first use, so importing this file does not
+// pull fs into a bundle that never calls it.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileStore = fileStore;
+function fileStore(dir) {
+    const files = (path) => {
+        const clean = path.replace(/^\/+|\/+$/g, "");
+        if (clean.split("/").some((seg) => seg === ".." || seg === "." || seg.includes("\\"))) {
+            throw new Error(`agent-ready: bad path ${path}`);
+        }
+        const base = `${dir.replace(/[\\/]+$/, "")}/${clean || "index"}`;
+        return { md: `${base}.md`, meta: `${base}.json` };
+    };
+    const fs = () => Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+    return {
+        dir,
+        async lastHash(path) {
+            try {
+                const meta = JSON.parse(await (await fs()).readFile(files(path).meta, "utf8"));
+                return typeof meta.sourceHash === "string" ? meta.sourceHash : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        async save(doc) {
+            const { md, meta } = files(doc.path);
+            const f = await fs();
+            await f.mkdir(md.slice(0, md.lastIndexOf("/")), { recursive: true });
+            await f.writeFile(md, doc.markdown, "utf8");
+            const { markdown: _markdown, ...rest } = doc;
+            await f.writeFile(meta, JSON.stringify(rest, null, 2) + "\n", "utf8");
+        },
+        async get(path) {
+            try {
+                return await (await fs()).readFile(files(path).md, "utf8");
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}

package/dist/refine/model.d.ts

@@ -0,0 +1,30 @@
+export interface ModelRequest {
+    system: string;
+    user: string;
+    /** Output cap. Default 8000 (documents are budgeted at 2,200-3,000 tokens). */
+    maxTokens?: number;
+}
+export interface ModelReply {
+    text: string;
+    model: string;
+    inputTokens: number | null;
+    outputTokens: number | null;
+}
+export type ModelClient = (req: ModelRequest) => Promise<ModelReply>;
+export interface ProviderOptions {
+    apiKey: string;
+    model?: string;
+    baseUrl?: string;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+}
+export declare const DEFAULT_CLAUDE_MODEL = "claude-opus-5-5";
+export declare const DEFAULT_OPENAI_MODEL = "gpt-4o";
+export declare function anthropicModel(opts: ProviderOptions): ModelClient;
+export declare function openaiModel(opts: ProviderOptions & {
+    model: string;
+}): ModelClient;
+/** The model the env points at, or null when no key is set. */
+export declare function modelFromEnv(env: Record<string, string | undefined>, f?: typeof fetch): ModelClient | null;
+/** The document only: drops a ```markdown fence or any words before the frontmatter. */
+export declare function cleanReply(text: string): string;

package/dist/refine/model.js

@@ -0,0 +1,105 @@
+"use strict";
+// Refine, step 3: one model call per page. A model is just a function, so
+// tests pass a stub and a venture can bring any provider.
+//
+//   ANTHROPIC_API_KEY  -> Claude (default model claude-opus-5-5, the model the
+//                         POC files were written with)
+//   OPENAI_API_KEY     -> OpenAI (default model gpt-4o, the strongest model
+//                         Relve already uses elsewhere)
+//   AGENT_READY_MODEL  -> the model id, e.g. claude-haiku-5-5 or gpt-4o-mini;
+//                         a gpt-* / o* id picks OpenAI when both keys are set
+//
+// Plain fetch, no SDK. Errors throw with the status and a short body excerpt,
+// never the key. EDGE-SAFE (global fetch only).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_OPENAI_MODEL = exports.DEFAULT_CLAUDE_MODEL = void 0;
+exports.anthropicModel = anthropicModel;
+exports.openaiModel = openaiModel;
+exports.modelFromEnv = modelFromEnv;
+exports.cleanReply = cleanReply;
+exports.DEFAULT_CLAUDE_MODEL = "claude-opus-5-5";
+exports.DEFAULT_OPENAI_MODEL = "gpt-4o";
+function anthropicModel(opts) {
+    const model = opts.model ?? exports.DEFAULT_CLAUDE_MODEL;
+    const base = (opts.baseUrl ?? "https://api.anthropic.com").replace(/\/+$/, "");
+    return async (req) => {
+        const json = await post(opts, `${base}/v1/messages`, {
+            "x-api-key": opts.apiKey,
+            "anthropic-version": "2023-06-01",
+        }, {
+            model,
+            max_tokens: req.maxTokens ?? 8000,
+            system: req.system,
+            messages: [{ role: "user", content: req.user }],
+        });
+        const text = Array.isArray(json.content)
+            ? json.content.filter((c) => c?.type === "text").map((c) => c.text).join("")
+            : "";
+        return { text, model: json.model ?? model, inputTokens: json.usage?.input_tokens ?? null, outputTokens: json.usage?.output_tokens ?? null };
+    };
+}
+function openaiModel(opts) {
+    const base = (opts.baseUrl ?? "https://api.openai.com").replace(/\/+$/, "");
+    return async (req) => {
+        const json = await post(opts, `${base}/v1/chat/completions`, { authorization: `Bearer ${opts.apiKey}` }, {
+            model: opts.model,
+            max_completion_tokens: req.maxTokens ?? 8000,
+            messages: [
+                { role: "system", content: req.system },
+                { role: "user", content: req.user },
+            ],
+        });
+        return {
+            text: json.choices?.[0]?.message?.content ?? "",
+            model: json.model ?? opts.model,
+            inputTokens: json.usage?.prompt_tokens ?? null,
+            outputTokens: json.usage?.completion_tokens ?? null,
+        };
+    };
+}
+/** The model the env points at, or null when no key is set. */
+function modelFromEnv(env, f) {
+    const model = env.AGENT_READY_MODEL?.trim() || undefined;
+    const anthropicKey = env.ANTHROPIC_API_KEY?.trim();
+    const openaiKey = env.OPENAI_API_KEY?.trim();
+    const wantsOpenai = !!model && /^(gpt|o\d)/i.test(model);
+    if (anthropicKey && !wantsOpenai)
+        return anthropicModel({ apiKey: anthropicKey, model, fetch: f });
+    if (openaiKey) {
+        if (model && !wantsOpenai)
+            throw new Error(`agent-ready refine: ${model} is not an OpenAI model, and ANTHROPIC_API_KEY is not set.`);
+        return openaiModel({ apiKey: openaiKey, model: model ?? exports.DEFAULT_OPENAI_MODEL, fetch: f });
+    }
+    return null;
+}
+/** The document only: drops a ```markdown fence or any words before the frontmatter. */
+function cleanReply(text) {
+    let t = text.replace(/\r\n?/g, "\n").trim();
+    const fence = /^```(?:markdown|md)?\n([\s\S]*?)\n```$/.exec(t);
+    if (fence)
+        t = fence[1].trim();
+    const start = t.indexOf("---\n");
+    if (start > 0 && !t.startsWith("---"))
+        t = t.slice(start);
+    return t + "\n";
+}
+async function post(opts, url, headers, body) {
+    const f = opts.fetch ?? fetch;
+    const ctl = new AbortController();
+    const timer = setTimeout(() => ctl.abort(), opts.timeoutMs ?? 180000);
+    try {
+        const res = await f(url, {
+            method: "POST",
+            headers: { "content-type": "application/json", ...headers },
+            body: JSON.stringify(body),
+            signal: ctl.signal,
+        });
+        const text = await res.text();
+        if (!res.ok)
+            throw new Error(`model call failed: HTTP ${res.status} ${text.slice(0, 300)}`);
+        return JSON.parse(text);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}