@kaana.ai/contracts 0.0.0-stage → 4.3.0

package/dist/public/messages.js

@@ -0,0 +1,251 @@
+/**
+ * Messages, content parts, tools and generation controls shared by every
+ * public request and by the signed envelope.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/request.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+import { reasoningEffortSchema } from './catalogue.js';
+/**
+ * Where binary or remote content comes from.
+ *
+ * `url` is fetched by the data plane; `inline` carries base64 the customer sent
+ * with the request. Both are transient: neither is persisted by default, and
+ * neither appears in a receipt, a log line or a telemetry event.
+ */
+export const inferenceContentSourceSchema = z.discriminatedUnion('kind', [
+    z.object({ kind: z.literal('url'), url: z.string().min(1).max(4096) }).strict(),
+    z
+        .object({
+        kind: z.literal('inline'),
+        mediaType: z.string().min(1).max(255),
+        data: z.string().min(1),
+    })
+        .strict(),
+]);
+/**
+ * One part of a message's content. A message is always a list of parts.
+ *
+ * ## `refusal` is a member and `reasoning` is not, and the asymmetry is the point
+ *
+ * A model that DECLINES says why, and those words are meant for the customer:
+ * they are the difference between "rephrase this" and "stop asking". Before this
+ * member existed there was nowhere in an {@link InferenceMessage} to put them, so
+ * a non-streaming fold kept `finishReason: 'refusal'` and dropped the sentence —
+ * the customer learned they were refused and not why, while a streaming caller of
+ * the same request got the whole explanation on the `refusal` delta channel.
+ *
+ * Reasoning is the opposite case and stays absent. It is the model's private
+ * working, and a `text` part is where somebody would put it — which renders
+ * private reasoning to the customer AS the answer, the product bug the delta
+ * channels exist to prevent. An opaque per-block reasoning blob crossing this
+ * boundary needs a home nobody has chosen yet, and inventing one here would
+ * choose it by accident.
+ *
+ * Both public dialects can carry a refusal, which is what separates the two
+ * cases at the boundary as well as in principle: `refusal` is OpenAI's OWN field
+ * in both of its shapes (`delta.refusal` streaming, `message.refusal`
+ * non-streaming), while reasoning has no OpenAI field at all — the
+ * `reasoning_content`/`reasoning` spellings an OpenAI-compatible provider emits
+ * are provider extensions. So carrying the refusal costs no dialect its
+ * standard-client parseability, and carrying reasoning would.
+ *
+ * The part is a MEMBER rather than a field because a refusal need not have text:
+ * an Anthropic `stop_reason: "refusal"` maps to the finish reason and separates
+ * no words from the answer, while an OpenAI-compatible `refusal` does. A required
+ * field would force the first provider to invent a sentence.
+ */
+export const inferenceContentPartSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('text'), text: z.string() }).strict(),
+    z
+        .object({
+        type: z.literal('image'),
+        source: inferenceContentSourceSchema,
+        /** Provider-independent hint; providers that ignore it are unaffected. */
+        detail: z.enum(['auto', 'low', 'high']).optional(),
+    })
+        .strict(),
+    z.object({ type: z.literal('audio'), source: inferenceContentSourceSchema }).strict(),
+    z
+        .object({
+        type: z.literal('file'),
+        source: inferenceContentSourceSchema,
+        filename: z.string().max(255).optional(),
+    })
+        .strict(),
+    /**
+     * A model's explanation for declining. Its own part, never a `text` one, so no
+     * renderer can present a refusal as the answer that was asked for.
+     */
+    z.object({ type: z.literal('refusal'), text: z.string() }).strict(),
+]);
+/**
+ * A tool call an assistant made, in the normalized form.
+ *
+ * `arguments` is the JSON TEXT the model emitted, not a parsed object: models
+ * emit invalid JSON often enough that parsing it here would turn a recoverable
+ * model mistake into a rejected message.
+ */
+export const inferenceToolCallSchema = z
+    .object({
+    id: z.string().min(1).max(128),
+    name: z.string().min(1).max(128),
+    arguments: z.string(),
+})
+    .strict();
+export const inferenceMessageRoleSchema = z.enum([
+    'system',
+    'developer',
+    'user',
+    'assistant',
+    'tool',
+]);
+/**
+ * One normalized message.
+ *
+ * The role-specific fields are refined rather than modelled as a discriminated
+ * union so the shape stays the one a caller recognises from the OpenAI-style
+ * dialects; the refinement is what stops `toolCallId` from riding on a user
+ * message, where every provider would silently ignore it.
+ */
+export const inferenceMessageSchema = z
+    .object({
+    role: inferenceMessageRoleSchema,
+    content: z.array(inferenceContentPartSchema),
+    /** Participant name, where the dialect supports naming participants. */
+    name: z.string().max(128).optional(),
+    /** The tool call this message answers. Required on, and only on, `tool`. */
+    toolCallId: z.string().min(1).max(128).optional(),
+    /** Tool calls the assistant made. Only on `assistant`. */
+    toolCalls: z.array(inferenceToolCallSchema).optional(),
+})
+    .strict()
+    .superRefine((message, ctx) => {
+    if (message.role === 'tool' && message.toolCallId === undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['toolCallId'],
+            message: 'a tool message must name the tool call it answers',
+        });
+    }
+    if (message.role !== 'tool' && message.toolCallId !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['toolCallId'],
+            message: 'only a tool message answers a tool call',
+        });
+    }
+    if (message.role !== 'assistant' && message.toolCalls !== undefined) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['toolCalls'],
+            message: 'only an assistant message makes tool calls',
+        });
+    }
+    // Same rule as `toolCalls`, for the same reason: only the assistant can
+    // decline, so a refusal on any other role is a part every provider would
+    // silently ignore — and one a renderer might not.
+    if (message.role !== 'assistant') {
+        for (const [index, part] of message.content.entries()) {
+            if (part.type === 'refusal') {
+                ctx.addIssue({
+                    code: 'custom',
+                    path: ['content', index, 'type'],
+                    message: 'only an assistant message carries a refusal',
+                });
+            }
+        }
+    }
+});
+/** Sampling parameters, all optional: absent means the route's own default. */
+export const samplingParametersSchema = z
+    .object({
+    temperature: z.number().min(0).max(2).optional(),
+    topP: z.number().min(0).max(1).optional(),
+    topK: z.number().int().positive().safe().optional(),
+    frequencyPenalty: z.number().min(-2).max(2).optional(),
+    presencePenalty: z.number().min(-2).max(2).optional(),
+    /** A seed makes a request reproducible on providers that honour one. */
+    seed: z.number().int().safe().optional(),
+    stopSequences: z.array(z.string().min(1).max(256)).max(8).optional(),
+})
+    .strict();
+/**
+ * A tool the model may call. `parameters` is a JSON Schema document, carried
+ * as an opaque object: validating the customer's JSON Schema against a meta
+ * schema here would reject documents providers accept.
+ */
+export const toolDefinitionSchema = z
+    .object({
+    type: z.literal('function'),
+    name: z.string().min(1).max(128),
+    description: z.string().max(2000).optional(),
+    parameters: z.record(z.string(), z.unknown()),
+    /** Ask the provider to enforce the schema, where it supports enforcement. */
+    strict: z.boolean().optional(),
+})
+    .strict();
+/** Whether, and which, tool the model must call. */
+export const toolChoiceSchema = z.union([
+    z.enum(['auto', 'none', 'required']),
+    z.object({ type: z.literal('function'), name: z.string().min(1).max(128) }).strict(),
+]);
+/** Structured-output request: free text, any JSON object, or a named schema. */
+export const responseFormatSchema = z.discriminatedUnion('type', [
+    z.object({ type: z.literal('text') }).strict(),
+    z.object({ type: z.literal('json_object') }).strict(),
+    z
+        .object({
+        type: z.literal('json_schema'),
+        name: z.string().min(1).max(128),
+        schema: z.record(z.string(), z.unknown()),
+        strict: z.boolean(),
+    })
+        .strict(),
+]);
+/**
+ * The caller's reasoning control. Strict, like every leaf: a provider-specific
+ * knob (`budget_tokens`, `summary`) is refused rather than silently dropped.
+ *
+ * Oxy forwards it only after checking the resolved model advertises the effort
+ * in its catalogue `reasoningEfforts`; Kaana translates it per provider.
+ */
+export const inferenceReasoningSchema = z.object({ effort: reasoningEffortSchema }).strict();
+/** Parameters for text-to-speech, preserved in the signed request. */
+export const inferenceSpeechParametersSchema = z
+    .object({
+    voice: z.string().min(1).max(64),
+    responseFormat: z.enum(['mp3', 'opus', 'aac', 'flac', 'wav', 'pcm']),
+    speed: z.number().min(0.25).max(4).optional(),
+})
+    .strict();
+/**
+ * Spoken output from a CONVERSATIONAL model (contract set 3.2.0) — an audio chat
+ * model answering in its own voice, as opposed to `speech`, which reads given
+ * text aloud. Presence is the request: a chat request carrying this asks for
+ * the answer as audio AND its transcript, which is the only combination the
+ * audio chat models produce (OpenAI's `modalities: ["text", "audio"]`).
+ *
+ * The audio streams as `audio` events and the words as `delta` events on the
+ * `output_audio_transcript` channel — never as `output_text`, because a
+ * transcript of speech the customer is already hearing is not a second answer.
+ * `pcm` is the only format an audio chat model can STREAM; the refinement on the
+ * envelope holds that rather than leaving a provider to refuse it mid-flight.
+ */
+export const inferenceAudioOutputParametersSchema = z
+    .object({
+    voice: z.string().min(1).max(64),
+    format: z.enum(['wav', 'mp3', 'flac', 'opus', 'pcm']),
+})
+    .strict();
+/**
+ * Customer-supplied cost-attribution labels, echoed on the generation record.
+ *
+ * Bounded in both directions because they are stored and read back: sixteen
+ * keys is a team/feature/environment tag set, not a place to smuggle a payload.
+ *
+ * Moved from the Oxy edge (`packages/api/src/schemas/inferenceEdge.schemas.ts`).
+ */
+export const requestLabelsSchema = z
+    .record(z.string(), z.string().max(256))
+    .refine((labels) => Object.keys(labels).length <= 16, 'at most 16 labels may be attached to one request');

