@zanii/blackbox 0.0.0-stage → 0.2.0

package/dist/money/index.js

@@ -0,0 +1,622 @@
+// Money (spec/money.md): spend by model, the provider's statement against the record, cost
+// baselines per task, fuel to destination. Mirrors sdks/python/src/zanii_blackbox/money.py.
+import { sessionCost } from "../cost/index.js";
+const byKey = (m) => Object.fromEntries([...m.keys()].sort().map((k) => [k, m.get(k)]));
+/** `{model: micro_usd}` over the priced calls, sorted by model. */
+export function modelSpend(lines, prices) {
+    const m = new Map();
+    for (const c of sessionCost(lines, prices).calls)
+        if (c.micro_usd !== null && c.model !== null)
+            m.set(c.model, (m.get(c.model) ?? 0) + c.micro_usd);
+    return byKey(m);
+}
+/** Why a statement is invalid, or undefined. */
+export function checkStatement(s) {
+    const lines = s?.lines;
+    if (!Array.isArray(lines) ||
+        lines.length > 1000 ||
+        !lines.every((l) => typeof l === "object" &&
+            l !== null &&
+            typeof l.model === "string" &&
+            l.model.length > 0 &&
+            l.model.length <= 128 &&
+            Number.isSafeInteger(l.micro_usd) &&
+            l.micro_usd >= 0))
+        return "statement must be {lines: [{model, micro_usd}]}: at most 1000 lines, integer micro_usd ≥ 0";
+    return undefined;
+}
+export function reconcileBilling(ours, statement, tolerancePpm = 10_000) {
+    const theirs = new Map();
+    for (const l of statement.lines)
+        theirs.set(l.model, (theirs.get(l.model) ?? 0) + l.micro_usd);
+    const names = [...new Set([...Object.keys(ours), ...theirs.keys()])].sort();
+    const models = names.map((model) => {
+        const o = ours[model] ?? 0;
+        const t = theirs.get(model) ?? 0;
+        const diff = t - o;
+        const status = Math.abs(diff) * 1_000_000 <= tolerancePpm * Math.max(o, t)
+            ? "match"
+            : diff > 0
+                ? "provider_higher"
+                : "provider_lower";
+        return { model, ours: o, theirs: t, diff, status };
+    });
+    const oursTotal = models.reduce((n, m) => n + m.ours, 0);
+    const theirsTotal = models.reduce((n, m) => n + m.theirs, 0);
+    return {
+        v: 1,
+        tolerance_ppm: tolerancePpm,
+        ours_micro_usd: oursTotal,
+        theirs_micro_usd: theirsTotal,
+        diff_micro_usd: theirsTotal - oursTotal,
+        ok: models.every((m) => m.status === "match"),
+        models,
+    };
+}
+/** Nearest rank: the p-th of the sorted values is at index ceil(p·n/100) − 1. */
+function rank(values, p) {
+    const sorted = [...values].sort((a, b) => a - b);
+    return sorted[Math.max(0, Math.ceil((p * sorted.length) / 100) - 1)];
+}
+/** Per label, over successful sessions only (spec/money.md §3). */
+export function baselines(summaries) {
+    const by = new Map();
+    for (const s of summaries)
+        if (s.outcome === "success") {
+            const k = s.label ?? "(no label)";
+            by.set(k, [...(by.get(k) ?? []), s]);
+        }
+    return {
+        labels: [...by.keys()].sort().map((label) => {
+            const ss = by.get(label);
+            const spend = ss.map((s) => s.spend_micro_usd);
+            return {
+                label,
+                successes: ss.length,
+                median_spend_micro_usd: rank(spend, 50),
+                p90_spend_micro_usd: rank(spend, 90),
+                median_model_calls: rank(ss.map((s) => s.model_calls), 50),
+                median_tool_calls: rank(ss.map((s) => s.tool_calls), 50),
+            };
+        }),
+    };
+}
+/** Will the remaining budget reach the destination? (spec/money.md §4) */
+export function fuel(summary, budgetMicroUsd, baseline) {
+    const spent = summary.spend_micro_usd;
+    const expected = baseline ? Math.max(spent, baseline.median_spend_micro_usd) : null;
+    const p90 = baseline ? Math.max(spent, baseline.p90_spend_micro_usd) : null;
+    const verdict = expected === null || p90 === null
+        ? "unknown"
+        : budgetMicroUsd === null
+            ? "no_budget"
+            : p90 <= budgetMicroUsd
+                ? "likely"
+                : expected <= budgetMicroUsd
+                    ? "at_risk"
+                    : "unlikely";
+    return {
+        spent_micro_usd: spent,
+        budget_micro_usd: budgetMicroUsd,
+        expected_total_micro_usd: expected,
+        p90_total_micro_usd: p90,
+        verdict,
+    };
+}
+// ---------------------------------------------------------------- statements from cost APIs (§2a)
+const DECIMAL = /^(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/;
+/** Per unit: the power of ten to multiply by, and the divisor (AED at the CBUAE peg, 3.6725). */
+const UNITS = {
+    usd: [6, 1n],
+    cents: [4, 1n],
+    micro_usd: [0, 1n],
+    aed: [10, 36725n],
+};
+/** spec/money.md §2a-b: an exact decimal amount (string, or a JSON number's text) to integer
+ * micro-USD, rounded half up. `unit` is what the amount counts. */
+export function decimalToMicroUsd(value, unit) {
+    const text = typeof value === "number" && Number.isFinite(value) ? String(value) : value;
+    const m = typeof text === "string" ? DECIMAL.exec(text.trim()) : null;
+    const scale = UNITS[unit];
+    if (!m || !scale)
+        throw new Error(`not a non-negative decimal amount: ${JSON.stringify(value)}`);
+    const frac = m[2] ?? "";
+    const digits = BigInt(`${m[1]}${frac}`);
+    if (digits === 0n)
+        return 0;
+    const k = Number(m[3] ?? 0) - frac.length + scale[0];
+    if (k > 30)
+        throw new Error(`amount too large: ${JSON.stringify(value)}`);
+    const num = k >= 0 ? digits * 10n ** BigInt(k) : digits;
+    const den = scale[1] * (k >= 0 ? 1n : 10n ** BigInt(-k));
+    let micro = num / den;
+    if ((num % den) * 2n >= den)
+        micro += 1n;
+    if (micro > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new Error(`amount too large: ${JSON.stringify(value)}`);
+    return Number(micro);
+}
+const bucketsOf = (pages) => pages.flatMap((p) => p?.data ?? []);
+const resultsOf = (b) => b.results ?? [];
+function toStatement(m) {
+    if (m.size > 1000)
+        throw new Error("a statement holds at most 1,000 lines");
+    const names = [...m.keys()].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    return { lines: names.map((model) => ({ model, micro_usd: m.get(model) })) };
+}
+const add = (m, model, micro) => {
+    const key = model.slice(0, 128);
+    m.set(key, (m.get(key) ?? 0) + micro);
+};
+/** spec/money.md §2a: Anthropic's cost report pages (grouped by description) as a statement. */
+export function anthropicStatement(pages) {
+    const m = new Map();
+    for (const bucket of bucketsOf(pages))
+        for (const r of resultsOf(bucket)) {
+            if (r.currency !== "USD")
+                throw new Error(`unexpected currency ${JSON.stringify(r.currency)}`);
+            const model = typeof r.model === "string" && r.model !== ""
+                ? r.model
+                : `anthropic:${typeof r.cost_type === "string" && r.cost_type !== "" ? r.cost_type : "other"}`;
+            add(m, model, decimalToMicroUsd(r.amount, "cents"));
+        }
+    return toStatement(m);
+}
+/** spec/money.md §2a: OpenAI's organization costs pages (grouped by line_item) as a statement. */
+export function openaiStatement(pages) {
+    const m = new Map();
+    for (const bucket of bucketsOf(pages))
+        for (const r of resultsOf(bucket)) {
+            const amount = r.amount ?? {};
+            if (amount.currency !== "usd")
+                throw new Error(`unexpected currency ${JSON.stringify(amount.currency)}`);
+            const li = r.line_item;
+            const cut = typeof li === "string" ? li.lastIndexOf(", ") : -1;
+            const model = typeof li !== "string" || li === ""
+                ? "openai:unattributed"
+                : cut > 0
+                    ? li.slice(0, cut)
+                    : `openai:${li}`;
+            add(m, model, decimalToMicroUsd(amount.value, "usd"));
+        }
+    return toStatement(m);
+}
+// ---------------------------------------------------------------- any provider (§2b)
+/** spec/money.md §2b: every value at a path (`a.b[].c`, `[]` alone for a list itself). */
+export function resolvePath(value, path) {
+    let current = [value];
+    for (const seg of path.split(".")) {
+        const list = seg.endsWith("[]");
+        const key = list ? seg.slice(0, -2) : seg;
+        const next = [];
+        for (const v of current) {
+            const got = key === ""
+                ? v
+                : v !== null && typeof v === "object" && !Array.isArray(v)
+                    ? v[key]
+                    : undefined;
+            if (list) {
+                if (Array.isArray(got))
+                    next.push(...got);
+            }
+            else if (got !== undefined)
+                next.push(got);
+        }
+        current = next;
+    }
+    return current;
+}
+/** spec/money.md §2b: a CSV export with named columns as a statement. */
+export function csvStatement(text, opts) {
+    const rows = parseCsv(text.replace(/^/, ""), opts.delimiter ?? ",");
+    const header = rows.shift();
+    if (!header)
+        throw new Error("the CSV is empty");
+    const mi = header.indexOf(opts.model_column);
+    const ai = header.indexOf(opts.amount_column);
+    if (mi < 0)
+        throw new Error(`no column ${JSON.stringify(opts.model_column)}`);
+    if (ai < 0)
+        throw new Error(`no column ${JSON.stringify(opts.amount_column)}`);
+    const m = new Map();
+    rows.forEach((row, i) => {
+        if (row.length === 1 && row[0] === "")
+            return; // a blank line
+        if (row.length <= Math.max(mi, ai))
+            throw new Error(`row ${i + 2}: too few fields`);
+        let micro;
+        try {
+            micro = decimalToMicroUsd(row[ai], opts.unit);
+        }
+        catch {
+            throw new Error(`row ${i + 2}: ${JSON.stringify(row[ai])} isn't a plain decimal amount`);
+        }
+        add(m, row[mi].trim() || "unattributed", micro);
+    });
+    return toStatement(m);
+}
+/** RFC 4180-style: quoted fields, `""` for a quote, CRLF or LF. */
+function parseCsv(text, delimiter) {
+    const rows = [];
+    let row = [];
+    let field = "";
+    let quoted = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quoted) {
+            if (c === '"' && text[i + 1] === '"') {
+                field += '"';
+                i++;
+            }
+            else if (c === '"')
+                quoted = false;
+            else
+                field += c;
+        }
+        else if (c === '"' && field === "")
+            quoted = true;
+        else if (c === delimiter) {
+            row.push(field);
+            field = "";
+        }
+        else if (c === "\n" || c === "\r") {
+            if (c === "\r" && text[i + 1] === "\n")
+                i++;
+            row.push(field);
+            rows.push(row);
+            row = [];
+            field = "";
+        }
+        else
+            field += c;
+    }
+    if (quoted)
+        throw new Error("the CSV ends inside a quoted field");
+    if (field !== "" || row.length) {
+        row.push(field);
+        rows.push(row);
+    }
+    return rows;
+}
+const NAME = /^[a-z0-9][a-z0-9._-]{0,63}$/;
+const PATH = /^(\[\]|[A-Za-z0-9_$:@#-]+(\[\])?)(\.([A-Za-z0-9_$:@#-]+(\[\])?|\[\]))*$/;
+/** spec/money.md §2b: why a connector file is invalid, or undefined. */
+export function checkConnector(value) {
+    const c = value;
+    if (!c || typeof c !== "object" || Array.isArray(c))
+        return "a connector must be an object";
+    if (c.v !== 1)
+        return "v must be 1";
+    if (typeof c.name !== "string" || !NAME.test(c.name))
+        return "name must be 1-64 lowercase letters, digits, '.', '_' or '-'";
+    const url = c.request?.url;
+    if (typeof url !== "string")
+        return "request.url is required";
+    let parsed;
+    try {
+        parsed = new URL(url.replace(/\{(from|to)(_unix)?\}/g, "0"));
+    }
+    catch {
+        return "request.url isn't a URL";
+    }
+    const local = parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1";
+    if (!(parsed.protocol === "https:" || (parsed.protocol === "http:" && local)))
+        return "request.url must be https (http only for localhost)";
+    if (/\{env:/.test(url))
+        return "secrets go in request.headers, never in the URL";
+    const headers = c.request?.headers ?? {};
+    if (typeof headers !== "object" ||
+        Array.isArray(headers) ||
+        !Object.values(headers).every((v) => typeof v === "string"))
+        return "request.headers must map names to strings";
+    for (const k of ["results", "model", "amount"])
+        if (typeof c[k] !== "string" || !PATH.test(c[k]))
+            return `${k} must be a path`;
+    if (!c.unit || !(c.unit in UNITS))
+        return "unit must be usd, cents, micro_usd or aed";
+    if (c.currency !== undefined &&
+        (typeof c.currency?.path !== "string" ||
+            !PATH.test(c.currency.path) ||
+            typeof c.currency.equals !== "string"))
+        return "currency must be {path, equals}";
+    const method = c.request?.method ?? "GET";
+    if (method !== "GET" && method !== "POST")
+        return "request.method must be GET or POST";
+    const body = c.request?.body;
+    if (method === "GET" && (body !== undefined || c.request?.content_type !== undefined))
+        return "request.body and request.content_type are for POST";
+    if (method === "POST") {
+        if (typeof body !== "string" || Buffer.byteLength(body, "utf8") > 65_536)
+            return "a POST needs request.body, at most 64 KiB";
+        if (typeof c.request?.content_type !== "string" ||
+            !/^[\x21-\x7e][\x20-\x7e]{0,127}$/.test(c.request.content_type))
+            return "a POST needs request.content_type";
+        if (body.includes("{env:"))
+            return "secrets go in request.headers, never in the body";
+    }
+    if (c.format !== undefined && c.format !== "json" && c.format !== "xml")
+        return "format must be json or xml";
+    if (c.next !== undefined) {
+        const bad = checkNext(c.next);
+        if (bad)
+            return bad;
+    }
+    return undefined;
+}
+const PARAM = /^[A-Za-z0-9_[\].-]{1,64}$/;
+const intIn = (v, min, max) => Number.isSafeInteger(v) && v >= min && v <= max;
+function checkNext(next) {
+    const n = next;
+    const only = (keys) => Object.keys(n ?? {}).every((k) => keys.includes(k));
+    const param = (k) => typeof n?.[k] === "string" && PARAM.test(n[k]);
+    if (!n || typeof n !== "object" || Array.isArray(n))
+        return "next must be an object";
+    if ("cursor" in n) {
+        if (!only(["cursor", "param"]) ||
+            typeof n.cursor !== "string" ||
+            !PATH.test(n.cursor) ||
+            !param("param"))
+            return "next must be {cursor: path, param: query parameter name}";
+        return undefined;
+    }
+    if (n.size_param !== undefined && (!param("size_param") || n.size === undefined))
+        return "next.size_param must be a query parameter name, with next.size";
+    if (n.size !== undefined && !intIn(n.size, 1, 10_000))
+        return "next.size must be 1-10000";
+    if ("page_param" in n) {
+        if (!only(["page_param", "first_page", "size_param", "size"]) || !param("page_param"))
+            return "next must be {page_param, first_page?, size_param?, size?}";
+        if (n.first_page !== undefined && !intIn(n.first_page, 0, 1_000_000))
+            return "next.first_page must be 0 or more";
+        return undefined;
+    }
+    if ("offset_param" in n) {
+        if (!only(["offset_param", "size", "size_param"]) ||
+            !param("offset_param") ||
+            n.size === undefined)
+            return "next must be {offset_param, size, size_param?}";
+        return undefined;
+    }
+    return "next must have cursor, page_param or offset_param";
+}
+/** spec/money.md §2b: pages from a connector's API as a statement. */
+export function customStatement(pages, connector) {
+    const bad = checkConnector(connector);
+    if (bad)
+        throw new Error(`connector: ${bad}`);
+    const m = new Map();
+    for (const page of pages)
+        for (const row of resolvePath(page, connector.results)) {
+            if (connector.currency) {
+                const cur = resolvePath(row, connector.currency.path)[0];
+                if (cur !== connector.currency.equals)
+                    throw new Error(`unexpected currency ${JSON.stringify(cur)}`);
+            }
+            const model = resolvePath(row, connector.model)[0];
+            add(m, typeof model === "string" && model !== "" ? model : `${connector.name}:unattributed`, decimalToMicroUsd(resolvePath(row, connector.amount)[0], connector.unit));
+        }
+    return toStatement(m);
+}
+/** spec/money.md §2b: the query parameters for the next request, or null when there are no more. */
+export function pageParams(c, pages) {
+    const next = c.next;
+    const n = pages.length;
+    if (!next)
+        return n === 0 ? [] : null;
+    if ("cursor" in next) {
+        if (n === 0)
+            return [];
+        const v = resolvePath(pages[n - 1], next.cursor)[0];
+        return typeof v === "string" && v !== "" ? [[next.param, v]] : null;
+    }
+    const size = next.size;
+    const rows = n === 0 ? 0 : resolvePath(pages[n - 1], c.results).length;
+    if (n > 0 && (rows === 0 || (size !== undefined && rows < size)))
+        return null;
+    const sized = next.size_param !== undefined && size !== undefined ? [[next.size_param, String(size)]] : [];
+    if ("page_param" in next)
+        return [[next.page_param, String((next.first_page ?? 1) + n)], ...sized];
+    return [[next.offset_param, String(n * next.size)], ...sized];
+}
+// ---------------------------------------------------------------- XML (§2b)
+const XML_WS = " \t\r\n";
+const trimXml = (s) => {
+    let a = 0;
+    let b = s.length;
+    while (a < b && XML_WS.includes(s[a]))
+        a++;
+    while (b > a && XML_WS.includes(s[b - 1]))
+        b--;
+    return s.slice(a, b);
+};
+const XML_NAME = /^[A-Za-z_:][A-Za-z0-9_.:-]*/;
+const ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+function xmlDecode(s) {
+    let out = "";
+    let i = 0;
+    for (;;) {
+        const amp = s.indexOf("&", i);
+        if (amp < 0)
+            return out + s.slice(i);
+        out += s.slice(i, amp);
+        const semi = s.indexOf(";", amp);
+        const ref = semi < 0 ? "" : s.slice(amp + 1, semi);
+        let ch;
+        if (/^#x[0-9A-Fa-f]{1,6}$/.test(ref) || /^#[0-9]{1,7}$/.test(ref)) {
+            const cp = ref[1] === "x" ? Number.parseInt(ref.slice(2), 16) : Number.parseInt(ref.slice(1), 10);
+            const ok = cp === 0x9 ||
+                cp === 0xa ||
+                cp === 0xd ||
+                (cp >= 0x20 && cp <= 0xd7ff) ||
+                (cp >= 0xe000 && cp <= 0xfffd) ||
+                (cp >= 0x10000 && cp <= 0x10ffff);
+            if (ok)
+                ch = String.fromCodePoint(cp);
+        }
+        else
+            ch = ENTITIES[ref];
+        if (ch === undefined)
+            throw new Error(`XML: unknown entity &${ref.slice(0, 16)};`);
+        out += ch;
+        i = semi + 1;
+    }
+}
+/** spec/money.md §2b: XML as `{root: [value]}`. No DTDs, so no external or expanding entities. */
+export function parseXml(text) {
+    let i = text.charCodeAt(0) === 0xfeff ? 1 : 0;
+    const stack = [];
+    let root = null;
+    const fail = (msg) => {
+        throw new Error(`XML: ${msg} (at ${i})`);
+    };
+    const finish = (f) => {
+        const value = f.attrs.length === 0 && f.children.size === 0
+            ? trimXml(f.text)
+            : Object.fromEntries([
+                ...f.attrs.map(([k, v]) => [`@${k}`, v]),
+                ...(trimXml(f.text) !== "" ? [["#text", trimXml(f.text)]] : []),
+                ...f.children.entries(),
+            ]);
+        const parent = stack.at(-1);
+        if (parent) {
+            const list = parent.children.get(f.name);
+            if (list)
+                list.push(value);
+            else
+                parent.children.set(f.name, [value]);
+        }
+        else
+            root = [f.name, value];
+    };
+    const name = () => {
+        const m = XML_NAME.exec(text.slice(i, i + 256));
+        if (!m)
+            fail("a name was expected");
+        i += m[0].length;
+        return m[0];
+    };
+    const skipWs = () => {
+        while (i < text.length && XML_WS.includes(text[i]))
+            i++;
+    };
+    while (i < text.length) {
+        if (text.startsWith("<!--", i)) {
+            const end = text.indexOf("-->", i + 4);
+            if (end < 0)
+                fail("an unclosed comment");
+            i = end + 3;
+        }
+        else if (text.startsWith("<![CDATA[", i)) {
+            const end = text.indexOf("]]>", i + 9);
+            const top = stack.at(-1);
+            if (end < 0 || !top)
+                fail("CDATA outside an element, or unclosed");
+            top.text += text.slice(i + 9, end);
+            i = end + 3;
+        }
+        else if (text.startsWith("<!", i))
+            fail("DTDs and declarations aren't allowed");
+        else if (text.startsWith("<?", i)) {
+            const end = text.indexOf("?>", i + 2);
+            if (end < 0)
+                fail("an unclosed processing instruction");
+            i = end + 2;
+        }
+        else if (text.startsWith("</", i)) {
+            i += 2;
+            const n = name();
+            skipWs();
+            if (text[i] !== ">")
+                fail("'>' was expected");
+            i++;
+            const f = stack.pop();
+            if (!f || f.name !== n)
+                fail(`</${n}> doesn't close the open element`);
+            finish(f);
+        }
+        else if (text[i] === "<") {
+            i++;
+            if (root !== null)
+                fail("more than one root element");
+            if (stack.length >= 64)
+                fail("nesting deeper than 64");
+            const f = { name: name(), attrs: [], text: "", children: new Map() };
+            for (;;) {
+                skipWs();
+                if (text.startsWith("/>", i)) {
+                    i += 2;
+                    stack.push(f);
+                    finish(stack.pop());
+                    break;
+                }
+                if (text[i] === ">") {
+                    i++;
+                    stack.push(f);
+                    break;
+                }
+                const a = name();
+                skipWs();
+                if (text[i] !== "=")
+                    fail("'=' was expected");
+                i++;
+                skipWs();
+                const q = text[i];
+                if (q !== '"' && q !== "'")
+                    fail("a quoted value was expected");
+                const end = text.indexOf(q, i + 1);
+                if (end < 0)
+                    fail("an unclosed attribute value");
+                const raw = text.slice(i + 1, end);
+                if (raw.includes("<"))
+                    fail("'<' in an attribute value");
+                if (f.attrs.some(([k]) => k === a))
+                    fail(`attribute ${a} twice`);
+                f.attrs.push([a, xmlDecode(raw)]);
+                i = end + 1;
+            }
+        }
+        else {
+            const next = text.indexOf("<", i);
+            const chunk = text.slice(i, next < 0 ? text.length : next);
+            const top = stack.at(-1);
+            if (top)
+                top.text += xmlDecode(chunk);
+            else if (trimXml(chunk) !== "")
+                fail("text outside the root element");
+            i = next < 0 ? text.length : next;
+        }
+    }
+    if (stack.length)
+        fail(`<${stack.at(-1).name}> isn't closed`);
+    if (root === null)
+        fail("no root element");
+    const [rootName, rootValue] = root;
+    return Object.fromEntries([[rootName, [rootValue]]]);
+}
+const xmlEscape = (v) => v.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[c]);
+const jsonEscape = (v) => JSON.stringify(v).slice(1, -1);
+/** spec/money.md §2b: the next request a connector makes, or null when there are no more. */
+export function requestFor(c, pages, from, to) {
+    const params = pageParams(c, pages);
+    if (params === null)
+        return null;
+    const unix = (d) => String(Date.parse(`${d}T00:00:00Z`) / 1000);
+    const vars = { from, to, from_unix: unix(from), to_unix: unix(to) };
+    const url = c.request.url.replace(/\{(from|to|from_unix|to_unix)\}/g, (_, k) => encodeURIComponent(vars[k]));
+    if ((c.request.method ?? "GET") === "GET")
+        return { method: "GET", url, query: params };
+    const type = c.request.content_type.toLowerCase();
+    const esc = type.includes("xml")
+        ? xmlEscape
+        : type.includes("json")
+            ? jsonEscape
+            : (v) => v;
+    const next = c.next;
+    const vals = {
+        ...vars,
+        next: params[0]?.[1] ?? "",
+        size: next && "size" in next && next.size !== undefined ? String(next.size) : "",
+    };
+    const body = c.request.body.replace(/\{(from|to|from_unix|to_unix|next|size)\}/g, (_, k) => esc(vals[k]));
+    return { method: "POST", url, query: [], body, content_type: c.request.content_type };
+}