@spendgraph/harness 0.1.0

package/dist/harness.js

@@ -0,0 +1,187 @@
+import { Client } from "./core/client.js";
+import { Budget } from "./core/budget.js";
+import { PullCache } from "./core/cache.js";
+import { pullWithCache } from "./core/pull.js";
+import { serializeFields } from "./core/schema/serialize.js";
+import { renderMessages } from "./prompt/render.js";
+import { newRolloutId, runAcrossModels, runOnce, sampleRuns } from "./prompt/run.js";
+export class Harness {
+    client;
+    cache;
+    hasKey;
+    onReportError;
+    concurrency;
+    budget;
+    constructor(opts) {
+        const { cache, onReportError, onPullError, concurrency, maxCostMicros, ...clientOpts } = opts;
+        this.client = new Client(clientOpts);
+        // Spread first, then the wiring — the other order let a `cache` object
+        // carrying `onRefreshError: undefined` silently discard `onPullError`.
+        this.cache = new PullCache({
+            ...cache,
+            onRefreshError: cache?.onRefreshError ?? onPullError,
+            // What a cached prompt answers to, so an invalidation by uuid also
+            // catches the slug production actually pulled by, and vice versa.
+            identify: (p) => [p.id, p.slug].filter((v) => Boolean(v)),
+        });
+        this.hasKey = Boolean(opts.apiKey);
+        this.onReportError = onReportError;
+        this.concurrency = Math.max(1, concurrency ?? 4);
+        this.budget = new Budget("maxCostMicros" in opts ? maxCostMicros : undefined);
+    }
+    /**
+     * A prompt, from cache when one is warm.
+     *
+     * Serves a stale copy immediately and refreshes behind the caller, so an edit
+     * takes effect within a TTL without any request ever paying for the fetch.
+     *
+     * Takes an id or a slug — the server resolves either. Cached under whatever
+     * you passed, so pulling the same prompt both ways keeps two entries.
+     *
+     * A slug is only as stable as the prompt's name: renaming it server-side
+     * mints a new one and the old stops resolving, at which point the background
+     * refresh 404s and this keeps serving the wording it last saw. Pull by id
+     * where a handle has to outlive an edit to the name.
+     */
+    async pull(promptId) {
+        const payload = await pullWithCache(this.cache, promptId, async () => {
+            const res = await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}`);
+            return res.prompt;
+        });
+        const serialize = (values = {}) => serializeFields(values, payload.fieldSpec ?? []);
+        return {
+            id: payload.id,
+            name: payload.name,
+            slug: payload.slug ?? null,
+            fields: payload.fieldSpec ?? [],
+            versionId: payload.currentVersionId ?? null,
+            models: payload.models ?? [],
+            serialize,
+            render: (values = {}) => renderMessages(payload.blocks, payload.question, serialize(values)),
+        };
+    }
+    /**
+     * Runs the prompt server-side and records the rollout.
+     *
+     * The batch path. A production request should pull, render and report
+     * instead — this adds a hop and makes spendgraph a dependency of the caller's
+     * uptime, which is the right trade for evaluation and the wrong one for a
+     * user waiting on a response.
+     */
+    async run(promptId, values = {}, opts = {}) {
+        return runOnce(this.client, promptId, values, opts, this.budget);
+    }
+    /** k repetitions of one case. Always k results, failures included. */
+    async sample(promptId, values = {}, opts = {}) {
+        return sampleRuns(this.client, promptId, values, { concurrency: this.concurrency, ...opts }, this.budget);
+    }
+    /** One rollout per model — the playground's comparison, headless. */
+    async runAll(promptId, values = {}, opts = {}) {
+        const models = opts.models ?? (await this.pull(promptId)).models;
+        if (models.length === 0) {
+            throw new Error("No models given and the prompt has none saved.");
+        }
+        return runAcrossModels(this.client, promptId, values, models, { concurrency: this.concurrency, ...opts }, this.budget);
+    }
+    /** The dataset a prompt is evaluated against, with its split counts. */
+    async cases(promptId) {
+        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/cases`);
+    }
+    /**
+     * Replaces the whole dataset.
+     *
+     * A dataset is a set: "which cases am I evaluating against" has one answer at
+     * a time, and a merge would leave no way to remove a case or to know from the
+     * outside what the set currently is.
+     */
+    async setCases(promptId, cases) {
+        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/cases`, { method: "PUT", body: JSON.stringify({ cases }) });
+    }
+    /** Micro-dollars this client has spent on runs it initiated. */
+    spent() {
+        return this.budget.spent();
+    }
+    /** What is left of the ceiling, or Infinity when none was set. */
+    remaining() {
+        return this.budget.remaining();
+    }
+    /** Every wording this prompt has had, newest first. */
+    async versions(promptId, opts = {}) {
+        const q = new URLSearchParams();
+        if (opts.origin)
+            q.set("origin", opts.origin);
+        if (opts.limit)
+            q.set("limit", String(opts.limit));
+        const suffix = q.size ? `?${q}` : "";
+        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/versions${suffix}`);
+    }
+    /**
+     * Serves this version from now on.
+     *
+     * Invalidates the cache: a promotion that left a warm entry in place would
+     * keep sending the old wording for up to a TTL, which is the one moment a
+     * caller is actively watching for the change.
+     */
+    async promote(promptId, versionId) {
+        const res = await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/versions`, {
+            method: "POST",
+            body: JSON.stringify({ versionId }),
+        });
+        this.invalidate(promptId);
+        return res;
+    }
+    /**
+     * Drops whatever is cached, so the next pull refetches.
+     *
+     * Both handles, not just the one passed. `pull` keys the cache on whatever
+     * string it was given, so the same prompt can sit under its uuid and its
+     * slug at once — and `promote` is only reachable with a uuid while the
+     * dashboard teaches pulling by slug. Dropping one key left the other warm
+     * for a full TTL, still rendering the wording the promotion replaced, which
+     * is the exact case this method exists to prevent.
+     */
+    invalidate(promptId) {
+        if (!promptId) {
+            this.cache.clear();
+            return;
+        }
+        // Matched on the payload, not on the key handed in. Reading the entry under
+        // `promptId` only finds the sibling when that key was the cached one — and
+        // the case this exists for is the opposite: production pulled by slug, so
+        // the slug is the only key, while `promote` is reachable only with a uuid.
+        for (const key of this.cache.keysWhere((p) => p.id === promptId || p.slug === promptId)) {
+            this.cache.delete(key);
+        }
+        // Always, even with nothing stored under it: a cold isolate has a fetch in
+        // flight under this handle and no entry yet, and delete is what bumps the
+        // epoch that stops the in-flight result being stored after the promotion.
+        this.cache.delete(promptId);
+        // Recorded against the name as well, so a fetch still in flight — which
+        // carries no payload yet to say which prompt it is for — is judged when it
+        // lands rather than guessed at now. This is what replaced dropping every
+        // unrelated outstanding fetch on any promote.
+        this.cache.invalidate(promptId);
+    }
+    /**
+     * Records a rollout the caller executed.
+     *
+     * Never throws and never rejects. This sits beside a user-facing request that
+     * has already been answered; telemetry that can break the thing it measures
+     * is worse than no telemetry. Failures go to `onReportError` and are dropped.
+     *
+     * Returns the rollout id it used, so a caller that wants to retry the exact
+     * same record can pass it back and land on one row.
+     */
+    async report(promptId, input) {
+        const rolloutId = input.rolloutId ?? newRolloutId();
+        if (!this.hasKey)
+            return rolloutId;
+        try {
+            await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/rollouts`, { method: "POST", body: JSON.stringify({ ...input, rolloutId }) });
+        }
+        catch (err) {
+            this.onReportError?.(err);
+        }
+        return rolloutId;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { Harness, type HarnessOptions } from "./harness.js";
+export { Budget, BudgetExceededError, Client, HarnessError, PullCache, pullWithCache, type CacheHit, type CacheOptions, type ClientOptions, } from "./core/index.js";
+export type { FieldSpec, FieldType } from "./core/schema/types.js";
+export { FieldValidationError, validateFields, type FieldError, } from "./core/schema/validate.js";
+export { serializeFields } from "./core/schema/serialize.js";
+export { applyVariables, compileSystemPrompt, findVariables, renderMessages, type Block, type Message, } from "./prompt/render.js";
+export { mapLimit, newRolloutId } from "./prompt/run.js";
+export { emitPromptTypes, typeOf, valuesTypeFor, type CodegenPrompt, type EmitOptions, } from "./prompt/codegen.js";
+export type { DatasetCase, DatasetSummary, Prompt, PromptPayload, ReportInput, Rollout, RunOptions, PromptVersion, Prompts, RunResult, Split, ValuesFor, } from "./prompt/types.js";

