@spendgraph/prompt 0.2.0

package/dist/prompt/bind.d.ts

@@ -0,0 +1,60 @@
+import type { History, Message } from "../render/index.js";
+import type { Prompt, TraceOutcome } from "../types/index.js";
+/**
+ * Anything that can answer a list of messages.
+ *
+ * Structural on purpose: `Llm` from `@spendgraph/llms` satisfies it because its
+ * `LlmReply` is a `TraceOutcome`, so binding one costs neither package an
+ * import of the other.
+ */
+export interface Model {
+    call(messages: Message[], opts?: ModelOptions): Promise<TraceOutcome> | TraceOutcome;
+    /** Optional. `chain.stream` falls back to `call` when a model cannot stream. */
+    stream?(messages: Message[], opts?: ModelOptions): Promise<TraceOutcome> | TraceOutcome;
+}
+export interface ModelOptions {
+    /** The turn selected for this call — structurally a tool bus. */
+    tools?: unknown;
+    onText?: (delta: string) => void;
+}
+export interface InvokeOptions {
+    /** Prior turns, oldest first. */
+    history?: History;
+    /** A bus to select from. The turn is passed to the model and to the rollout. */
+    tools?: {
+        trace(query?: string, limit?: number): {
+            record(): unknown;
+        };
+    };
+    /** What to select tools on. Defaults to the rendered question. */
+    query?: string;
+    /** False runs the model and records nothing. */
+    report?: boolean;
+    /** Supply your own to make a retry safe. */
+    rolloutId?: string;
+}
+export interface BatchOptions extends InvokeOptions {
+    /** Max calls in flight. Default 4. */
+    concurrency?: number;
+}
+export type Answer = TraceOutcome & {
+    rolloutId: string;
+};
+/** A prompt with a model attached. */
+export interface Chain {
+    /** Render, call the model, record. The one-liner. */
+    invoke(values?: Record<string, unknown>, opts?: InvokeOptions): Promise<Answer>;
+    /** The same, streamed. `onText` receives each delta as it arrives. */
+    stream(values?: Record<string, unknown>, opts?: InvokeOptions & {
+        onText?: (delta: string) => void;
+    }): Promise<Answer>;
+    /** One call per set of values, concurrency-capped. */
+    batch(values: Record<string, unknown>[], opts?: BatchOptions): Promise<Answer[]>;
+}
+/**
+ * Attaches a model, so the prompt can run itself.
+ *
+ * Without this you hand the call to `prompt.call`; with it the call is already
+ * known and `invoke` is the whole thing.
+ */
+export declare function bind(prompt: Prompt, model: Model): Chain;

package/dist/prompt/bind.js

@@ -0,0 +1,21 @@
+import { mapLimit } from "../run/concurrency.js";
+const DEFAULT_CONCURRENCY = 4;
+/**
+ * Attaches a model, so the prompt can run itself.
+ *
+ * Without this you hand the call to `prompt.call`; with it the call is already
+ * known and `invoke` is the whole thing.
+ */
+export function bind(prompt, model) {
+    const once = (values, opts, streaming) => prompt.call(values, ({ messages, turn }) => {
+        const modelOpts = { tools: turn, onText: opts.onText };
+        return streaming && model.stream
+            ? model.stream(messages, modelOpts)
+            : model.call(messages, modelOpts);
+    }, opts);
+    return {
+        invoke: (values = {}, opts = {}) => once(values, opts, false),
+        stream: (values = {}, opts = {}) => once(values, opts, true),
+        batch: (values, opts = {}) => mapLimit(values, opts.concurrency ?? DEFAULT_CONCURRENCY, (v) => once(v, opts, false)),
+    };
+}

package/dist/prompt/factory.d.ts

