margin-meter 0.1.0 → 0.3.0

package/dist/index.d.ts

@@ -21,11 +21,122 @@
  *    written `source` is forced server-side to the key's project slug — the
  *    client cannot spoof another project's economics.
  */
+import { type ProviderName } from "./providers.ts";
+import { type Substrate } from "./substrate.ts";
+export * from "./providers.ts";
+export * from "./instrument.ts";
+export * from "./batching.ts";
+export * as substrate from "./substrate.ts";
+export type { Substrate } from "./substrate.ts";
+export * as promptfoo from "./promptfoo.ts";
+export * as braintrust from "./braintrust.ts";
+export * as langsmith from "./langsmith.ts";
+export * as vitest from "./vitest.ts";
 export declare const CALLS_PATH = "/api/ingest/calls";
 export declare const OUTCOMES_PATH = "/api/ingest/outcomes";
 export declare const KEY_HEADER = "X-Margin-Key";
-export declare const DEFAULT_INGEST_URL = "http://127.0.0.1:8000";
 export declare const DEFAULT_TIMEOUT_MS = 10000;
+/** One batched request's byte ceiling, and the retry policy behind it. Full
+ *  reasoning in `docs/reference/SDK_BATCHING.md`; the short version:
+ *
+ *  - 1 MB is ~7x headroom over a worst-case 1500-byte row at the default 100
+ *    records, and far under any gateway limit. Vercel accepts 100 MB bodies;
+ *    that is a ceiling, not a target.
+ *  - 3 attempts with FULL jitter rather than plain exponential, because every
+ *    buffered client backs off on the same schedule and un-jittered retries
+ *    re-synchronise into a herd aimed at the endpoint that just failed.
+ *  - Duplicates from an at-least-once retry are free: every record carries an
+ *    `event_id` and the server is idempotent on `(source, event_id)`.
+ */
+export declare const MAX_BATCH_BYTES = 1000000;
+export declare const RETRY_ATTEMPTS = 3;
+export declare const RETRY_BASE_MS = 1000;
+export declare const RETRY_CAP_MS = 30000;
+/** The active step's re-label. Mirrors the Python `_STAGE_OVERRIDE` tuple. */
+interface StageOverride {
+    operation?: string;
+    sessionId?: string;
+    taskClass?: string;
+}
+/** Options for {@link stage}. */
+export interface StageOptions {
+    /** The run this step belongs to. Wins over a `sessionId` passed at the call —
+     *  that is how the steps of one multi-agent run share an id. */
+    sessionId?: string;
+    /** WHAT KIND of work this step does, in the vocabulary the face-off ledger is
+     *  keyed on (`signal-check`, `document-extraction`, …). DECLARED, never inferred
+     *  from the step name (see `RecordCallInput.taskClass`). A call that names its
+     *  own `taskClass` keeps it; this fills the ones that do not. */
+    taskClass?: string;
+    /** Attach this step under a parent the async context cannot see — a branch run
+     *  on a worker (`AsyncLocalStorage` does not cross a worker boundary, exactly as
+     *  a Python contextvar does not cross a bare thread). Without it such a branch
+     *  records as a root, which reads as "no chain happened" rather than the missing
+     *  edge it is, so pass it by hand there. */
+    parentSpanId?: string;
+}
+/** Options for {@link span}. */
+export interface SpanOptions {
+    /** The orchestration shape THIS block performs. Rides only the calls emitted
+     *  directly in it — a nested span opens its own node and inherits none of it, so
+     *  `branchWidth` on a child cannot claim the child did the fanning out. */
+    pattern?: "pipeline" | "barrier" | "panel" | "loop_until_dry";
+    /** How many branches the orchestration opened. */
+    branchWidth?: number;
+    /** The rule that ended the orchestration, free text (e.g. "majority of 3"). */
+    stoppingRule?: string;
+    /** Force this node's id instead of generating one — for a branch resumed in
+     *  another process that must reuse a known id. */
+    spanId?: string;
+    /** Attach this node under a parent the async context cannot see (worker/process
+     *  boundary), the same case as {@link StageOptions.parentSpanId}. */
+    parentSpanId?: string;
+}
+/** Mark one STEP of a pipeline — its name, its identity in the chain, and its kind
+ *  — for the length of `fn`. Every call `fn` makes, however many awaits deep,
+ *  meters as this operation and records as one node of the chain, nested under any
+ *  enclosing `stage`/`span`. Returns whatever `fn` returns (a value or a promise).
+ *
+ *  ```ts
+ *  import { MarginMeter, stage, instrumentGemini } from "margin-meter";
+ *  await stage("classify", { taskClass: "signal-check", sessionId: runId }, () =>
+ *    classifier.run(input),          // meters as operation="classify"
+ *  );
+ *  await stage("implement", { taskClass: "algorithm", sessionId: runId }, () =>
+ *    implementer.run(plan),          // ... and these as operation="implement"
+ *  );
+ *  ```
+ *
+ *  The two steps share `sessionId` but carry DISTINCT operations, so the run reads
+ *  as a real >=2-step pipeline instead of collapsing onto one node — the exact bug
+ *  the Python SDK hit before `stage()` opened a span. The step's span id is passed
+ *  to `fn`, for the worker-boundary case where a child must be attached explicitly
+ *  via {@link StageOptions.parentSpanId}. This is the TS twin of `margin_meter.stage`. */
+export declare function stage<T>(operation: string, fn: (spanId: string) => T): T;
+export declare function stage<T>(operation: string, opts: StageOptions, fn: (spanId: string) => T): T;
+/** The active `(operation, sessionId, taskClass)` step override, or `undefined`
+ *  outside any `stage`. */
+export declare function currentStage(): StageOverride | undefined;
+/** Mark every metered call inside `fn` as one node of an agent tree — the tree the
+ *  Money Map decomposes to ask what a BRANCH cost, which a flat list of calls
+ *  sharing a `sessionId` cannot answer. Nesting is what builds the tree; returns
+ *  whatever `fn` returns.
+ *
+ *  ```ts
+ *  await span({ pattern: "panel", branchWidth: 3, stoppingRule: "majority of 3" }, () =>
+ *    Promise.all(candidates.map((c) => judge(c))),   // each judge nests its own node
+ *  );
+ *  ```
+ *
+ *  `stage()` is the primitive to reach for on a plain pipeline step; `span()` adds
+ *  the orchestration shape when a block fans out. This is the TS twin of
+ *  `margin_meter.span`. */
+export declare function span<T>(opts: SpanOptions, fn: (spanId: string) => T): T;
+/** The active `(spanId, parentSpanId)`, or `undefined` outside any span/stage. */
+export declare function currentSpan(): {
+    spanId: string;
+    parentSpanId?: string;
+} | undefined;
 /** The outcome of one emit. Returned by every record call. */
 export interface IngestResult {
     /** True only on an HTTP 200. */
@@ -36,6 +147,37 @@ export interface IngestResult {
     body?: Record<string, unknown>;
     /** The failure reason, when not ok. */
     error?: string;
+    /** The same failure as a stable BUCKET (`no_key`, `transport`, `http_<status>`).
+     *  `error` is a human sentence and its wording moves, so anything COUNTING
+     *  failures reads this instead of parsing that. Absent when ok. */
+    reason?: string;
+}
+/** What a meter TRIED to deliver against what actually landed.
+ *
+ *  A meter is fail-safe by contract: a dropped row never breaks the host app and
+ *  never throws. That trade is right — telemetry must not take an agent down —
+ *  but it makes the failure INVISIBLE, and an invisible loss reads downstream as
+ *  traffic that never happened. Margin's own 2026-07-25 invoice reconcile found
+ *  ~65 of ~200 `gpt-4o` calls missing from the ledger with nothing anywhere
+ *  having recorded a single failure, so the rate could not be told from the cause.
+ *
+ *  `dropRate` is the number that answers "is the ledger short because the agent
+ *  made fewer calls, or because we failed to deliver them?" — the one question a
+ *  coverage gap cannot answer about itself.
+ *
+ *  Narrower than the Python SDK's `DeliveryStats` on purpose, not by omission:
+ *  this client has no file sink and no cross-hook de-dup, so it has no
+ *  `unmeasured` holes to name and no `deduped` suppressions to keep out of the
+ *  loss count. Every emit it makes goes through one door and is counted there. */
+export interface DeliveryStats {
+    attempted: number;
+    delivered: number;
+    dropped: number;
+    /** Share of attempted emits that never landed. 0 when nothing was tried. */
+    dropRate: number;
+    droppedByReason: Record<string, number>;
+    attemptedByPath: Record<string, number>;
+    droppedByPath: Record<string, number>;
 }
 /** The response shape a transport returns (a subset of the `fetch` Response). */
 export interface TransportResponse {
@@ -84,21 +226,140 @@ export interface RecordCallInput {
     inputTokens?: number;
     outputTokens?: number;
     cacheReadTokens?: number;
+    cacheCreationTokens?: number;
+    /** The 1-hour-TTL portion of cache creation (Anthropic bills it ~2x input, not
+     *  the 5-minute ~1.25x). Disjoint from cacheCreationTokens; omit/0 when a call
+     *  uses only the default cache. */
+    cacheCreation1hTokens?: number;
+    /** The hidden-thinking share of outputTokens (Gemini thoughts, OpenAI
+     *  reasoning_tokens). A SUBSET of output, already priced at the output rate —
+     *  never priced separately. Carried only so the reasoning-effort lever can be
+     *  isolated; omit/0 on a non-reasoning call. */
+    reasoningTokens?: number;
     latencyMs?: number;
     status?: string;
     isRetry?: boolean;
     sessionId?: string;
     promptId?: string;
+    /** The STEP within a multi-operation workflow this call belongs to (a
+     *  supply-chain node label the Money Map decomposes by, e.g. "extract"). Omit
+     *  for a single-call workflow. */
+    operation?: string;
+    /** WHERE the agent lives — the org-chart rung ABOVE it (MAR-345). `environment`
+     *  is prod/staging; `team` is who owns it. Two fields rather than one composite
+     *  because they are two questions: "is this real traffic?" and "whose budget?".
+     *
+     *  ⛔ These are LABELS. They group rows in the estate view and authorise nothing
+     *  — ownership is still the ingest key's project, forced server-side, which is
+     *  the part a caller cannot spoof. Omit both and the registry reports the agent
+     *  under `(unlabelled)`, never a home it did not claim.
+     *
+     *  ⚠️ Omitting them is not free, though: the estate tree collapses from four
+     *  rungs to two, so "you are running 34 agents across 3 environments" degrades
+     *  to a flat list. Measured 2026-08-08 — every production row was `(unlabelled)`
+     *  because this SDK had no way to send them at all. */
+    environment?: string;
+    team?: string;
     costUsd?: number;
     isSimulated?: boolean;
+    /** Idempotency key baked into the emitted payload. Defaults to a fresh uuid
+     *  per call, so a redelivery of THIS exact emit (a transport retry) collapses
+     *  to one row server-side instead of double-counting spend. Distinct calls get
+     *  distinct ids, so real volume is never deduped away. */
+    eventId?: string;
+    /** The provider billing tier. "standard" (the default) is a normal synchronous
+     *  call; "batch" is a call routed through the async Batch API, which the server
+     *  prices at the ~50%-off tier — pricing a real batch call standard would
+     *  over-state its cost. Omit for standard; the field is sent only when "batch". */
+    billingTier?: "standard" | "batch";
+    /** This call's own node in an agent tree. A branching run is otherwise a flat
+     *  list of calls sharing a sessionId — enough to total the run, never enough to
+     *  ask what one BRANCH cost. Omit for a single-agent call. */
+    spanId?: string;
+    /** The node that spawned this one; omit at the root. Requires `spanId` (a parent
+     *  link with no node of its own is an edge to nowhere, and the server rejects
+     *  it). */
+    parentSpanId?: string;
+    /** The orchestration shape THIS call performed, on the node that did the
+     *  orchestrating — not on its branches. The set is closed server-side so shapes
+     *  stay comparable across runs. */
+    orchestrationPattern?: "pipeline" | "barrier" | "panel" | "loop_until_dry";
+    /** How many branches the orchestration opened. */
+    branchWidth?: number;
+    /** The rule that ended the orchestration, free text (e.g. "majority of 3"). */
+    stoppingRule?: string;
+    /** Which PATH this call took to reach the model — the vendor's own API
+     *  ("direct"), a router ("openrouter", "litellm"), a cloud reseller ("azure",
+     *  "bedrock", "vertex"), or an unrecognised proxy ("gateway"). Independent of
+     *  `provider`, which says who owns the model and bills for it: the same
+     *  openai/gpt-4o call can arrive over four different paths, and comparing them
+     *  is something a single-substrate router structurally cannot do. Omit it when
+     *  the path is not actually known — an unmeasured dimension belongs empty, not
+     *  defaulted to "direct". The set is closed server-side. */
+    substrate?: "direct" | "openrouter" | "litellm" | "azure" | "bedrock" | "vertex" | "gateway";
+    /** WHICH UNIT OF WORK this call served, in your own vocabulary — a ticket
+     *  topic, an intent label, a corpus task id. Margin measures a route's parity
+     *  on a sample and records what that sample was made of; this is what lets it
+     *  then say whether the traffic arriving now is still that population, rather
+     *  than only whether the route got worse. Omit it and that question reads
+     *  `unknown`, which is the honest answer and a permanent one. Open-ended on
+     *  purpose: a topic nobody has seen before is how a mix shift announces
+     *  itself. Never priced. Truncated server-side at 128 characters rather than
+     *  refused — a long ticket subject costs you the tail of the label, never the
+     *  call's tokens or cost. */
+    taskKey?: string;
+    /** WHAT KIND of work this step does (MAR-898), in the vocabulary Margin's face-off
+     *  ledger is keyed on: `signal-check`, `document-extraction`, `multi-hop-reasoning`,
+     *  `algorithm`. `taskKey` is WHICH unit of work; this is WHAT KIND, and the
+     *  difference matters because a hold-rate prior is earned per CLASS — so a step
+     *  without one can be measured and still not be advisable.
+     *
+     *  ⛔ DECLARE IT; never let it be inferred from a step name. An operation called
+     *  `summarize` may or may not be the class the ledger calls document-extraction,
+     *  and mapping by resemblance would attach a real model recommendation to work it
+     *  may not describe. Omit it and the step reads `not_measured` in a per-stage plan,
+     *  which is the honest answer. Never priced; truncated server-side at 128. */
+    taskClass?: string;
+    /** WHICH AGENT SCAFFOLD drove the call (MAR-371) — the orchestration around the
+     *  model (Claude Code, a LangChain agent, a bespoke loop). The same model on the
+     *  same tasks costs differently by which harness ran it (Composio measured a 4.7x
+     *  spread across eight), independent of `model` and `substrate`. Open-ended, never
+     *  priced, truncated server-side at 64 characters. Omit it when the scaffold is not
+     *  known — an unmeasured dimension belongs empty. */
+    harness?: string;
+    /** WHY the provider ended the generation, read verbatim off the response
+     *  (Anthropic `stop_reason`, OpenAI/Gemini `finish_reason`, Bedrock `stopReason`).
+     *  A raw signal, NOT a billing verdict: a blocked-and-fell-back call (Fable 5's
+     *  safety fallback) is often not billed, but that is settled by the invoice, never
+     *  inferred from this reason alone (MAR-209). Rides only when the provider reported
+     *  one; absent it stays `unknown`, first-class. Never priced. Truncated
+     *  server-side (open vocabulary — a novel reason is never a dropped row). */
+    finishReason?: string;
 }
 export interface RecordOutcomeInput {
     workflowId: string;
     passed: boolean;
     qualityScore?: number;
     qualityMethod?: string;
+    /** WHO/what graded the score: "code" | "judge" | "human". Recorded, never
+     *  inferred — omit to leave the grader kind unknown on the server. */
+    graderKind?: string;
+    /** Model id that judged when graderKind is "judge". */
+    judgeModelId?: string;
+    /** How SURE the grader was of qualityScore, in [0, 1]. Recorded, never inferred —
+     *  omit to leave it unknown on the server (a missing value is never read as
+     *  "certain"). */
+    graderConfidence?: number;
     link?: string;
     isSimulated?: boolean;
+    /** Idempotency key (see RecordCallInput.eventId): a redelivered outcome does
+     *  not double-count the cost-per-outcome denominator. Defaults to a fresh uuid. */
+    eventId?: string;
+    /** The WORTH of this outcome in USD — the value-per-outcome NUMERATOR
+     *  (RA-31 / MAR-634). Supply it when the outcome has a known business value;
+     *  omit it and the outcome is measured as cost-per-outcome, the honest default.
+     *  Optional by construction — absent is the normal case, never defaulted to 0. */
+    valueUsd?: number;
 }
 /** A per-project client that emits measured economics to a Margin ingest API. */
 export declare class MarginMeter {
@@ -106,8 +367,84 @@ export declare class MarginMeter {
     apiKey?: string;
     raiseOnError: boolean;
     private transport;
+    private attempted;
+    private delivered;
+    private droppedByReason;
+    private attemptedByPath;
+    private droppedByPath;
+    private warnedOnDrop;
+    private noUrl;
+    private batcher;
+    private exitFlush;
+    private exitFlushArmed;
     constructor(options?: MarginMeterOptions);
+    /** Attach the process-exit flush, once, on the first row that will need it. */
+    private armExitFlush;
+    /** Record one emit attempt. Called at every exit point that knows its own
+     *  outcome, BEFORE any `raiseOnError` throw, so a strict-mode failure is
+     *  counted exactly like the fail-safe one it would otherwise have been. */
+    private count;
+    /** A snapshot of what this meter delivered against what it tried to.
+     *  See {@link DeliveryStats}. */
+    deliveryStats(): DeliveryStats;
+    /**
+     * Route one built payload to the wire or the buffer.
+     *
+     * Buffering is the default and the whole point (`docs/reference/SDK_BATCHING.md`).
+     * Two cases deliberately stay immediate, and neither is a knob:
+     *
+     * - **Strict mode** (`raiseOnError`) means "throw at MY call site when this row
+     *   is rejected", and a buffered emit has no call site left to throw at by the
+     *   time the POST happens. The two are incompatible, so strict posts now.
+     * - **No key**, because buffering rows that can never be sent would fill the
+     *   queue and then report `queue_full` — a diagnosis that sends the reader
+     *   hunting for a network problem when the answer is a missing variable.
+     *   A missing URL is the same case and is named `no_url`.
+     */
     private emit;
+    /** Hand one record to the buffer. Never blocks, never throws.
+     *
+     *  `ok: true` here means ACCEPTED INTO THE BUFFER, not written to the ledger —
+     *  the body says `queued` so nothing mistakes the two. What actually landed is
+     *  `deliveryStats()`, which exists for exactly this question. */
+    private enqueue;
+    /** Resolve once every buffered row has been delivered or counted as dropped.
+     *
+     *  Call it before reading `deliveryStats()` if you need the counts to cover rows
+     *  you have only just emitted — buffering separates an emit from its delivery
+     *  in time by design. */
+    flush(): Promise<void>;
+    /** Drain the buffer and stop the timer. Registered on `beforeExit`.
+     *
+     *  Anything the timeout strands is COUNTED as dropped rather than abandoned: the
+     *  records are handed back by `Batcher.close` precisely so the number is
+     *  knowable. */
+    close(timeoutMs?: number): Promise<void>;
+    private postNow;
+    /** POST one buffered batch. Never rejects: it owns its own accounting.
+     *
+     *  ⛔ The blanket `catch` is load-bearing, not defensive habit. `Batcher.flush`
+     *  swallows a rejection to keep the drain going, so anything escaping here would
+     *  vanish with the counters reading a clean sheet — an uncounted loss, which
+     *  makes measured spend read CHEAPER than the bill. Scoped per chunk so records
+     *  already accounted for in an earlier chunk are not counted twice. */
+    private sendBatch;
+    /** Split a batch so no request exceeds {@link MAX_BATCH_BYTES}.
+     *
+     *  ⛔ A single record over the cap on its own is DROPPED and counted as
+     *  `oversize`. No split can send it, and keeping it would wedge the queue behind
+     *  one poisoned row forever. It is a bug in the caller — every open-vocabulary
+     *  field is already bounded server-side, so an honest row cannot come near a
+     *  megabyte.
+     *
+     *  ⛔ A payload that will not serialise is dropped and counted too, and that case
+     *  is not exotic — a `BigInt` anywhere in the payload makes `JSON.stringify`
+     *  throw. Unguarded, the throw escaped into the flush and the row vanished with
+     *  the counters reading a clean sheet. */
+    private chunkByBytes;
+    private deliverChunk;
+    /** POST one batch, retrying the failures that clear with time. */
+    private postBatchWithRetry;
     /** Emit one measured LLM call. Cost is computed server-side when `costUsd`
      *  is omitted. Never throws unless `raiseOnError`. */
     recordCall(input: RecordCallInput): Promise<IngestResult>;
@@ -122,17 +459,107 @@ export declare class MarginMeter {
      * value `fn` produced; the emit's `IngestResult` is available as `m.result`.
      */
     measure<T>(input: Omit<RecordCallInput, "latencyMs" | "status">, fn: (m: Measurement) => Promise<T> | T): Promise<T>;
+    /**
+     * Meter one call by reading tokens straight off its provider `response`
+     * (OpenAI / Anthropic / Gemini result). The no-bookkeeping counterpart to
+     * `recordCall`: the `(provider, model, tokens)` are recovered by
+     * `extractUsage`. `provider` is optional when the shape is unambiguous but the
+     * instrumenter always passes it; `model` overrides a response that omits it
+     * (Gemini). Numbers are read verbatim. Never throws unless `raiseOnError`.
+     */
+    recordResponse(input: RecordResponseInput): Promise<IngestResult>;
+    /**
+     * Return `fn` wrapped so every call is timed and auto-metered. The core
+     * auto-instrumentation primitive: give it any async LLM call
+     * (`client.chat.completions.create`, `client.messages.create`,
+     * `model.generateContent` …) and it returns a drop-in replacement that times
+     * the call, emits its economics from the returned response, and hands the
+     * ORIGINAL response back untouched. On a throw the call is metered with
+     * `status="error"` and the error re-thrown (never swallowed); a metering
+     * failure is fail-safe and never breaks the wrapped call. `provider` is
+     * required for a shape the extractor can't disambiguate; `model` supplies a
+     * model the response omits (Gemini); `resolveModel(args)` derives it per call
+     * (e.g. off a bound Gemini model). Signature-agnostic (`...args`).
+     */
+    wrap<F extends (...args: never[]) => Promise<unknown>>(fn: F, opts: WrapOptions): (...args: Parameters<F>) => Promise<Awaited<ReturnType<F>>>;
+}
+/** Input to `recordResponse` — meter off a provider response object. */
+export interface RecordResponseInput {
+    workflowId: string;
+    response: unknown;
+    provider?: ProviderName;
+    model?: string;
+    latencyMs?: number;
+    status?: string;
+    isRetry?: boolean;
+    sessionId?: string;
+    promptId?: string;
+    operation?: string;
+    isSimulated?: boolean;
+    /** The delivery path the call took (see `substrate.ts`); omit when unknown. */
+    substrate?: Substrate;
+    /** The unit of work this call served (see `RecordCallInput.taskKey`). */
+    taskKey?: string;
+}
+/** Options for `wrap` — how to meter every call to the wrapped fn. */
+export interface WrapOptions {
+    workflowId: string;
+    provider?: ProviderName;
+    model?: string;
+    operation?: string;
+    sessionId?: string;
+    isRetry?: boolean;
+    isSimulated?: boolean;
+    /** Derive the model per call (e.g. off a bound Gemini model); a truthy return
+     *  overrides the static `model`. Receives the wrapped call's args. */
+    resolveModel?: (args: unknown[]) => string | undefined;
+    /** Derive the unit of work (`task_key`) per call — the WHICH-work axis. Resolved
+     *  AT CALL TIME on purpose: task identity is per-call, so this is a callable (read
+     *  a request-scoped store, the current ticket, an async-local), never a constant.
+     *  A single constant across a whole run would manufacture a one-class distribution
+     *  the mix gate treats as no signal (the reason the instrument path takes a
+     *  resolver, not a `taskKey` string — MAR-197 / MAR-46). Undefined return, or no
+     *  resolver, leaves the row's task_key unset: UNKNOWN, never a fabricated bucket. */
+    resolveTaskKey?: () => string | undefined;
+    /** OpenAI omits usage from a stream unless asked; when set (only by the OpenAI
+     *  chat instrumenter), a `stream: true` call gets `stream_options.include_usage`
+     *  injected so its final chunk carries the count the accumulator meters. */
+    streamIncludeUsage?: boolean;
+    /** Which DELIVERY PATH this wrapper's calls take (see `substrate.ts`). The JS
+     *  instrumenters patch a specific client instance, so the endpoint is known at
+     *  patch time and every call through this wrapper travelled it. Leave unset when
+     *  the endpoint could not be read — an unmeasured dimension belongs empty, never
+     *  defaulted to "direct". Never touches the cost math. */
+    substrate?: Substrate;
 }
 /** Token accumulator passed into `measure`'s callback. */
 export declare class Measurement {
     inputTokens: number;
     outputTokens: number;
     cacheReadTokens: number;
+    cacheCreationTokens: number;
+    cacheCreation1hTokens: number;
     result?: IngestResult;
     setTokens(tokens: {
         inputTokens?: number;
         outputTokens?: number;
         cacheReadTokens?: number;
+        cacheCreationTokens?: number;
+        cacheCreation1hTokens?: number;
     }): void;
 }
+/** The server's own `Retry-After`, in ms, when it sent one.
+ *
+ *  The ingest API computes the real wait from its rolling window rather than
+ *  sending a round number, so honouring it beats any backoff we could calculate
+ *  blind — a client that guesses either hammers or overshoots, and overshooting
+ *  drops exactly the calls the SDK was installed to record. */
+export declare function retryAfterMs_(resp: TransportResponse): number | undefined;
+/** FULL jitter — `random(0, base * 2**attempt)`, capped, or the server's wait.
+ *
+ *  Jittered rather than plain exponential because every buffered client backs off
+ *  on the same schedule: un-jittered retries re-synchronise into a thundering herd
+ *  aimed at the endpoint that just failed, which is how a brief blip becomes an
+ *  outage. */
+export declare function backoffMs(attempt: number, retryAfter?: number): number;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}