package/dist/index.js

@@ -0,0 +1,7 @@
+export { Harness } from "./harness.js";
+export { Budget, BudgetExceededError, Client, HarnessError, PullCache, pullWithCache, } from "./core/index.js";
+export { FieldValidationError, validateFields, } from "./core/schema/validate.js";
+export { serializeFields } from "./core/schema/serialize.js";
+export { applyVariables, compileSystemPrompt, findVariables, renderMessages, } from "./prompt/render.js";
+export { mapLimit, newRolloutId } from "./prompt/run.js";
+export { emitPromptTypes, typeOf, valuesTypeFor, } from "./prompt/codegen.js";

package/dist/prompt/codegen.d.ts

@@ -0,0 +1,37 @@
+import type { FieldSpec } from "../core/schema/types.js";
+/** The shape codegen needs from a prompt — a narrow slice of the payload. */
+export interface CodegenPrompt {
+    id: string;
+    /** The other handle `pull` and `run` accept, so it needs a key too. */
+    slug?: string | null;
+    name: string;
+    fieldSpec: FieldSpec[];
+}
+/**
+ * The TypeScript type a declared field accepts.
+ *
+ * `enum` becomes a union of its options rather than `string`, which is the whole
+ * reason a caller feels the difference: a typo in a tone or a format is caught
+ * where it is written instead of at the other end of a paid request.
+ */
+export declare function typeOf(field: FieldSpec): string;
+/** `{ name: type }`, or `Record<string, never>` when the prompt takes nothing. */
+export declare function valuesTypeFor(fields: FieldSpec[], indent?: string): string;
+export interface EmitOptions {
+    /** The package specifier being augmented. Overridable for tests and forks. */
+    module?: string;
+}
+/**
+ * A `.d.ts` that teaches TypeScript what each stored prompt expects.
+ *
+ * Declaration merging rather than a generated client: the caller keeps importing
+ * `Harness` from the package, and the generated file only sharpens the types it
+ * already has. Nothing breaks if the file is deleted or goes stale — calls fall
+ * back to `Record<string, unknown>`, and the runtime validation that always runs
+ * catches what the compiler then cannot.
+ *
+ * `export {}` at the end is load-bearing: without it the file is a script rather
+ * than a module, and `declare module` would replace the package's types instead
+ * of adding to them.
+ */
+export declare function emitPromptTypes(prompts: CodegenPrompt[], opts?: EmitOptions): string;