package/dist/public/money.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Money, prices and usage units.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/money.ts`) by Kaana ADR 0002.
+ * `priceSnapshotSchema` comes from `priceVersion.ts`; the price VERSION record
+ * itself stays in `@oxy.so/contracts`, because Oxy owns the price lists.
+ */
+import { z } from 'zod';
+/** ISO 4217 alpha-3 currency code, e.g. `USD`. */
+export declare const currencyCodeSchema: z.ZodString;
+/**
+ * The declared fractional scale of every amount and price in this contract, and
+ * of the `NUMERIC` columns the ledger stores them in.
+ *
+ * Twelve digits is sub-minor-unit precision by a wide margin: at $3 per million
+ * input tokens, one token costs `0.000003000000`, which this scale represents
+ * exactly. Amounts are compared and summed NUMERICALLY, never as text — `3.0`
+ * and `3.000000000000` are one amount written two ways.
+ */
+export declare const INFERENCE_MONEY_SCALE = 12;
+/**
+ * An exact non-negative decimal, carried as a STRING so no parse step can turn
+ * it into a float on the way past. Up to 18 integer digits and
+ * {@link INFERENCE_MONEY_SCALE} fractional digits.
+ *
+ * Non-negative: direction is carried by the SHAPE — a receipt debits, a refund
+ * credits — so a stray sign can never silently invert an entry.
+ *
+ * No exponent form: `1e-6` and `0.000001` are the same number, but only one of
+ * them survives a naive string comparison, a cache key or a log grep intact.
+ *
+ * Branded, so a bare `string` is not assignable and an amount cannot arrive
+ * from string concatenation that was never checked. Producers construct one
+ * with `exactDecimalSchema.parse(value)`.
+ */
+export declare const exactDecimalSchema: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+/**
+ * An amount of money: the exact decimal plus the currency it is in.
+ *
+ * `.strict()` so a payload carrying a convenience float beside the exact value
+ * (`{ amount: '18.06', amountFloat: 18.06 }`) is REJECTED rather than stripped.
+ * A stripped float is the more dangerous outcome: it disappears silently here
+ * and survives in the producer, where it is the value somebody eventually
+ * displays.
+ */
+export declare const moneySchema: z.ZodObject<{
+    amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+    currency: z.ZodString;
+}, z.core.$strict>;
+/**
+ * The closed set of units inference is metered in.
+ *
+ * **The units PARTITION a request: every unit counts material no other unit
+ * counts.** `cached_input_tokens` is not part of `input_tokens`, and
+ * `reasoning_tokens` is not part of `output_tokens` — they are siblings, not
+ * subsets. A request whose 10 000-token prompt was served 9 000 tokens from
+ * cache is reported as `input_tokens: 1000` beside `cached_input_tokens: 9000`,
+ * never as `input_tokens: 10000` beside it.
+ *
+ * That belongs to the definition rather than to a convention somewhere else,
+ * because settlement applies a price to EVERY reported unit and sums them
+ * (`inferenceLedger.service.ts`'s `computeCharge`). Under the partition rule
+ * that sum IS the request's cost, and a cached token can carry its own — lower
+ * — price. Under the nested reading the same sum charges the cached and
+ * reasoning tokens twice: once inside their parent and once on their own line.
+ * It fails silently, because every total still looks plausible and the receipt
+ * is still internally consistent, and on a reasoning model the reasoning tokens
+ * can dominate the completion, so the error is not marginal.
+ *
+ * **Every OpenAI-compatible provider reports the other way round**:
+ * `prompt_tokens` INCLUDES `prompt_tokens_details.cached_tokens`, and
+ * `completion_tokens` INCLUDES `completion_tokens_details.reasoning_tokens`.
+ * Normalising is the data plane's job and it is subtraction:
+ *
+ * ```text
+ * input_tokens  = prompt_tokens     - prompt_tokens_details.cached_tokens
+ * output_tokens = completion_tokens - completion_tokens_details.reasoning_tokens
+ * ```
+ *
+ * **Audio tokens are siblings too** (added in contract set 3.2.0). A model that
+ * consumes or produces audio AS TOKENS — OpenAI's audio chat and Realtime
+ * models — reports them inside the same totals, and they are priced several
+ * times higher than text tokens, so folding them into `input_tokens` would
+ * under-charge by exactly the audio. They are subtracted out the same way:
+ *
+ * ```text
+ * cached_audio_input_tokens = prompt_tokens_details.cached_tokens_details.audio_tokens
+ * audio_input_tokens        = prompt_tokens_details.audio_tokens - cached_audio_input_tokens
+ * input_tokens              = prompt_tokens - (text AND audio cached) - audio_input_tokens
+ * audio_output_tokens       = completion_tokens_details.audio_tokens
+ * output_tokens             = completion_tokens - reasoning_tokens - audio_output_tokens
+ * ```
+ *
+ * `audio_input_milliseconds` and `audio_output_milliseconds` remain the units
+ * for audio metered by DURATION (file transcription, speech synthesis). A
+ * report carries one reading of a given audio, never both: the same audio
+ * reported as tokens and as milliseconds is the double charge this rule exists
+ * to prevent.
+ *
+ * **`session_milliseconds` is session wall-clock time** (added in contract set
+ * 3.3.0): wall-clock milliseconds a realtime session was open with the upstream
+ * provider; reported only by a provider that bills session time, and never
+ * together with a per-audio reading of the same span. xAI's Voice Agent API
+ * bills a session using server-side voice activity detection for its whole
+ * duration, speech or silence, which is neither audio sent nor audio received:
+ * reporting that clock as `audio_input_milliseconds` would misdescribe the
+ * charge, and reporting both would bill the same span twice. It is measured by
+ * the data plane from the upstream session's open to its close, never
+ * estimated from the audio, and a provider billed by the audio it carries (or
+ * by tokens) never reports it.
+ *
+ * **`input_transcription_milliseconds` is a second model's reading** (added in
+ * contract set 4.1.0): milliseconds of a realtime session's input audio that
+ * the deployment's own TRANSCRIPTION model transcribed, when the provider bills
+ * that model apart from the session model. OpenAI runs input transcription on
+ * a separate ASR model "billed according to the ASR model's pricing rather
+ * than the realtime model's", so the session model's `audio_input_tokens` and
+ * this unit are two charges for two models, each read once — which is why the
+ * partition rule holds: no other unit counts the transcription model's work.
+ * Reporting the ASR duration as `audio_input_milliseconds` beside the session
+ * model's audio tokens would be the "same audio as tokens and as milliseconds"
+ * this rule forbids, and folding it into the tokens would price it at the
+ * wrong model's rate. A provider whose session price already includes the
+ * transcription (xAI's Voice Agent) never reports it. A transcription model
+ * billed by TOKENS is a charge this unit does not express: the data plane
+ * declares only duration-billed transcription models and ends a session whose
+ * provider reports tokens for one, rather than approximate the charge.
+ *
+ * No refinement in this package can enforce it, and saying so is part of the
+ * rule: a nested report and a disjoint one are the same four non-negative
+ * integers, so no predicate over a single report can tell them apart. The two
+ * structural guards that DO exist — refining `cached <= input` and
+ * `reasoning <= output`, or deriving the parents instead of reporting them —
+ * both encode the nested reading, which is the one this rule rejects. What IS
+ * enforceable is the arithmetic that depends on the rule, and that is where the
+ * enforcement lives — `inferenceLedger.service.test.ts` prices a report in
+ * which cached and reasoning tokens are both non-zero and asserts the exact
+ * total, which the nested reading cannot produce.
+ *
+ * Where the public surface has to speak a nested dialect, the sum is put back
+ * at the boundary rather than the internal reading being bent to it
+ * (`routes/inferenceEdge.ts` renders `prompt_tokens` as
+ * `input_tokens + cached_input_tokens`).
+ *
+ * Time is carried in integer MILLISECONDS rather than seconds so that no unit
+ * quantity is ever fractional: a 12.5-second transcription is `12500`, exactly,
+ * and the "units are integers" rule holds for every modality instead of holding
+ * for tokens and being quietly broken by audio.
+ */
+export declare const USAGE_UNITS: readonly ["input_tokens", "cached_input_tokens", "output_tokens", "reasoning_tokens", "requests", "images", "audio_input_milliseconds", "audio_output_milliseconds", "video_milliseconds", "characters", "embeddings", "audio_input_tokens", "cached_audio_input_tokens", "audio_output_tokens", "session_milliseconds", "input_transcription_milliseconds"];
+export declare const usageUnitSchema: z.ZodEnum<{
+    input_tokens: "input_tokens";
+    cached_input_tokens: "cached_input_tokens";
+    output_tokens: "output_tokens";
+    reasoning_tokens: "reasoning_tokens";
+    requests: "requests";
+    images: "images";
+    audio_input_milliseconds: "audio_input_milliseconds";
+    audio_output_milliseconds: "audio_output_milliseconds";
+    video_milliseconds: "video_milliseconds";
+    characters: "characters";
+    embeddings: "embeddings";
+    audio_input_tokens: "audio_input_tokens";
+    cached_audio_input_tokens: "cached_audio_input_tokens";
+    audio_output_tokens: "audio_output_tokens";
+    session_milliseconds: "session_milliseconds";
+    input_transcription_milliseconds: "input_transcription_milliseconds";
+}>;
+/**
+ * A metered quantity of ONE unit. Never money — a quantity carries no price and
+ * no currency, so a consumer cannot mistake a token count for an amount owed.
+ */
+export declare const usageQuantitySchema: z.ZodObject<{
+    unit: z.ZodEnum<{
+        input_tokens: "input_tokens";
+        cached_input_tokens: "cached_input_tokens";
+        output_tokens: "output_tokens";
+        reasoning_tokens: "reasoning_tokens";
+        requests: "requests";
+        images: "images";
+        audio_input_milliseconds: "audio_input_milliseconds";
+        audio_output_milliseconds: "audio_output_milliseconds";
+        video_milliseconds: "video_milliseconds";
+        characters: "characters";
+        embeddings: "embeddings";
+        audio_input_tokens: "audio_input_tokens";
+        cached_audio_input_tokens: "cached_audio_input_tokens";
+        audio_output_tokens: "audio_output_tokens";
+        session_milliseconds: "session_milliseconds";
+        input_transcription_milliseconds: "input_transcription_milliseconds";
+    }>;
+    quantity: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * Where a metered quantity came from.
+ *
+ * Kept explicit because the three are not interchangeable when a charge is
+ * disputed: `provider_reported` is the upstream's own count, `oxy_measured` is
+ * counted by the platform (streamed bytes, wall-clock milliseconds), and
+ * `estimated` is a reconstruction used when a provider returned no usage at
+ * all. An estimate that is indistinguishable from a reported number is an
+ * estimate nobody can later reconcile or refund against.
+ */
+export declare const USAGE_SOURCES: readonly ["provider_reported", "oxy_measured", "estimated"];
+export declare const usageSourceSchema: z.ZodEnum<{
+    provider_reported: "provider_reported";
+    oxy_measured: "oxy_measured";
+    estimated: "estimated";
+}>;
+/**
+ * A price for one unit, as `amount` per `per` units — `per` because a price
+ * quoted per single token would need more fractional digits than it is worth
+ * ("$3.00 per 1000000 input_tokens" is how every provider quotes it, and how
+ * every customer reads it).
+ */
+export declare const unitPriceSchema: z.ZodObject<{
+    unit: z.ZodEnum<{
+        input_tokens: "input_tokens";
+        cached_input_tokens: "cached_input_tokens";
+        output_tokens: "output_tokens";
+        reasoning_tokens: "reasoning_tokens";
+        requests: "requests";
+        images: "images";
+        audio_input_milliseconds: "audio_input_milliseconds";
+        audio_output_milliseconds: "audio_output_milliseconds";
+        video_milliseconds: "video_milliseconds";
+        characters: "characters";
+        embeddings: "embeddings";
+        audio_input_tokens: "audio_input_tokens";
+        cached_audio_input_tokens: "cached_audio_input_tokens";
+        audio_output_tokens: "audio_output_tokens";
+        session_milliseconds: "session_milliseconds";
+        input_transcription_milliseconds: "input_transcription_milliseconds";
+    }>;
+    amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+    per: z.ZodNumber;
+    currency: z.ZodString;
+}, z.core.$strict>;
+/**
+ * The price snapshot a settled receipt keeps.
+ *
+ * The unit prices are COPIED onto the receipt, not just referenced, so a receipt
+ * remains readable even if the price version record is later archived, and so
+ * that a mistake in the copy is visible as a disagreement with the version it
+ * names rather than silently invisible.
+ */
+export declare const priceSnapshotSchema: z.ZodObject<{
+    priceVersionId: z.ZodString;
+    currency: z.ZodString;
+    unitPrices: z.ZodArray<z.ZodObject<{
+        unit: z.ZodEnum<{
+            input_tokens: "input_tokens";
+            cached_input_tokens: "cached_input_tokens";
+            output_tokens: "output_tokens";
+            reasoning_tokens: "reasoning_tokens";
+            requests: "requests";
+            images: "images";
+            audio_input_milliseconds: "audio_input_milliseconds";
+            audio_output_milliseconds: "audio_output_milliseconds";
+            video_milliseconds: "video_milliseconds";
+            characters: "characters";
+            embeddings: "embeddings";
+            audio_input_tokens: "audio_input_tokens";
+            cached_audio_input_tokens: "cached_audio_input_tokens";
+            audio_output_tokens: "audio_output_tokens";
+            session_milliseconds: "session_milliseconds";
+            input_transcription_milliseconds: "input_transcription_milliseconds";
+        }>;
+        amount: z.core.$ZodBranded<z.ZodString, "ExactDecimal", "out">;
+        per: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/**
+ * What a request consumed, as a public response reports it: one quantity per
+ * unit, each unit at most once, the units partitioning the request (see
+ * {@link USAGE_UNITS}). New in contract set 4.0.0.
+ */
+export declare const usageSchema: z.ZodArray<z.ZodObject<{
+    unit: z.ZodEnum<{
+        input_tokens: "input_tokens";
+        cached_input_tokens: "cached_input_tokens";
+        output_tokens: "output_tokens";
+        reasoning_tokens: "reasoning_tokens";
+        requests: "requests";
+        images: "images";
+        audio_input_milliseconds: "audio_input_milliseconds";
+        audio_output_milliseconds: "audio_output_milliseconds";
+        video_milliseconds: "video_milliseconds";
+        characters: "characters";
+        embeddings: "embeddings";
+        audio_input_tokens: "audio_input_tokens";
+        cached_audio_input_tokens: "cached_audio_input_tokens";
+        audio_output_tokens: "audio_output_tokens";
+        session_milliseconds: "session_milliseconds";
+        input_transcription_milliseconds: "input_transcription_milliseconds";
+    }>;
+    quantity: z.ZodNumber;
+}, z.core.$strict>>;
+export type CurrencyCode = z.infer<typeof currencyCodeSchema>;
+export type ExactDecimal = z.infer<typeof exactDecimalSchema>;
+export type Money = z.infer<typeof moneySchema>;
+export type UsageUnit = z.infer<typeof usageUnitSchema>;
+export type UsageSource = z.infer<typeof usageSourceSchema>;
+export type UsageQuantity = z.infer<typeof usageQuantitySchema>;
+export type UnitPrice = z.infer<typeof unitPriceSchema>;
+export type PriceSnapshot = z.infer<typeof priceSnapshotSchema>;
+export type Usage = z.infer<typeof usageSchema>;