@spendgraph/prompt 0.2.0

package/dist/cache/cache.js

@@ -0,0 +1,198 @@
+export class PullCache {
+    store = new Map();
+    ttlMs;
+    maxSize;
+    now;
+    /** Keys with a refresh in flight, so N concurrent readers cause one fetch. */
+    refreshing = new Set();
+    /** When a key's refresh last failed, so a dead handle is not retried per call. */
+    failures = new Map();
+    retryAfterMs;
+    onRefreshError;
+    identify;
+    /**
+     * A monotonic counter and the tick at which each name was last invalidated.
+     *
+     * A fetch records the counter when it starts and, when it lands, asks whether
+     * anything it turned out to be — its key, its id, its slug — has been
+     * invalidated since. That is the whole protocol, and it holds for the cold
+     * path, the background refresh, and a handle nobody has seen before, none of
+     * which the previous per-key epoch could cover.
+     */
+    tick = 0;
+    invalidatedAt = new Map();
+    /**
+     * The tick of the last `clear()`.
+     *
+     * `clear` cannot name a fetch it has never seen — a cold one is in neither
+     * `store` nor `refreshing` — so it raises a floor instead: anything that
+     * started before it is out of date whatever it turns out to be.
+     */
+    clearedAt = -1;
+    /** Fetches outstanding, so the log above can be dropped when none remain. */
+    outstanding = 0;
+    constructor(opts = {}) {
+        // A TTL of 0 disables caching without a separate flag; only undefined
+        // falls back to the default.
+        this.ttlMs = (opts.ttlSeconds ?? 300) * 1000;
+        this.maxSize = Math.max(1, opts.maxSize ?? 100);
+        this.now = opts.now ?? (() => Date.now());
+        this.retryAfterMs = (opts.retryAfterSeconds ?? 60) * 1000;
+        this.onRefreshError = opts.onRefreshError;
+        this.identify = opts.identify;
+    }
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        // Map iterates in insertion order, so re-setting marks most-recently-used.
+        this.store.delete(key);
+        this.store.set(key, entry);
+        const ageMs = this.now() - entry.at;
+        return { value: entry.value, stale: ageMs > this.ttlMs, ageMs };
+    }
+    set(key, value) {
+        this.store.delete(key);
+        this.store.set(key, { value, at: this.now() });
+        while (this.store.size > this.maxSize) {
+            const oldest = this.store.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.store.delete(oldest);
+            // The bookkeeping goes with the entry unless a fetch for it is still
+            // running, otherwise these grow forever in a class whose contract is a
+            // bounded LRU — one permanent entry per distinct key ever seen.
+            if (!this.refreshing.has(oldest))
+                this.failures.delete(oldest);
+        }
+    }
+    /**
+     * Runs `refresh` unless one is already in flight for this key.
+     *
+     * Without the guard, a burst of requests arriving just after the TTL lapses
+     * each start their own refresh — the stampede the cache exists to prevent.
+     * Failures are swallowed on purpose: a background refresh that throws must not
+     * surface in a request that was already answered from cache.
+     */
+    refreshInBackground(key, refresh) {
+        if (this.refreshing.has(key))
+            return;
+        // Backed off after a failure. A handle that stopped resolving — routine
+        // since a rename re-mints the slug — would otherwise fire a doomed request
+        // on every pull, forever. The entry stays; the stampede stops.
+        const failedAt = this.failures.get(key);
+        if (failedAt !== undefined && this.now() - failedAt < this.retryAfterMs)
+            return;
+        this.refreshing.add(key);
+        const startedAt = this.beginFetch();
+        void refresh()
+            .then((value) => this.settle(key, value, startedAt))
+            .catch((err) => {
+            this.abandon(key);
+            // Surfaced rather than swallowed. `report` has onReportError for exactly
+            // this reason; without a counterpart here a service can serve a frozen
+            // prompt indefinitely with nothing anywhere saying so.
+            //
+            // Wrapped, because nobody is holding this promise: `pullWithCache` has
+            // already returned the stale value, so a callback that throws would be
+            // an unhandled rejection — process exit in Node, isolate abort in a
+            // Worker.
+            try {
+                this.onRefreshError?.(err, key);
+            }
+            catch {
+                /* a reporter that cannot report is not worth an outage */
+            }
+        })
+            .finally(() => {
+            this.refreshing.delete(key);
+            this.forgetLogIfIdle();
+        });
+    }
+    /** Records a fetch starting, and the tick it must be judged against. */
+    beginFetch() {
+        this.outstanding++;
+        return this.tick;
+    }
+    /** Stores a landed fetch unless what it fetched was invalidated meanwhile. */
+    settle(key, value, startedAt) {
+        this.outstanding--;
+        const names = [key, ...(this.identify?.(value) ?? [])];
+        const overtaken = startedAt < this.clearedAt ||
+            names.some((n) => (this.invalidatedAt.get(n) ?? -1) > startedAt);
+        if (!overtaken) {
+            // Only once the value is kept: clearing first meant a fetch that lost the
+            // race still wiped a live backoff, turning bounded retry into a retry on
+            // every call.
+            this.failures.delete(key);
+            this.set(key, value);
+        }
+        this.forgetLogIfIdle();
+    }
+    /** Ends a fetch that threw, and backs the handle off. */
+    abandon(key) {
+        this.outstanding--;
+        // Recorded on the cold path too — the one a fresh isolate takes — or a
+        // permanently 404ing handle fires one upstream request per pull, forever.
+        this.failures.set(key, this.now());
+        this.boundFailures();
+        this.forgetLogIfIdle();
+    }
+    /** Records that everything under this name is out of date. */
+    invalidate(name) {
+        this.invalidatedAt.set(name, ++this.tick);
+    }
+    /** The log only matters while a fetch could still be judged against it. */
+    forgetLogIfIdle() {
+        if (this.outstanding === 0 && this.refreshing.size === 0)
+            this.invalidatedAt.clear();
+    }
+    /** Keeps `failures` inside the same bound as the entries themselves. */
+    boundFailures() {
+        while (this.failures.size > this.maxSize) {
+            const oldest = this.failures.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.failures.delete(oldest);
+        }
+    }
+    /** Every key whose entry satisfies `match`. */
+    keysWhere(match) {
+        const out = [];
+        for (const [key, entry] of this.store)
+            if (match(entry.value))
+                out.push(key);
+        return out;
+    }
+    delete(key) {
+        this.store.delete(key);
+        // The backoff goes with it, or a handle that has demonstrably recovered
+        // keeps skipping its refresh for the whole retry window.
+        this.failures.delete(key);
+        this.invalidate(key);
+        // Nothing outstanding means nothing to judge against it — residue that
+        // grew by one per prompt ever invalidated.
+        this.forgetLogIfIdle();
+    }
+    clear() {
+        // Every key the cache has an opinion about, not just stored ones: a cold
+        // fetch is in flight under a key not in `store` yet.
+        this.clearedAt = ++this.tick;
+        this.store.clear();
+        this.failures.clear();
+        this.forgetLogIfIdle();
+    }
+    get size() {
+        return this.store.size;
+    }
+    /**
+     * How many keys the cache holds bookkeeping for, entries aside.
+     *
+     * Exposed for the test that this stays bounded: `epochs` and `failures` are
+     * private and grow on paths `size` cannot see, so a test written against
+     * `size` passes whether or not they leak — which is what the first one did.
+     */
+    get trackedKeys() {
+        return new Set([...this.invalidatedAt.keys(), ...this.failures.keys()]).size;
+    }
+}

