@spendgraph/sdk 0.7.0 → 0.8.1

package/dist/resources/files.d.ts

@@ -4,7 +4,7 @@ export declare const PUBLISH_TO: readonly ["md", "html", "txt", "pdf"];
 export type PublishFrom = (typeof PUBLISH_FROM)[number];
 export type PublishTo = (typeof PUBLISH_TO)[number];
 export interface PublishInput {
-    projectId: string;
+    projectId?: string;
     content: string;
     from: PublishFrom;
     to: PublishTo;

package/dist/resources/ingest.d.ts

@@ -19,6 +19,15 @@ export interface IngestResult {
     rejected: number;
     /** Ids nothing could price. Stored at $0 and counted, never rejected. */
     unpricedModels: string[];
+    /**
+     * What each event was priced at, by the `eventId` it was sent with.
+     *
+     * The server prices from the project's resolved offer as it writes the row,
+     * so this is the figure that was stored rather than a second calculation of
+     * it. A caller reporting usage rather than a rollout has no other way to put
+     * a cost on the call it just made.
+     */
+    costs: Record<string, number>;
 }
 /** The route takes up to this many events per request. */
 export declare const MAX_EVENTS = 100;
@@ -31,12 +40,22 @@ export declare const MAX_EVENTS = 100;
 export interface Sender {
     send(events: UsageEvent[]): Promise<void>;
 }
+/** What one event cost, for a caller that sent exactly one. */
+export type OneCost = number | undefined;
 /** Posts usage straight through, chunked to what the route accepts. */
 export declare class Ingest implements Sender {
     private readonly client;
     private readonly project?;
     constructor(client: Client, project?: string | undefined);
     send(events: UsageEvent[]): Promise<void>;
+    /**
+     * One event, and what it cost — for a caller that wants the figure back.
+     *
+     * `undefined` where the server could not price the model, which it counts at
+     * zero rather than rejecting. A caller can then say "unpriced" instead of
+     * showing a zero that looks measured.
+     */
+    priced(event: UsageEvent): Promise<OneCost>;
     /** The same write, with the server's answer — which ids went unpriced. */
     report(events: UsageEvent[]): Promise<IngestResult>;
 }

package/dist/resources/ingest.js

@@ -1 +1 @@
-const i=100;class p{client;project;constructor(c,e){this.client=c,this.project=e}async send(c){await this.report(c)}async report(c){const e={accepted:0,rejected:0,unpricedModels:[]};if(c.length===0)return e;const r=new Set,o=c.map(t=>({...t,eventId:t.eventId??crypto.randomUUID()}));for(let t=0;t<o.length;t+=100){const n=await this.client.post("/api/v1/ingest",{events:o.slice(t,t+100)},{project:this.project});e.accepted+=n?.accepted??0,e.rejected+=n?.rejected??0;for(const s of n?.unpricedModels??[])r.add(s)}return e.unpricedModels=[...r],e}}export{p as Ingest,i as MAX_EVENTS};
+const i=100;class p{client;project;constructor(e,t){this.client=e,this.project=t}async send(e){await this.report(e)}async priced(e){const t=e.eventId??crypto.randomUUID();return(await this.report([{...e,eventId:t}])).costs[t]}async report(e){const t={accepted:0,rejected:0,unpricedModels:[],costs:{}};if(e.length===0)return t;const r=new Set,o=e.map(c=>({...c,eventId:c.eventId??crypto.randomUUID()}));for(let c=0;c<o.length;c+=100){const s=await this.client.post("/api/v1/ingest",{events:o.slice(c,c+100)},{project:this.project});t.accepted+=s?.accepted??0,t.rejected+=s?.rejected??0;for(const n of s?.unpricedModels??[])r.add(n);Object.assign(t.costs,s?.costs??{})}return t.unpricedModels=[...r],t}}export{p as Ingest,i as MAX_EVENTS};

package/dist/resources/prompts.d.ts

@@ -21,7 +21,7 @@ export interface PromptBlock {
     body?: string;
 }
 export interface SavePromptInput {
-    projectId: string;
+    projectId?: string;
     name: string;
     blocks?: PromptBlock[];
     variables?: Record<string, string>;

package/dist/resources/tools.d.ts

@@ -22,7 +22,7 @@ export interface ToolRow {
     updatedAt: string;
 }
 export interface SaveToolInput {
-    projectId: string;
+    projectId?: string;
     name: string;
     description: string;
     args?: FieldSpec[];

package/dist/schema/types/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * Typed prompt fields — what a `{placeholder}` accepts, and how it renders.
  *
- * Deliberately a copy of `lib/fields.ts` rather than an import. This package is
+ * Deliberately a copy of `lib/prompts/fields.ts` rather than an import. This package is
  * published and depends on nothing; reaching into the app for a type would make
  * every installed copy break the next time the app moved a file. The two are
  * kept in step by the wire format, which is the only contract that matters.

package/docs/api.mdx

@@ -0,0 +1,101 @@
+export const meta = {
+  title: "HTTP API | spendgraph docs",
+  description: "The ingest endpoint, cache token accounting, the stats and events reads, and CSV export.",
+};
+
+# HTTP API
+
+The SDK talks to one endpoint; everything else powers the dashboard. Errors are always `{ "error": { "code", "message" } }`.
+
+## POST /api/v1/ingest
+
+Auth is the `x-api-key` header. The body carries 1 to 100 events.
+
+```bash
+curl -X POST https://spendgraph.locusgraph.com/api/v1/ingest \
+  -H "content-type: application/json" \
+  -H "x-api-key: sg_..." \
+  -d '{
+    "events": [{
+      "model": "claude-sonnet-5",
+      "inputTokens": 3211,
+      "outputTokens": 842
+    }]
+  }'
+# -> 202 { "accepted": 1, "rejected": 0, "unpricedModels": [] }
+```
+
+Cost is computed at ingest from the newest price for the model and stored on the event in integer micro-USD. Unknown models are stored at $0 and flagged on the [Pricing](https://spendgraph.locusgraph.com/pricing) page. Events are never dropped.
+
+## Cache tokens
+
+Cached prompts bill at their own rates: a read costs roughly a tenth of normal input, a write a little more than it, so they are reported as their own fields rather than folded into `inputTokens`.
+
+```json
+"events": [{
+  "model": "claude-sonnet-5",
+  "inputTokens": 3211,
+  "outputTokens": 842,
+  "cacheReadTokens": 18004,
+  "cacheWriteTokens": 3211
+}]
+```
+
+<Callout tone="trap" title="The three counts are disjoint">
+  Providers report them separately, Anthropic's total input is `input + cache_read + cache_creation`, and spendgraph prices them the same way. Do **not** also add cache tokens into `inputTokens`: that bills the same tokens twice, at the wrong rate. Omitting them loses the spend entirely.
+</Callout>
+
+A model whose offer publishes no cache rate bills cache tokens at its input rate rather than at zero. An unknown discount should overcount, never undercount.
+
+`wrap()` reads all three counts off the provider response for you. This only matters if you are calling the API directly.
+
+## Reads
+
+These accept a signed-in GitHub session, and, for the endpoints below, the same `x-api-key` header as ingest. That is what makes a scheduled cost report possible without driving a browser.
+
+| | |
+| --- | --- |
+| `GET /api/v1/stats/summary` | totals plus the previous period |
+| `GET /api/v1/stats/timeseries` | spend and tokens over time |
+| `GET /api/v1/stats/by-model` | grouped by model |
+| `GET /api/v1/stats/by-key` | grouped by API key |
+| `GET /api/v1/stats/by-tag?key=` | spend by one metadata dimension |
+| `GET /api/v1/events` | raw events, newest first |
+| `GET /api/v1/compare` | what a workload costs on each model |
+
+`by-key` is how spend gets attributed to an environment or a service. Each row carries the key's `revoked` timestamp, so spend that arrived on a key you have since turned off stays visible rather than silently unattributed.
+
+`by-tag` takes one dimension at a time on purpose. Omit `key` and the costliest is used, with the rest listed in `keys`. Ranking `env` and `feature` together would double count: they are two cuts of the same spend.
+
+<Callout tone="warn" title="A key is pinned to its project">
+  `project=` is implied and can be omitted. Passing a *different* project returns `403 project_not_accessible` rather than quietly answering with the key's own project, a report that iterates projects with one key should fail loudly, not repeat one project's figures under every heading.
+</Callout>
+
+## Filtering and exporting events
+
+A parameter you cannot guess is a parameter you do not have, so here is the whole set `/api/v1/events` accepts. All optional, all combine freely.
+
+| | |
+| --- | --- |
+| `sort=cost` | most expensive first, instead of newest |
+| `model=` `key=` `project=` | narrow to one model, key, or project |
+| `q=` | substring match across the model name and metadata JSON |
+| `from=` `to=` | ISO timestamps |
+| `format=csv` | the same rows as a spreadsheet |
+| `cursor=` `limit=` | paging |
+
+Paging works in either sort order, but a cursor is only valid for the sort it came from; switching restarts from the first page.
+
+In CSV, each metadata key becomes its own `meta.<key>` column, so cost by feature is a pivot rather than a JSON parse.
+
+<Callout tone="trap" title="A truncated export is a wrong answer that looks right">
+  CSV is capped at 5,000 rows. Check `x-spendgraph-truncated` before totalling a column: `x-spendgraph-rows` and `x-spendgraph-next-cursor` carry on from where it stopped.
+</Callout>
+
+## Everything else
+
+`GET /api/v1/pricing` · `PUT /api/v1/pricing/:model` · `POST /api/v1/pricing/sync` · `GET|POST /api/v1/projects` · `GET|POST /api/v1/keys` · `DELETE /api/v1/keys/:id`
+
+Prices sync from LiteLLM's community file every day at 06:00 UTC, and **Sync prices** on the [Pricing](https://spendgraph.locusgraph.com/pricing) page runs it on demand. A price you set by hand always wins over the sync, so a negotiated rate survives the next refresh.
+
+Keys, projects, pricing and credentials are gated on a dashboard session and have no API-key path, deliberately: credentials holds provider keys, and keys mints API keys.

package/docs/budgets.mdx

@@ -0,0 +1,50 @@
+export const meta = {
+  title: "Budgets and alerts | spendgraph docs",
+  description: "Set a monthly budget, get a Slack-shaped webhook at 80% and 100%, and understand what a budget deliberately does not do.",
+};
+
+# Budgets and alerts
+
+<Callout tone="trap" title="A budget alerts. It never blocks.">
+  Ingest keeps accepting events and your provider keeps serving requests after the budget is passed. Spendgraph watches spend, it does not stand between you and the model. Nothing here caps anything.
+</Callout>
+
+That is worth being blunt about, because "budget" implies a limit in most tools. If you need a hard cap, it has to live in front of the provider, not here.
+
+## Setting one
+
+```bash
+# set or clear a budget (null clears; webhook is optional)
+PUT /api/v1/projects/{id}/budget
+  { "monthlyBudgetMicros": 40000000,
+    "alertWebhookUrl": "https://hooks.slack.com/..." }
+
+# read it back, with spend so far this month
+GET /api/v1/projects/{id}/budget
+  -> { "budget": { "monthlyBudgetMicros": 40000000, "alertWebhookUrl": "..." },
+       "monthToDateMicros": 28887771 }
+```
+
+Money is integer micro-USD everywhere: `40000000` is $40.
+
+## When alerts fire
+
+Thresholds are **80%** and **100%** of month-to-date spend, and each fires at most once per project per calendar month. A single run that jumps past both posts only the higher one.
+
+The check runs once a day on the cron, so spend can pass a threshold and sit there for up to a day before you hear about it. Budgets are a monthly-planning tool, not a pager.
+
+The `(project, period, threshold)` row is what makes "at most once" true, and it is written **after** a successful POST, so a webhook that is down retries on the next run instead of silently swallowing the alert.
+
+## Reading what fired
+
+```bash
+GET /api/v1/alerts        # newest first, limit 1-200, default 50
+  -> { "alerts": [{ "projectName": "support-bot", "period": "2026-08",
+                    "thresholdPct": 80, "sentAt": "..." }] }
+```
+
+## The webhook payload
+
+Slack-shaped, `{ "text": "..." }`, so any Slack-compatible incoming webhook works unchanged.
+
+The line names the project, spend against budget, the day of the month, and where the current pace lands by month end. That last part is the point: **80% on the 3rd and 80% on the 28th are not the same news**, and an alert that does not say which one it is makes you go and look.

package/docs/client.mdx

@@ -1,12 +1,12 @@
 export const meta = {
-  title: "The client — spendgraph docs",
+  title: "The client: spendgraph docs",
   description:
     "Spendgraph is the whole API in one client: prompts, tools, stats, events, keys and projects. One capital letter apart from the meter, and a different thing entirely.",
 };
 
 # The client
 
-`SpendGraph` meters what you spend. `Spendgraph` reads and writes everything else — prompts, tools, stats, events, keys, projects.
+`SpendGraph` meters what you spend. `Spendgraph` reads and writes everything else: prompts, tools, stats, events, keys, projects.
 
 ```ts
 import { Spendgraph } from "@spendgraph/sdk";
@@ -21,7 +21,7 @@ const summary = await sg.stats.summary({ from, to });
 ```
 
 <Callout tone="trap" title="Two classes, one capital letter apart">
-  `SpendGraph` is the meter — `wrap`, `track`, `flush`. `Spendgraph` is the API client. Both are exported from the package root, autocomplete offers both, and picking the wrong one gives you an object with none of the methods you expected. The meter is the one with the capital G.
+  `SpendGraph` is the meter: `wrap`, `track`, `flush`. `Spendgraph` is the API client. Both are exported from the package root, autocomplete offers both, and picking the wrong one gives you an object with none of the methods you expected. The meter is the one with the capital G.
 </Callout>
 
 ## Why go through it
@@ -48,7 +48,7 @@ new Spendgraph({ session: cookie, baseUrl });    // the second
 new Spendgraph({ token: "sgc_…", baseUrl });     // a terminal, via cli.exchange
 ```
 
-An `sgc_` token stands in for a person's session anywhere a session is accepted, and unlike a cookie it can be revoked — see `cli.revoke`.
+An `sgc_` token stands in for a person's session anywhere a session is accepted, and unlike a cookie it can be revoked. See `cli.revoke`.
 
 ## A key is already pinned
 
@@ -61,7 +61,7 @@ Naming a *different* project in a body comes back `403 project_not_accessible` r
 | | |
 | --- | --- |
 | `sg.stats` | `summary` · `timeseries` · `byModel` · `byKey` · `byTag` |
-| `sg.events` | `list` — raw events, filtered, paged, or as CSV |
+| `sg.events` | `list`: raw events, filtered, paged, or as CSV |
 | `sg.ingest` | reporting usage by hand, up to 100 events a call |
 | `sg.prompts` | `list` · `create` · `update` · `promote` · `rollouts` · `report` |
 | `sg.tools` | `list` · `get` · `create` · `update` · `archive` |
@@ -74,7 +74,7 @@ Naming a *different* project in a body comes back `403 project_not_accessible` r
 
 ## The escape hatch
 
-`sg.http` is the transport underneath. Reach for it only for a route the class does not cover yet — you keep the auth, retries and error handling, and you give up the types.
+`sg.http` is the transport underneath. Reach for it only for a route the class does not cover yet: you keep the auth, retries and error handling, and you give up the types.
 
 ```ts
 await sg.http.get("/api/v1/something-new");
@@ -82,4 +82,4 @@ await sg.http.get("/api/v1/something-new");
 
 ## Next
 
-What happens when a call fails, and what retries on its own: [Errors and retries](/docs/sdk/errors).
+What happens when a call fails, and what retries on its own: [Errors and retries](/spendgraph/sdk/errors).

package/docs/errors.mdx

@@ -1,5 +1,5 @@
 export const meta = {
-  title: "Errors and retries — spendgraph docs",
+  title: "Errors and retries: spendgraph docs",
   description:
     "One error type carrying the status, the code, and how many attempts it took. The client retries what is worth retrying and nothing else; the meter never throws at all.",
 };
@@ -59,7 +59,7 @@ const sg = new Spendgraph({ apiKey, baseUrl, attempts: 5, maxWaitMs: 2000 });
 
 ## `retry-after` wins, but not unbounded
 
-When the server sends `retry-after`, the client waits that long rather than guessing — the server knows when its window reopens and your backoff does not.
+When the server sends `retry-after`, the client waits that long rather than guessing, the server knows when its window reopens and your backoff does not.
 
 The two caps do different jobs, and the difference is worth keeping straight. `maxWaitMs` bounds **our own** backoff and is small. `maxRetryAfterMs` bounds **the server's** instruction and is much larger, because clamping a `retry-after: 600` down to five seconds would retry straight back into the same closed window and burn every remaining attempt for nothing.
 
@@ -71,9 +71,9 @@ Backoff is spread with jitter so a fleet of clients does not wake in lockstep an
 
 ## Why the meter is different
 
-The SDK's metering half batches events — 5 seconds or 20 events, whichever lands first — and if the server is unreachable it drops them.
+The SDK's metering half batches events, 5 seconds or 20 events, whichever lands first, and if the server is unreachable it drops them.
 
-That is a trade, stated plainly: a metering library that takes your app down when the meter is having a bad day has failed at something more important than metering. [`flush()`](/docs/sdk/tracking) is how you decide when the risk of losing a batch matters more than the latency of waiting for it.
+That is a trade, stated plainly: a metering library that takes your app down when the meter is having a bad day has failed at something more important than metering. [`flush()`](/spendgraph/sdk/tracking) is how you decide when the risk of losing a batch matters more than the latency of waiting for it.
 
 ## Unpriced models are not errors
 

package/docs/integrations.mdx

@@ -0,0 +1,74 @@
+export const meta = {
+  title: "Integrations | spendgraph docs",
+  description: "LangChain, LangGraph and the Vercel AI SDK, each in one line. Built in, no extra dependencies.",
+};
+
+# Integrations
+
+Every integration ships inside the SDK: subpath imports, zero extra dependencies, version-agnostic because they read shapes rather than packages, and fail-open like everything else.
+
+## LangChain
+
+One callback handler covers every model call in a chain.
+
+```ts
+import { spendGraphHandler } from "@spendgraph/sdk/langchain";
+
+const handler = spendGraphHandler(meter, { metadata: { feature: "rag" } });
+
+await chain.invoke(input, { callbacks: [handler] });
+```
+
+Or attach it once to the model, which covers everything that model ever does:
+
+```ts
+const llm = new ChatAnthropic({
+  model: "claude-sonnet-5",
+  callbacks: [handler],
+});
+```
+
+## LangGraph
+
+The same handler. LangGraph forwards callbacks to every node, so one line tracks every model call inside the graph: agents and tools included.
+
+```ts
+const graph = workflow.compile();
+await graph.invoke(state, { callbacks: [spendGraphHandler(meter)] });
+```
+
+## Vercel AI SDK
+
+There is no client to wrap here, you call functions, not methods, so you hand it the result instead. Both v4 and v5 usage shapes are handled.
+
+```ts
+import { trackAiResult } from "@spendgraph/sdk/ai";
+
+const result = await generateText({ model: anthropic("claude-sonnet-5"), prompt });
+trackAiResult(meter, result);
+```
+
+Streaming usage is only known at the end, so report it from `onFinish`:
+
+```ts
+streamText({ model, prompt, onFinish: (r) => trackAiResult(meter, r) });
+```
+
+A third argument takes the same `metadata` as the other integrations, and lets you name the model outright:
+
+```ts
+trackAiResult(meter, result, {
+  metadata: { feature: "summarise", tenant: user.orgId },
+  model: "claude-sonnet-5",
+});
+```
+
+Pass `model` when you know it. The id is otherwise read off the result, and a shape that does not carry one is tracked as `unknown`: the token counts are kept rather than dropped, but nothing prices an id that is not in the catalog, so those calls show up as `unpriced`.
+
+<Callout tone="trap" title="Flush in route handlers">
+  The AI SDK is mostly used on serverless runtimes, which freeze the moment the response is sent. `await meter.flush()` before returning, or the buffered event goes with them.
+</Callout>
+
+## Everything else
+
+Anthropic and OpenAI clients use [`meter.wrap()`](/spendgraph/sdk/tracking). Any other framework or language reports with [`meter.track()`](/spendgraph/sdk/tracking) or a plain HTTP POST to [`/api/v1/ingest`](/spendgraph/sdk/api).

package/docs/quickstart.mdx

@@ -0,0 +1,58 @@
+export const meta = {
+  title: "Quickstart | spendgraph docs",
+  description: "Wire spendgraph into an app in two minutes: mint a key, wrap your provider client, watch spend appear.",
+};
+
+# Quickstart
+
+Two minutes, and the only code you write is the line that wraps your client.
+
+## 1. Get a key
+
+Create a project under [Projects](https://spendgraph.locusgraph.com/projects), then mint an API key under [API keys](https://spendgraph.locusgraph.com/keys), both live under **Setup** in the dashboard sidebar.
+
+<Callout tone="warn" title="Shown once">
+  The plaintext key appears on screen a single time and is never recoverable. Put it in your secret store before you close the tab.
+</Callout>
+
+## 2. Install
+
+```bash
+npm install @spendgraph/sdk
+```
+
+## 3. Wrap your client
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+import { SpendGraph } from "@spendgraph/sdk";
+
+const meter = new SpendGraph({
+  apiKey: process.env.SPENDGRAPH_API_KEY, // sg_…
+  baseUrl: "https://spendgraph.locusgraph.com",
+});
+
+const anthropic = meter.wrap(new Anthropic());
+
+const msg = await anthropic.messages.create({
+  model: "claude-sonnet-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello" }],
+});
+```
+
+That is the whole integration. Use the client exactly as before: usage is read off each reply and reported for you. Spend appears on the dashboard within seconds.
+
+## What it will not do to you
+
+The SDK is fire-and-forget by design. It never throws into your code, never blocks a request, batches events (5 seconds or 20 events, whichever comes first), and **drops data rather than crash your app** if the server is unreachable.
+
+That last one is a deliberate trade. A metering library that takes your app down when the meter is having a bad day has failed at something more important than metering.
+
+<Callout tone="trap" title="`wrap()` reads usage off the reply, so a stream has to ask for it">
+  A streamed call that did not request usage reports no tokens, and no tokens prices at $0.00, a hole in the dashboard that looks like a saving. If you stream, make sure the request asks for usage; `@spendgraph/llms` does it for you.
+</Callout>
+
+## Next
+
+Anthropic and OpenAI clients work with `wrap()`. Anything else, Gemini, Bedrock, a framework, another language, reports through [`track()`](/spendgraph/sdk/tracking) or a plain HTTP POST. If it can tell you its token counts, spendgraph can price it.

package/docs/tracking.mdx

@@ -1,5 +1,5 @@
 export const meta = {
-  title: "Tracking — spendgraph docs",
+  title: "Tracking: spendgraph docs",
   description:
     "The three SDK functions: wrap a client, track an event by hand, and flush before a serverless runtime freezes.",
 };
@@ -10,7 +10,7 @@ Three functions. Most apps only ever call the first.
 
 ## meter.wrap(client)
 
-A proxy over an Anthropic or OpenAI client. After each call resolves, the provider's own usage block — `usage.input_tokens` or `usage.prompt_tokens` — is read and reported. No per-call code, and no wrapper object to thread through your app.
+A proxy over an Anthropic or OpenAI client. After each call resolves, the provider's own usage block, `usage.input_tokens` or `usage.prompt_tokens`, is read and reported. No per-call code, and no wrapper object to thread through your app.
 
 ```ts
 const anthropic = meter.wrap(new Anthropic());
@@ -33,7 +33,7 @@ meter.track({
 });
 ```
 
-`metadata` is what the **Cost by tenant** and **Cost by feature** breakdowns group on. Two keys you will want on day one are `feature` and either `tenant` or `env` — without them, spend is one undifferentiated number and the dashboard can only tell you that it went up.
+`metadata` is what the **Cost by tenant** and **Cost by feature** breakdowns group on. Two keys you will want on day one are `feature` and either `tenant` or `env`, without them, spend is one undifferentiated number and the dashboard can only tell you that it went up.
 
 `eventId` makes a retry safe. Send the same id twice and the second is discarded server-side rather than double-counted.
 
@@ -42,7 +42,7 @@ meter.track({
 Sends everything buffered right now.
 
 <Callout tone="trap" title="Serverless runtimes freeze the moment you respond">
-  Vercel functions, Lambda, and Cloudflare Workers stop executing as soon as the response is sent — and the batched events go with them. `await meter.flush()` before returning from a route handler, or you will lose the tail of every request.
+  Vercel functions, Lambda, and Cloudflare Workers stop executing as soon as the response is sent, and the batched events go with them. `await meter.flush()` before returning from a route handler, or you will lose the tail of every request.
 </Callout>
 
 ```ts
@@ -53,7 +53,7 @@ export async function POST(req: Request) {
 }
 ```
 
-On a long-lived server you can ignore it — the batch timer handles things.
+On a long-lived server you can ignore it, the batch timer handles things.
 
 ## Unknown models
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spendgraph/sdk",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "Track LLM input/output tokens and cost. Three functions, zero dependencies, fail-open.",
   "license": "Apache-2.0",
   "repository": {
@@ -46,6 +46,7 @@
     "README.md"
   ],
   "devDependencies": {
+    "@spendgraph/config": "0.8.1",
     "typescript": "^5"
   },
   "engines": {
@@ -56,6 +57,7 @@
   },
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json --emitDeclarationOnly && tsc -p tsconfig.json --declaration false --removeComments && node ../../scripts/minify.mjs dist",
-    "test": "vitest run"
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.tests.json"
   }
 }