@@ -0,0 +1,49 @@
+import type { FieldSpec } from "@spendgraph/sdk";
+import type { Block } from "../render/index.js";
+import type { Prompt, PromptSource, ReportInput } from "../types/index.js";
+/** Everything the factory needs about the wording, however it was obtained. */
+export interface PromptShape {
+    id: string;
+    name: string;
+    slug: string | null;
+    blocks: Block[];
+    question: string;
+    fields: FieldSpec[];
+    versionId: string | null;
+    models: string[];
+}
+/**
+ * Where a finished call goes.
+ *
+ * A server prompt writes a rollout; a custom one has no row to hang one on and
+ * writes usage instead. Injecting it is what lets both constructors share one
+ * `trace`, so the two can never drift on what "recorded" means.
+ */
+export interface Recorder {
+    enabled: boolean;
+    /**
+     * Records one rollout.
+     *
+     * May return what the server priced it at, in micro-USD. Callers that do not
+     * wait for it are unaffected — the write is still fire-and-forget, and the
+     * promise is only there for `call({ awaitCost: true })` to take.
+     */
+    write(promptId: string, entry: ReportInput): void | Promise<number | undefined>;
+}
+export declare const noRecorder: Recorder;
+/**
+ * What the rollout route accepts in one record.
+ *
+ * A conversation longer than this still runs — only its rollout is refused, and
+ * that refusal reaches `onReportError` rather than the caller, so it is said
+ * here instead while there is still somebody watching.
+ */
+export declare const MAX_RECORDED_MESSAGES = 50;
+/**
+ * The `Prompt` both constructors return.
+ *
+ * `pullPrompt` and `buildCustomPrompt` differ only in where the wording came
+ * from and what the recorder does with the result — everything a caller
+ * touches is built here, once.
+ */
+export declare function makePrompt(shape: PromptShape, source: PromptSource, recorder?: Recorder): Prompt;

package/dist/prompt/factory.js

@@ -0,0 +1,118 @@
+import { serializeFields } from "@spendgraph/sdk";
+import { renderMessages } from "../render/index.js";
+import { newRolloutId } from "../run/id.js";
+import { bind } from "./bind.js";
+export const noRecorder = {
+    enabled: false,
+    write: () => { },
+};
+/**
+ * What the rollout route accepts in one record.
+ *
+ * A conversation longer than this still runs — only its rollout is refused, and
+ * that refusal reaches `onReportError` rather than the caller, so it is said
+ * here instead while there is still somebody watching.
+ */
+export const MAX_RECORDED_MESSAGES = 50;
+let warnedAboutLength = false;
+function warnIfUnrecordable(messages) {
+    if (warnedAboutLength || messages.length <= MAX_RECORDED_MESSAGES)
+        return;
+    warnedAboutLength = true;
+    console.warn(`[prompt] ${messages.length} messages is over the ${MAX_RECORDED_MESSAGES} a rollout ` +
+        "can record. The call still runs; the rollout will be rejected. Trim the history you pass.");
+}
+function lastUserMessage(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "user")
+            return messages[i].content;
+    }
+    return "";
+}
+/**
+ * The `Prompt` both constructors return.
+ *
+ * `pullPrompt` and `buildCustomPrompt` differ only in where the wording came
+ * from and what the recorder does with the result — everything a caller
+ * touches is built here, once.
+ */
+export function makePrompt(shape, source, recorder = noRecorder) {
+    const serialize = (values = {}) => serializeFields(values, shape.fields);
+    const format = (values = {}, opts = {}) => renderMessages(shape.blocks, shape.question, serialize(values), opts.history);
+    const built = {
+        id: shape.id,
+        name: shape.name,
+        slug: shape.slug,
+        fields: shape.fields,
+        versionId: shape.versionId,
+        models: shape.models,
+        source,
+        serialize,
+        format,
+        async call(values, run, opts = {}) {
+            const messages = format(values, { history: opts.history });
+            warnIfUnrecordable(messages);
+            const turn = opts.tools?.trace(opts.query ?? lastUserMessage(messages));
+            const rolloutId = opts.rolloutId ?? newRolloutId();
+            const recording = recorder.enabled && (opts.report ?? true);
+            const startedAt = Date.now();
+            const sent = {
+                rolloutId,
+                versionId: shape.versionId,
+                fields: serialize(values),
+                rendered: messages,
+            };
+            let outcome;
+            try {
+                outcome = await run({ messages, turn });
+            }
+            catch (err) {
+                if (recording) {
+                    const recorded = turn?.record();
+                    recorder.write(shape.id, {
+                        ...sent,
+                        model: "unknown",
+                        output: "",
+                        status: "failed",
+                        error: err instanceof Error ? err.message : String(err),
+                        latencyMs: Date.now() - startedAt,
+                        offeredTools: recorded?.offeredTools,
+                        steps: recorded?.steps,
+                    });
+                }
+                throw err;
+            }
+            const latencyMs = Date.now() - startedAt;
+            let pricing;
+            if (recording) {
+                const recorded = turn?.record();
+                const written = recorder.write(shape.id, {
+                    ...sent,
+                    model: outcome.model,
+                    output: outcome.output,
+                    status: outcome.status ?? "completed",
+                    error: outcome.error,
+                    inputTokens: outcome.inputTokens,
+                    outputTokens: outcome.outputTokens,
+                    cacheReadTokens: outcome.cacheReadTokens,
+                    cacheWriteTokens: outcome.cacheWriteTokens,
+                    citationTokens: outcome.citationTokens,
+                    reasoningTokens: outcome.reasoningTokens,
+                    latencyMs,
+                    caseId: outcome.caseId,
+                    seed: outcome.seed,
+                    offeredTools: outcome.offeredTools ?? recorded?.offeredTools,
+                    steps: outcome.steps ?? recorded?.steps,
+                });
+                // Not awaited. The write stays fire-and-forget — a stage that stalled
+                // on a report round trip would pay it fifteen times over a run — and
+                // the promise is handed back so a caller can settle every price at the
+                // end, when the total is what it needs.
+                pricing = written instanceof Promise ? written : undefined;
+            }
+            return { ...outcome, rolloutId, ...(pricing ? { pricing } : {}) };
+        },
+        bind: (model) => bind(built, model),
+    };
+    return built;
+}