package/dist/prompt/codegen.js

@@ -0,0 +1,97 @@
+/** JSON string literal, so a quote or newline in an option cannot break the file. */
+function lit(value) {
+    return JSON.stringify(value);
+}
+/**
+ * The TypeScript type a declared field accepts.
+ *
+ * `enum` becomes a union of its options rather than `string`, which is the whole
+ * reason a caller feels the difference: a typo in a tone or a format is caught
+ * where it is written instead of at the other end of a paid request.
+ */
+export function typeOf(field) {
+    switch (field.type) {
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "enum": {
+            const options = field.options ?? [];
+            // An enum with no options declared cannot be narrowed to anything useful,
+            // and `never` would make the prompt uncallable.
+            return options.length ? options.map(lit).join(" | ") : "string";
+        }
+        case "list":
+            return "string[]";
+        case "json":
+            return "unknown";
+        default:
+            return "string";
+    }
+}
+/** A field may be omitted when it is optional or carries a default. */
+function isOptional(field) {
+    return !field.required || field.default !== undefined;
+}
+/** `{ name: type }`, or `Record<string, never>` when the prompt takes nothing. */
+export function valuesTypeFor(fields, indent = "    ") {
+    if (fields.length === 0)
+        return "Record<string, never>";
+    const lines = fields.map((f) => {
+        const doc = f.description ? `${indent}  /** ${f.description.replace(/\*\//g, "*\\/")} */\n` : "";
+        const key = /^[A-Za-z_$][\w$]*$/.test(f.name) ? f.name : lit(f.name);
+        return `${doc}${indent}  ${key}${isOptional(f) ? "?" : ""}: ${typeOf(f)};`;
+    });
+    return `{\n${lines.join("\n")}\n${indent}}`;
+}
+/**
+ * A `.d.ts` that teaches TypeScript what each stored prompt expects.
+ *
+ * Declaration merging rather than a generated client: the caller keeps importing
+ * `Harness` from the package, and the generated file only sharpens the types it
+ * already has. Nothing breaks if the file is deleted or goes stale — calls fall
+ * back to `Record<string, unknown>`, and the runtime validation that always runs
+ * catches what the compiler then cannot.
+ *
+ * `export {}` at the end is load-bearing: without it the file is a script rather
+ * than a module, and `declare module` would replace the package's types instead
+ * of adding to them.
+ */
+export function emitPromptTypes(prompts, opts = {}) {
+    // Not named `module`: the app's eslint config forbids assigning that
+    // identifier, and this package is linted under it.
+    const importFrom = opts.module ?? "@spendgraph/harness";
+    // Sorted by id so regenerating an unchanged project produces no diff.
+    const sorted = [...prompts].sort((a, b) => a.id.localeCompare(b.id));
+    const entries = sorted.map((p) => {
+        const name = p.name ? `${indentDoc(p.name)}\n` : "";
+        const values = valuesTypeFor(p.fieldSpec ?? []);
+        // A key per handle. `pull` and `run` accept an id or a slug, and the
+        // dashboard's Use-in-code tab hands out the slug — so keying on the id
+        // alone meant every snippet the product prints fell through
+        // `ValuesFor<K>` to `Record<string, unknown>` and lost the checking this
+        // file exists to provide, silently.
+        const keys = p.slug && p.slug !== p.id ? [p.id, p.slug] : [p.id];
+        return keys.map((k) => `${name}    ${lit(k)}: ${values};`).join("\n");
+    });
+    const body = entries.length
+        ? entries.join("\n")
+        : "    // No prompts found. Run `harness codegen` again after saving one.";
+    return `// Generated by \`harness codegen\`. Do not edit.
+//
+// Sharpens the id and values arguments of Harness methods. Deleting this file
+// is safe: calls fall back to a loose \`Record<string, unknown>\`, and the
+// runtime field validation is unchanged either way.
+
+declare module ${lit(importFrom)} {
+  interface Prompts {
+${body}
+  }
+}
+
+export {};
+`;
+}
+function indentDoc(text) {
+    return `    /** ${text.replace(/\*\//g, "*\\/")} */`;
+}

