@spendgraph/prompt 0.2.0 → 0.2.1

package/README.md

@@ -238,3 +238,6 @@ Two subpaths hold the rest:
 Reach for `internals` only to build your own client; `PromptClient` already
 wires all of it.
 
+## License
+
+MIT

package/dist/budget/budget.js

@@ -1,23 +1,8 @@
 import { BudgetExceededError } from "./errors.js";
-/** Warned once per process, not per client — a library that nags gets muted. */
 let warned = false;
-/**
- * What this client has spent, and whether it may spend more.
- *
- * A `sample` loop over a dataset is the shape of an expensive accident, and the
- * guard is a counter and a comparison.
- *
- * Governs what this client initiates — `run`, `sample`, `runAll`. Not `report`,
- * which records money already spent elsewhere.
- */
 export class Budget {
     used = 0;
     limit;
-    /**
-     * `undefined` means no ceiling and warns once — an unbounded client in a
-     * scheduled script is how a surprise bill happens. `null` means the same
-     * thing deliberately, and says nothing.
-     */
     constructor(maxCostMicros) {
         this.limit = maxCostMicros ?? Infinity;
         if (maxCostMicros === undefined && !warned) {
@@ -36,18 +21,11 @@ export class Budget {
         if (Number.isFinite(costMicros) && costMicros > 0)
             this.used += costMicros;
     }
-    /**
-     * Throws if the ceiling is already reached.
-     *
-     * Checked before a request rather than after: stopping once the bill has been
-     * incurred is a report, not a limit.
-     */
     assertAffordable() {
         if (this.used >= this.limit)
             throw new BudgetExceededError(this.used, this.limit);
     }
 }
-/** Test seam: lets the once-only warning be exercised more than once. */
 export function resetBudgetWarning() {
     warned = false;
 }

package/dist/budget/errors.js

@@ -1,10 +1,3 @@
-/**
- * Thrown when a client has spent its ceiling.
- *
- * Deliberately not a `SpendgraphError`: nothing was refused by the server, so a
- * caller inspecting `status` or `retryable` would be told a story about HTTP
- * that never happened.
- */
 export class BudgetExceededError extends Error {
     spentMicros;
     limitMicros;

package/dist/build/build.js

@@ -12,14 +12,6 @@ function warnOnEmptyTokens(entry) {
         "the provider response, so return inputTokens and outputTokens from your callback " +
         "or every cost on this prompt reads as zero.");
 }
-/**
- * Usage, not a rollout.
- *
- * A custom prompt has no row on the server and so no version to reference, and
- * `POST /api/v1/prompts/:id/rollouts` needs both. The tokens are still real, so
- * they go to ingest — the spend lands on the dashboard, attributed to the model
- * and tagged with the prompt's name; only the wording goes unversioned.
- */
 function usageRecorder(sdk, name, opts) {
     const onEmpty = opts.onEmptyTokens ?? warnOnEmptyTokens;
     return {
@@ -46,14 +38,6 @@ function usageRecorder(sdk, name, opts) {
         },
     };
 }
-/**
- * A prompt written in code rather than pulled from the server.
- *
- * The same `Prompt` `pullPrompt` returns — same `render`, same `serialize`,
- * same `trace` — so nothing downstream has to know which one it was handed.
- * Give it an `sdk` and it records what the call cost; leave it off and it
- * touches the network never.
- */
 export function buildCustomPrompt(spec, opts = {}) {
     const variables = spec.variables ?? {};
     const blocks = (spec.blocks ?? []).map((b) => ({

package/dist/cache/cache.js

@@ -3,37 +3,16 @@ export class PullCache {
     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());
@@ -45,7 +24,6 @@ export class PullCache {
         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;
@@ -59,27 +37,13 @@ export class PullCache {
             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;
@@ -89,19 +53,10 @@ export class PullCache {
             .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(() => {
@@ -109,45 +64,34 @@ export class PullCache {
             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;
@@ -156,7 +100,6 @@ export class PullCache {
             this.failures.delete(oldest);
         }
     }
-    /** Every key whose entry satisfies `match`. */
     keysWhere(match) {
         const out = [];
         for (const [key, entry] of this.store)
@@ -166,17 +109,11 @@ export class PullCache {
     }
     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();
@@ -185,13 +122,6 @@ export class PullCache {
     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/client.js

@@ -7,14 +7,7 @@ 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;
@@ -44,15 +37,6 @@ export class PromptClient {
             },
         };
     }
-    /**
-     * 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);
@@ -69,17 +53,9 @@ export class PromptClient {
             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;
@@ -92,22 +68,12 @@ export class PromptClient {
             "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) {
@@ -115,52 +81,26 @@ export class PromptClient {
         }
         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();
@@ -172,25 +112,6 @@ export class PromptClient {
         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)
@@ -219,12 +140,6 @@ export class PromptClient {
         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/internals.js

@@ -1,10 +1,3 @@
-/**
- * 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";

package/dist/prompt/bind.js

@@ -1,11 +1,5 @@
 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 };

package/dist/prompt/factory.js

@@ -6,13 +6,6 @@ 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) {
@@ -29,13 +22,6 @@ function lastUserMessage(messages) {
     }
     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);
@@ -104,10 +90,6 @@ export function makePrompt(shape, source, recorder = noRecorder) {
                     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 } : {}) };

package/dist/pull/pull.js

@@ -1,13 +1,3 @@
-/**
- * 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)
@@ -16,8 +6,6 @@ export async function pullWithCache(cache, key, fetchOne) {
         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();

package/dist/render/messages.js

@@ -1,15 +1,5 @@
 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);

package/dist/render/system.js

@@ -1,10 +1,4 @@
 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 ?? []) {

package/dist/render/variables.js

@@ -1,16 +1,8 @@
-/**
- * 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) => {
@@ -19,7 +11,6 @@ export function findVariables(blocks, question) {
                 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 ?? "");

package/dist/run/across-models.js

@@ -1,6 +1,5 @@
 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.js

@@ -1,9 +1,3 @@
-/**
- * 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;

package/dist/run/id.js

@@ -1,4 +1,3 @@
-/** 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/once.js

@@ -15,7 +15,6 @@ export async function runOnce(prompts, promptId, values, opts = {}, budget) {
         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.js

@@ -1,16 +1,6 @@
 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);
@@ -21,7 +11,6 @@ export async function sampleRuns(prompts, promptId, values, opts = {}, 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 ?? "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spendgraph/prompt",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Pull a stored prompt or build one in code, render it, and record what it cost.",
   "license": "MIT",
   "repository": {
@@ -42,16 +42,16 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json --declaration false --removeComments",
     "test": "npm run build && vitest run",
     "pretest": "npm run build --workspace @spendgraph/tools"
   },
   "dependencies": {
-    "@spendgraph/sdk": "^0.2.0"
+    "@spendgraph/sdk": "^0.2.1"
   },
   "devDependencies": {
-    "@spendgraph/llms": "^0.2.0",
-    "@spendgraph/tools": "^0.2.0",
+    "@spendgraph/llms": "^0.2.1",
+    "@spendgraph/tools": "^0.2.1",
     "typescript": "^5"
   },
   "engines": {