package/dist/prompt/index.d.ts

@@ -0,0 +1,4 @@
+export type { Answer, BatchOptions, Chain, InvokeOptions, Model, ModelOptions, } from "./bind.js";
+export { bind } from "./bind.js";
+export type { PromptShape, Recorder } from "./factory.js";
+export { MAX_RECORDED_MESSAGES, makePrompt, noRecorder } from "./factory.js";

package/dist/prompt/index.js

@@ -0,0 +1,2 @@
+export { bind } from "./bind.js";
+export { MAX_RECORDED_MESSAGES, makePrompt, noRecorder } from "./factory.js";

package/dist/pull/index.d.ts

@@ -0,0 +1 @@
+export { pullWithCache } from "./pull.js";

package/dist/pull/index.js

@@ -0,0 +1 @@
+export { pullWithCache } from "./pull.js";

package/dist/pull/pull.d.ts

@@ -0,0 +1,12 @@
+import type { PullCache } from "../cache/index.js";
+/**
+ * Fetch-by-id with stale-while-revalidate.
+ *
+ *   fresh  → return it, no request
+ *   stale  → return it now, refresh behind the caller
+ *   miss   → fetch, and only then answer
+ *
+ * The middle path is why a prompt edit takes effect within a TTL without any
+ * request paying for the fetch. Generic because tools and graphs pull the same.
+ */
+export declare function pullWithCache<T>(cache: PullCache<T>, key: string, fetchOne: () => Promise<T>): Promise<T>;

package/dist/pull/pull.js