package/dist/cache/index.d.ts

@@ -0,0 +1 @@
+export { type CacheHit, type CacheOptions, PullCache } from "./cache.js";

package/dist/cache/index.js

@@ -0,0 +1 @@
+export { PullCache } from "./cache.js";

package/dist/client.d.ts

@@ -0,0 +1,147 @@
+import { type ClientOptions, Spendgraph } from "@spendgraph/sdk";
+import { type BuildOptions } from "./build/index.js";
+import { type CacheOptions } from "./cache/index.js";
+import type { DatasetCase, DatasetSummary, Prompt, PromptPayload, PromptSpec, PromptVersion, ReportInput, RunOptions, RunResult } from "./types/index.js";
+export interface PromptClientOptions extends Omit<ClientOptions, "apiKey" | "baseUrl"> {
+    /** spendgraph API key (sg_…). Without it, `pull` throws and `report` no-ops. */
+    apiKey: string | undefined;
+    baseUrl: string;
+    cache?: CacheOptions<PromptPayload>;
+    /** Max requests in flight for sample() and runAll(). Default 4. */
+    concurrency?: number;
+    /**
+     * Stop spending past this, in micro-dollars. Omit and the client warns once
+     * that it is unbounded; pass `null` to say you meant it.
+     */
+    maxCostMicros?: number | null;
+    onReportError?: (err: unknown) => void;
+    onPullError?: (err: unknown, key: string) => void;
+}
+/**
+ * Stored prompts, and the spend they account for.
+ *
+ * Everything that leaves the process goes through `@spendgraph/sdk`; this class
+ * owns the caching, the budget and the rollout bookkeeping on top of it.
+ */
+export declare class PromptClient {
+    /** The SDK underneath. Reach for it for anything this class does not wrap. */
+    readonly sdk: Spendgraph;
+    private readonly cache;
+    private readonly hasKey;
+    private readonly onReportError?;
+    private readonly concurrency;
+    private readonly budget;
+    private warnedAboutTokens;
+    constructor(opts: PromptClientOptions);
+    private recorder;
+    /**
+     * 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.
+     */
+    pull(handle: string): Promise<Prompt>;
+    /** A prompt written in code, wired to record its usage through this client. */
+    build(spec: PromptSpec, opts?: Omit<BuildOptions, "sdk">): Prompt;
+    /**
+     * Said once, because this package cannot count tokens it never saw.
+     *
+     * A callback that forgets to return them records a rollout reading zero in
+     * and zero out, which prices at nothing and quietly drags every average that
+     * includes it. Silence here is how that goes unnoticed for a month.
+     */
+    private warnOnEmptyTokens;
+    /**
+     * 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.
+     */
+    run(promptId: string, values?: Record<string, unknown>, opts?: RunOptions): Promise<RunResult>;
+    /** k repetitions of one case. Always k results, failures included. */
+    sample(promptId: string, values?: Record<string, unknown>, opts?: RunOptions & {
+        k?: number;
+        concurrency?: number;
+    }): Promise<RunResult[]>;
+    /** One rollout per model — the playground's comparison, headless. */
+    runAll(promptId: string, values?: Record<string, unknown>, opts?: RunOptions & {
+        models?: string[];
+        concurrency?: number;
+    }): Promise<RunResult[]>;
+    /** The dataset a prompt is evaluated against, with its split counts. */
+    cases(promptId: string): Promise<DatasetSummary>;
+    /**
+     * 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.
+     */
+    setCases(promptId: string, cases: DatasetCase[]): Promise<Omit<DatasetSummary, "cases">>;
+    /** Micro-dollars this client has spent on runs it initiated. */
+    spent(): number;
+    /** What is left of the ceiling, or Infinity when none was set. */
+    remaining(): number;
+    /** Every wording this prompt has had, newest first. */
+    versions(promptId: string, opts?: {
+        origin?: "user" | "assay";
+        limit?: number;
+    }): Promise<{
+        versions: PromptVersion[];
+        currentVersionId: string | null;
+    }>;
+    /**
+     * 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.
+     */
+    promote(promptId: string, versionId: string): Promise<{
+        promoted: string;
+        previous?: string | null;
+        unchanged?: boolean;
+    }>;
+    /**
+     * 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.
+     */
+    invalidate(promptId?: string): void;
+    /**
+     * 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.
+     */
+    /**
+     * Records a rollout and returns what the server priced it at, in micro-USD,
+     * or undefined where the model had no price to compute one from.
+     *
+     * The price is computed there, from the tokens and the project's pricing
+     * table, so this is the only place it exists — and it is why `report` cannot
+     * simply be reused: that one answers with the rollout id.
+     *
+     * `priced: false` is answered as undefined rather than as the stored zero.
+     * The column is `notNull`, so an unpriced rollout is written as zero and the
+     * flag beside it is the only thing that tells free apart from unknown.
+     */
+    private priced;
+    report(promptId: string, input: ReportInput): Promise<string>;
+}
+/**
+ * One prompt from the server, without keeping a client around.
+ *
+ * Convenience over `new PromptClient(...).pull(...)`, and it builds a client
+ * per call — a service pulling repeatedly wants the class, which caches.
+ */
+export declare function pullPrompt(handle: string, opts: PromptClientOptions): Promise<Prompt>;