package/dist/prompt/render.d.ts

@@ -0,0 +1,35 @@
+export type Block = {
+    title: string;
+    body: string;
+};
+export type Message = {
+    role: "system" | "user";
+    content: string;
+};
+/**
+ * Substitutes `{name}` placeholders. An unknown one is left verbatim — silently
+ * emptying it would send a prompt with a hole the caller cannot see.
+ *
+ * Mirrors `lib/prompt.ts` in the app, deliberately duplicated: this package is
+ * published and depends on nothing. The two are kept in step by
+ * `rendered` being recorded on every rollout, which makes a divergence visible
+ * rather than theoretical.
+ */
+export declare function applyVariables(text: string, values: Record<string, string> | undefined): string;
+/** Placeholder names used anywhere in the prompt, in first-seen order. */
+export declare function findVariables(blocks: Block[], question: string): string[];
+/**
+ * Blocks in the order they were arranged.
+ *
+ * An empty body drops the block entirely — a heading over nothing is noise in
+ * the prompt. A body with no title is emitted bare rather than under a blank
+ * `##`, so an unnamed block still says what it says.
+ */
+export declare function compileSystemPrompt(blocks: Block[], values?: Record<string, string>): string;
+/**
+ * Every message the request will send, in order.
+ *
+ * An empty system message is a different request from no system message at all,
+ * so a prompt with no blocks sends one message rather than two.
+ */
+export declare function renderMessages(blocks: Block[], question: string, values?: Record<string, string>): Message[];