@@ -0,0 +1,31 @@
+/**
+ * Fetch-by-id with stale-while-revalidate.
+ *
+ *   fresh  → return it, no request
+ *   stale  → return it now, refresh behind the caller
+ *   miss   → fetch, and only then answer
+ *
+ * The middle path is why a prompt edit takes effect within a TTL without any
+ * request paying for the fetch. Generic because tools and graphs pull the same.
+ */
+export async function pullWithCache(cache, key, fetchOne) {
+    const hit = cache.get(key);
+    if (hit && !hit.stale)
+        return hit.value;
+    if (hit) {
+        cache.refreshInBackground(key, fetchOne);
+        return hit.value;
+    }
+    // Guarded like the background refresh: an invalidation can land mid-fetch,
+    // and storing afterwards marks pre-invalidation state fresh for a whole TTL.
+    const startedAt = cache.beginFetch();
+    try {
+        const value = await fetchOne();
+        cache.settle(key, value, startedAt);
+        return value;
+    }
+    catch (err) {
+        cache.abandon(key);
+        throw err;
+    }
+}

package/dist/render/index.d.ts

@@ -0,0 +1,4 @@
+export { renderMessages } from "./messages.js";
+export { compileSystemPrompt } from "./system.js";
+export type { Block, History, Message } from "./types.js";
+export { applyVariables, findVariables } from "./variables.js";

package/dist/render/index.js

@@ -0,0 +1,3 @@
+export { renderMessages } from "./messages.js";
+export { compileSystemPrompt } from "./system.js";
+export { applyVariables, findVariables } from "./variables.js";

package/dist/render/messages.d.ts

@@ -0,0 +1,12 @@
+import type { Block, History, Message } from "./types.js";
+/**
+ * The messages a request will send.
+ *
+ * A prompt with no blocks sends one message, not two: an empty system message is
+ * a different request from no system message at all.
+ *
+ * `history` is placed between the system turn and the question, oldest first,
+ * and is passed through verbatim — it is a record of what was already said, not
+ * a template, so `{placeholders}` inside it are left alone.
+ */
+export declare function renderMessages(blocks: Block[], question: string, values?: Record<string, string>, history?: History): Message[];

package/dist/render/messages.js

@@ -0,0 +1,24 @@
+import { compileSystemPrompt } from "./system.js";
+import { applyVariables } from "./variables.js";
+/**
+ * The messages a request will send.
+ *
+ * A prompt with no blocks sends one message, not two: an empty system message is
+ * a different request from no system message at all.
+ *
+ * `history` is placed between the system turn and the question, oldest first,
+ * and is passed through verbatim — it is a record of what was already said, not
+ * a template, so `{placeholders}` inside it are left alone.
+ */
+export function renderMessages(blocks, question, values, history = []) {
+    const system = compileSystemPrompt(blocks, values);
+    const user = applyVariables(question, values);
+    const turns = history.filter((m) => m.role !== "system");
+    return system
+        ? [
+            { role: "system", content: system },
+            ...turns,
+            { role: "user", content: user },
+        ]
+        : [...turns, { role: "user", content: user }];
+}

package/dist/render/system.d.ts

@@ -0,0 +1,8 @@
+import type { Block } from "./types.js";
+/**
+ * Blocks in order, each under its title.
+ *
+ * An empty body drops the block — a heading over nothing is noise. An untitled
+ * block is emitted bare rather than under a blank `##`.
+ */
+export declare function compileSystemPrompt(blocks: Block[], values?: Record<string, string>): string;

package/dist/render/system.js

@@ -0,0 +1,19 @@
+import { applyVariables } from "./variables.js";
+/**
+ * Blocks in order, each under its title.
+ *
+ * An empty body drops the block — a heading over nothing is noise. An untitled
+ * block is emitted bare rather than under a blank `##`.
+ */
+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");
+}

package/dist/render/types.d.ts

@@ -0,0 +1,15 @@
+/** One titled section of a prompt. */
+export type Block = {
+    title: string;
+    body: string;
+};
+/**
+ * One turn. `assistant` appears only in conversation history — a prompt's own
+ * wording still renders a system turn and a user turn, never an answer.
+ */
+export type Message = {
+    role: "system" | "user" | "assistant";
+    content: string;
+};
+/** Prior turns, oldest first, placed between the system turn and the question. */
+export type History = Message[];

package/dist/render/types.js

@@ -0,0 +1 @@
+export {};