package/dist/client.js

@@ -0,0 +1,230 @@
+import { Spendgraph } from "@spendgraph/sdk";
+import { Budget } from "./budget/index.js";
+import { buildCustomPrompt } from "./build/index.js";
+import { PullCache } from "./cache/index.js";
+import { makePrompt } from "./prompt/index.js";
+import { pullWithCache } from "./pull/index.js";
+import { newRolloutId } from "./run/id.js";
+import { runAcrossModels, runOnce, sampleRuns } from "./run/index.js";
+const DEFAULT_CONCURRENCY = 4;
+/**
+ * Stored prompts, and the spend they account for.
+ *
+ * Everything that leaves the process goes through `@spendgraph/sdk`; this class
+ * owns the caching, the budget and the rollout bookkeeping on top of it.
+ */
+export class PromptClient {
+    /** The SDK underneath. Reach for it for anything this class does not wrap. */
+    sdk;
+    cache;
+    hasKey;
+    onReportError;
+    concurrency;
+    budget;
+    warnedAboutTokens = false;
+    constructor(opts) {
+        const { cache, onReportError, onPullError, concurrency, maxCostMicros, ...clientOpts } = opts;
+        this.sdk = new Spendgraph(clientOpts);
+        this.cache = new PullCache({
+            ...cache,
+            onRefreshError: cache?.onRefreshError ?? onPullError,
+            identify: (p) => [p.id, p.slug].filter((v) => Boolean(v)),
+        });
+        this.hasKey = Boolean(opts.apiKey);
+        this.onReportError = onReportError;
+        this.concurrency = Math.max(1, concurrency ?? DEFAULT_CONCURRENCY);
+        this.budget = new Budget("maxCostMicros" in opts ? maxCostMicros : undefined);
+    }
+    recorder() {
+        return {
+            enabled: true,
+            write: (promptId, entry) => {
+                this.warnOnEmptyTokens(entry);
+                return this.priced(promptId, entry);
+            },
+        };
+    }
+    /**
+     * 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.
+     */
+    async pull(handle) {
+        const payload = await pullWithCache(this.cache, handle, async () => {
+            const res = await this.sdk.prompts.get(handle);
+            return res.prompt;
+        });
+        return makePrompt({
+            id: payload.id,
+            name: payload.name,
+            slug: payload.slug ?? null,
+            blocks: payload.blocks,
+            question: payload.question,
+            fields: payload.fieldSpec ?? [],
+            versionId: payload.currentVersionId ?? null,
+            models: payload.models ?? [],
+        }, "server", this.recorder());
+    }
+    /** A prompt written in code, wired to record its usage through this client. */
+    build(spec, opts = {}) {
+        return buildCustomPrompt(spec, { ...opts, sdk: this.sdk });
+    }
+    /**
+     * Said once, because this package cannot count tokens it never saw.
+     *
+     * A callback that forgets to return them records a rollout reading zero in
+     * and zero out, which prices at nothing and quietly drags every average that
+     * includes it. Silence here is how that goes unnoticed for a month.
+     */
+    warnOnEmptyTokens(outcome) {
+        if (this.warnedAboutTokens)
+            return;
+        if (outcome.status === "failed")
+            return;
+        if ((outcome.inputTokens ?? 0) > 0 || (outcome.outputTokens ?? 0) > 0)
+            return;
+        this.warnedAboutTokens = true;
+        console.warn("[prompt] trace() recorded a rollout with no tokens. This package never sees " +
+            "the provider response, so return inputTokens and outputTokens from your callback " +
+            "or every cost on this prompt reads as zero.");
+    }
+    /**
+     * 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.sdk.prompts, promptId, values, opts, this.budget);
+    }
+    /** k repetitions of one case. Always k results, failures included. */
+    async sample(promptId, values = {}, opts = {}) {
+        return sampleRuns(this.sdk.prompts, 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.sdk.prompts, 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.sdk.prompts.cases(promptId);
+    }
+    /**
+     * 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.sdk.prompts.putCases(promptId, 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 = {}) {
+        return this.sdk.prompts.versions(promptId, opts);
+    }
+    /**
+     * 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.sdk.prompts.promote(promptId, 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.
+     */
+    invalidate(promptId) {
+        if (!promptId) {
+            this.cache.clear();
+            return;
+        }
+        for (const key of this.cache.keysWhere((p) => p.id === promptId || p.slug === promptId)) {
+            this.cache.delete(key);
+        }
+        this.cache.delete(promptId);
+        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.
+     */
+    /**
+     * Records a rollout and returns what the server priced it at, in micro-USD,
+     * or undefined where the model had no price to compute one from.
+     *
+     * The price is computed there, from the tokens and the project's pricing
+     * table, so this is the only place it exists — and it is why `report` cannot
+     * simply be reused: that one answers with the rollout id.
+     *
+     * `priced: false` is answered as undefined rather than as the stored zero.
+     * The column is `notNull`, so an unpriced rollout is written as zero and the
+     * flag beside it is the only thing that tells free apart from unknown.
+     */
+    async priced(promptId, input) {
+        const rolloutId = input.rolloutId ?? newRolloutId();
+        if (!this.hasKey)
+            return undefined;
+        try {
+            const res = (await this.sdk.prompts.report(promptId, { ...input, rolloutId }));
+            if (res.priced === false)
+                return undefined;
+            return res.rollout?.costMicros;
+        }
+        catch (err) {
+            this.onReportError?.(err);
+            return undefined;
+        }
+    }
+    async report(promptId, input) {
+        const rolloutId = input.rolloutId ?? newRolloutId();
+        if (!this.hasKey)
+            return rolloutId;
+        try {
+            await this.sdk.prompts.report(promptId, { ...input, rolloutId });
+        }
+        catch (err) {
+            this.onReportError?.(err);
+        }
+        return rolloutId;
+    }
+}
+/**
+ * One prompt from the server, without keeping a client around.
+ *
+ * Convenience over `new PromptClient(...).pull(...)`, and it builds a client
+ * per call — a service pulling repeatedly wants the class, which caches.
+ */
+export function pullPrompt(handle, opts) {
+    return new PromptClient(opts).pull(handle);
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export type { FieldError, FieldSpec, FieldType, RolloutStep } from "@spendgraph/sdk";
+export { FieldValidationError } from "@spendgraph/sdk";
+export { BudgetExceededError } from "./budget/index.js";
+export type { BuildOptions } from "./build/index.js";
+export { buildCustomPrompt } from "./build/index.js";
+export type { PromptClientOptions } from "./client.js";
+export { PromptClient, pullPrompt } from "./client.js";
+export type { Answer, BatchOptions, Chain, InvokeOptions, Model } from "./prompt/index.js";
+export { MAX_RECORDED_MESSAGES } from "./prompt/index.js";
+export type { Block, History, Message } from "./render/index.js";
+export type { DatasetCase, DatasetSummary, Prompt, PromptSource, PromptSpec, PromptVersion, RenderOptions, ReportInput, RunOptions, RunResult, Split, TraceHandle, TraceOptions, TraceOutcome, } from "./types/index.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { FieldValidationError } from "@spendgraph/sdk";
+export { BudgetExceededError } from "./budget/index.js";
+export { buildCustomPrompt } from "./build/index.js";
+export { PromptClient, pullPrompt } from "./client.js";
+export { MAX_RECORDED_MESSAGES } from "./prompt/index.js";

package/dist/internals.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The pieces `PromptClient` is built from.
+ *
+ * Not in the main entry on purpose: everything here is already wired for you,
+ * and a caller reaching for it is building their own client rather than using
+ * this one. Kept exported so that stays possible.
+ */
+export type { RolloutInput, RolloutRecord } from "@spendgraph/sdk";
+export { serializeFields, validateFields } from "@spendgraph/sdk";
+export { Budget } from "./budget/index.js";
+export type { CacheHit, CacheOptions } from "./cache/index.js";
+export { PullCache } from "./cache/index.js";
+export type { ModelOptions, PromptShape, Recorder } from "./prompt/index.js";
+export { bind, makePrompt, noRecorder } from "./prompt/index.js";
+export { pullWithCache } from "./pull/index.js";
+export { mapLimit, newRolloutId } from "./run/index.js";
+export type { PromptPayload, Recordable, Rollout, TurnRecord, TurnSource } from "./types/index.js";

package/dist/internals.js

@@ -0,0 +1,13 @@
+/**
+ * The pieces `PromptClient` is built from.
+ *
+ * Not in the main entry on purpose: everything here is already wired for you,
+ * and a caller reaching for it is building their own client rather than using
+ * this one. Kept exported so that stays possible.
+ */
+export { serializeFields, validateFields } from "@spendgraph/sdk";
+export { Budget } from "./budget/index.js";
+export { PullCache } from "./cache/index.js";
+export { bind, makePrompt, noRecorder } from "./prompt/index.js";
+export { pullWithCache } from "./pull/index.js";
+export { mapLimit, newRolloutId } from "./run/index.js";