package/dist/prompt/render.js

@@ -0,0 +1,66 @@
+/**
+ * Substitutes `{name}` placeholders. An unknown one is left verbatim — silently
+ * emptying it would send a prompt with a hole the caller cannot see.
+ *
+ * Mirrors `lib/prompt.ts` in the app, deliberately duplicated: this package is
+ * published and depends on nothing. The two are kept in step by
+ * `rendered` being recorded on every rollout, which makes a divergence visible
+ * rather than theoretical.
+ */
+export function applyVariables(text, values) {
+    if (!text || !values)
+        return text;
+    return text.replace(/\{(\w+)\}/g, (whole, name) => name in values ? values[name] : whole);
+}
+/** Placeholder names used anywhere in the prompt, in first-seen order. */
+export function findVariables(blocks, question) {
+    const seen = [];
+    const scan = (text) => {
+        for (const m of text.matchAll(/\{(\w+)\}/g)) {
+            if (!seen.includes(m[1]))
+                seen.push(m[1]);
+        }
+    };
+    // titles too — a heading can carry a placeholder as readily as a body
+    for (const b of blocks ?? []) {
+        scan(b.title ?? "");
+        scan(b.body ?? "");
+    }
+    scan(question);
+    return seen;
+}
+/**
+ * Blocks in the order they were arranged.
+ *
+ * An empty body drops the block entirely — a heading over nothing is noise in
+ * the prompt. A body with no title is emitted bare rather than under a blank
+ * `##`, so an unnamed block still says what it says.
+ */
+export function compileSystemPrompt(blocks, values) {
+    const out = [];
+    for (const b of blocks ?? []) {
+        const body = b.body?.trim();
+        if (!body)
+            continue;
+        const title = b.title?.trim();
+        const text = applyVariables(body, values);
+        out.push(title ? `## ${applyVariables(title, values)}\n${text}` : text);
+    }
+    return out.join("\n\n");
+}
+/**
+ * Every message the request will send, in order.
+ *
+ * An empty system message is a different request from no system message at all,
+ * so a prompt with no blocks sends one message rather than two.
+ */
+export function renderMessages(blocks, question, values) {
+    const system = compileSystemPrompt(blocks, values);
+    const user = applyVariables(question, values);
+    return system
+        ? [
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ]
+        : [{ role: "user", content: user }];
+}

package/dist/prompt/run.d.ts

@@ -0,0 +1,38 @@
+import type { Budget } from "../core/budget.js";
+import type { Client } from "../core/client.js";
+import type { RunOptions, RunResult } from "./types.js";
+/** Generated per attempt so a retry of the same call lands on one row. */
+export declare function newRolloutId(): string;
+/**
+ * Runs `fn` over `items` with at most `limit` in flight.
+ *
+ * Bounded on purpose. Firing a whole dataset at once turns most of it into 429s
+ * that you still wait out, so the unbounded version finishes later and flakier
+ * than the bounded one.
+ */
+export declare function mapLimit<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+export declare function runOnce(client: Client, promptId: string, values: Record<string, unknown>, opts?: RunOptions, budget?: Budget): Promise<RunResult>;
+/**
+ * k repetitions of one case, so `pass^k` is computable.
+ *
+ * Always returns k results. A seed that failed is present with
+ * `status: "failed"` rather than missing: returning three results for k = 5
+ * would have the reliability metric compute over three and report better
+ * consistency than the run actually showed.
+ *
+ * A budget stop is the exception, and it throws. Money running out says nothing
+ * about how reliable the prompt is, so recording those seeds as failures would
+ * push a number into pass^k that is about the wallet rather than the model.
+ *
+ * `seed` is metadata, not a provider parameter. Anthropic exposes none and
+ * OpenAI's is best-effort; it records which repetition a row is, which is all
+ * pass^k needs.
+ */
+export declare function sampleRuns(client: Client, promptId: string, values: Record<string, unknown>, opts?: RunOptions & {
+    k?: number;
+    concurrency?: number;
+}, budget?: Budget): Promise<RunResult[]>;
+/** One rollout per model — the playground's comparison, headless. */
+export declare function runAcrossModels(client: Client, promptId: string, values: Record<string, unknown>, models: string[], opts?: RunOptions & {
+    concurrency?: number;
+}, budget?: Budget): Promise<RunResult[]>;