package/dist/render/variables.d.ts

@@ -0,0 +1,11 @@
+import type { Block } from "./types.js";
+/**
+ * Substitutes `{name}` placeholders, leaving unknown ones verbatim — emptying
+ * one would send a prompt with a hole the caller cannot see.
+ *
+ * Mirrors `lib/prompt.ts` in the app. Duplicated because this package depends on
+ * nothing; `rendered` on every rollout makes a divergence visible.
+ */
+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[];

package/dist/render/variables.js

@@ -0,0 +1,29 @@
+/**
+ * Substitutes `{name}` placeholders, leaving unknown ones verbatim — emptying
+ * one would send a prompt with a hole the caller cannot see.
+ *
+ * Mirrors `lib/prompt.ts` in the app. Duplicated because this package depends on
+ * nothing; `rendered` on every rollout makes a divergence visible.
+ */
+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;
+}

package/dist/run/across-models.d.ts

@@ -0,0 +1,7 @@
+import type { Prompts } from "@spendgraph/sdk";
+import type { Budget } from "../budget/index.js";
+import type { RunOptions, RunResult } from "../types/index.js";
+/** One rollout per model — the playground's comparison, headless. */
+export declare function runAcrossModels(prompts: Prompts, promptId: string, values: Record<string, unknown>, models: string[], opts?: RunOptions & {
+    concurrency?: number;
+}, budget?: Budget): Promise<RunResult[]>;

package/dist/run/across-models.js

@@ -0,0 +1,6 @@
+import { mapLimit } from "./concurrency.js";
+import { runOnce } from "./once.js";
+/** One rollout per model — the playground's comparison, headless. */
+export async function runAcrossModels(prompts, promptId, values, models, opts = {}, budget) {
+    return mapLimit(models, opts.concurrency ?? 4, (model) => runOnce(prompts, promptId, values, { ...opts, model, rolloutId: undefined }, budget));
+}

package/dist/run/concurrency.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Runs `fn` over `items`, at most `limit` in flight.
+ *
+ * Bounded on purpose: a whole dataset at once becomes 429s you still wait out,
+ * so the unbounded version finishes later and flakier.
+ */
+export declare function mapLimit<T, R>(items: T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/run/concurrency.js

@@ -0,0 +1,18 @@
+/**
+ * Runs `fn` over `items`, at most `limit` in flight.
+ *
+ * Bounded on purpose: a whole dataset at once becomes 429s you still wait out,
+ * so the unbounded version finishes later and flakier.
+ */
+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;
+}

package/dist/run/id.d.ts

@@ -0,0 +1,2 @@
+/** Generated per attempt so a retry of the same call lands on one row. */
+export declare function newRolloutId(): string;

package/dist/run/id.js

@@ -0,0 +1,4 @@
+/** Generated per attempt so a retry of the same call lands on one row. */
+export function newRolloutId() {
+    return `ro_${crypto.randomUUID().replace(/-/g, "")}`;
+}

package/dist/run/index.d.ts

@@ -0,0 +1,5 @@
+export { runAcrossModels } from "./across-models.js";
+export { mapLimit } from "./concurrency.js";
+export { newRolloutId } from "./id.js";
+export { runOnce } from "./once.js";
+export { sampleRuns } from "./sample.js";

package/dist/run/index.js

@@ -0,0 +1,5 @@
+export { runAcrossModels } from "./across-models.js";
+export { mapLimit } from "./concurrency.js";
+export { newRolloutId } from "./id.js";
+export { runOnce } from "./once.js";
+export { sampleRuns } from "./sample.js";

package/dist/run/once.d.ts

@@ -0,0 +1,4 @@
+import type { Prompts } from "@spendgraph/sdk";
+import type { Budget } from "../budget/index.js";
+import type { RunOptions, RunResult } from "../types/index.js";
+export declare function runOnce(prompts: Prompts, promptId: string, values: Record<string, unknown>, opts?: RunOptions, budget?: Budget): Promise<RunResult>;