package/dist/prompt/run.js

@@ -0,0 +1,96 @@
+import { BudgetExceededError } from "../core/budget.js";
+/** Generated per attempt so a retry of the same call lands on one row. */
+export function newRolloutId() {
+    return `ro_${crypto.randomUUID().replace(/-/g, "")}`;
+}
+/**
+ * Runs `fn` over `items` with at most `limit` in flight.
+ *
+ * Bounded on purpose. Firing a whole dataset at once turns most of it into 429s
+ * that you still wait out, so the unbounded version finishes later and flakier
+ * than the bounded one.
+ */
+export async function mapLimit(items, limit, fn) {
+    const out = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, async () => {
+        while (next < items.length) {
+            const i = next++;
+            out[i] = await fn(items[i], i);
+        }
+    });
+    await Promise.all(workers);
+    return out;
+}
+export async function runOnce(client, promptId, values, opts = {}, budget) {
+    budget?.assertAffordable();
+    const rolloutId = opts.rolloutId ?? newRolloutId();
+    const res = await client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/run`, {
+        method: "POST",
+        body: JSON.stringify({
+            rolloutId,
+            values,
+            model: opts.model,
+            temperature: opts.temperature,
+            maxTokens: opts.maxTokens,
+            seed: opts.seed ?? 0,
+            caseId: opts.caseId,
+            candidateId: opts.candidateId,
+            parentId: opts.parentId,
+            generation: opts.generation,
+            record: opts.record ?? true,
+        }),
+    });
+    // A deduped reply costs nothing new, but its cost is already in the total from
+    // the attempt that wrote it, so counting it again would overstate the spend.
+    if (!res.deduped)
+        budget?.add(res.rollout.costMicros ?? 0);
+    return res.rollout;
+}
+/**
+ * k repetitions of one case, so `pass^k` is computable.
+ *
+ * Always returns k results. A seed that failed is present with
+ * `status: "failed"` rather than missing: returning three results for k = 5
+ * would have the reliability metric compute over three and report better
+ * consistency than the run actually showed.
+ *
+ * A budget stop is the exception, and it throws. Money running out says nothing
+ * about how reliable the prompt is, so recording those seeds as failures would
+ * push a number into pass^k that is about the wallet rather than the model.
+ *
+ * `seed` is metadata, not a provider parameter. Anthropic exposes none and
+ * OpenAI's is best-effort; it records which repetition a row is, which is all
+ * pass^k needs.
+ */
+export async function sampleRuns(client, promptId, values, opts = {}, budget) {
+    const k = Math.max(1, opts.k ?? 5);
+    const seeds = Array.from({ length: k }, (_, i) => i);
+    return mapLimit(seeds, opts.concurrency ?? 4, async (seed) => {
+        try {
+            return await runOnce(client, promptId, values, { ...opts, seed, rolloutId: undefined }, budget);
+        }
+        catch (err) {
+            if (err instanceof BudgetExceededError)
+                throw err;
+            // A transport failure is still an outcome for this seed. Throwing would
+            // discard the k-1 results that did come back.
+            return {
+                id: null,
+                model: opts.model ?? "",
+                status: "failed",
+                output: "",
+                error: err.message,
+                costMicros: 0,
+                latencyMs: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                seed,
+            };
+        }
+    });
+}
+/** One rollout per model — the playground's comparison, headless. */
+export async function runAcrossModels(client, promptId, values, models, opts = {}, budget) {
+    return mapLimit(models, opts.concurrency ?? 4, (model) => runOnce(client, promptId, values, { ...opts, model, rolloutId: undefined }, budget));
+}