package/dist/run/once.js

@@ -0,0 +1,22 @@
+import { newRolloutId } from "./id.js";
+export async function runOnce(prompts, promptId, values, opts = {}, budget) {
+    budget?.assertAffordable();
+    const rolloutId = opts.rolloutId ?? newRolloutId();
+    const res = await prompts.run(promptId, {
+        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 — the attempt that wrote it already paid.
+    if (!res.deduped)
+        budget?.add(res.rollout.costMicros ?? 0);
+    return res.rollout;
+}

package/dist/run/sample.d.ts

@@ -0,0 +1,17 @@
+import type { Prompts } from "@spendgraph/sdk";
+import type { Budget } from "../budget/index.js";
+import type { RunOptions, RunResult } from "../types/index.js";
+/**
+ * k repetitions of one case, so `pass^k` is computable.
+ *
+ * Always k results. A failed seed is present with `status: "failed"` rather than
+ * missing — three results for k = 5 would have the metric compute over three and
+ * report better consistency than the run showed.
+ *
+ * A budget stop throws instead. Money running out says nothing about the prompt,
+ * and recording those seeds as failures would put the wallet into pass^k.
+ */
+export declare function sampleRuns(prompts: Prompts, promptId: string, values: Record<string, unknown>, opts?: RunOptions & {
+    k?: number;
+    concurrency?: number;
+}, budget?: Budget): Promise<RunResult[]>;

package/dist/run/sample.js

@@ -0,0 +1,39 @@
+import { BudgetExceededError } from "../budget/index.js";
+import { mapLimit } from "./concurrency.js";
+import { runOnce } from "./once.js";
+/**
+ * k repetitions of one case, so `pass^k` is computable.
+ *
+ * Always k results. A failed seed is present with `status: "failed"` rather than
+ * missing — three results for k = 5 would have the metric compute over three and
+ * report better consistency than the run showed.
+ *
+ * A budget stop throws instead. Money running out says nothing about the prompt,
+ * and recording those seeds as failures would put the wallet into pass^k.
+ */
+export async function sampleRuns(prompts, 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(prompts, promptId, values, { ...opts, seed, rolloutId: undefined }, budget);
+        }
+        catch (err) {
+            if (err instanceof BudgetExceededError)
+                throw err;
+            // Still an outcome for this seed; throwing discards the k-1 that landed.
+            return {
+                id: null,
+                model: opts.model ?? "",
+                status: "failed",
+                output: "",
+                error: err.message,
+                costMicros: 0,
+                latencyMs: 0,
+                inputTokens: 0,
+                outputTokens: 0,
+                seed,
+            };
+        }
+    });
+}

package/dist/types/dataset.d.ts

@@ -0,0 +1,22 @@
+/** Which side of the wall a case sits on. The server decides, never the client. */
+export type Split = "feedback" | "held_out";
+/** One input the prompt is evaluated against. */
+export interface DatasetCase {
+    caseId: string;
+    fieldValues: Record<string, string>;
+    expected?: string | null;
+    /** Omit it. The server derives the split, so a case never moves sides. */
+    split?: Split;
+}
+export interface DatasetSummary {
+    cases: (DatasetCase & {
+        split: Split;
+    })[];
+    counts: {
+        total: number;
+        feedback: number;
+        held_out: number;
+    };
+    /** Why this dataset cannot be optimized against yet, or null. */
+    problem: string | null;
+}

package/dist/types/dataset.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,8 @@
+export type { DatasetCase, DatasetSummary, Split } from "./dataset.js";
+export type { PromptPayload } from "./payload.js";
+export type { Prompt, PromptSource, PromptSpec, RenderOptions } from "./prompt.js";
+export type { RunResult } from "./result.js";
+export type { ReportInput, Rollout } from "./rollout.js";
+export type { RunOptions } from "./run.js";
+export type { Recordable, TraceHandle, TraceOptions, TraceOutcome, TurnRecord, TurnSource, } from "./trace.js";
+export type { PromptVersion } from "./version.js";

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};