@kaana.ai/contracts 0.0.0-stage → 4.4.0

package/dist/public/identifiers.js

@@ -0,0 +1,160 @@
+/**
+ * Identifiers and wire primitives of the public API (`https://kaana.ai/v1`).
+ *
+ * Every regex is plain ASCII: the package runs on Hermes (React Native), which
+ * rejects Unicode property escapes at runtime.
+ *
+ * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/identifiers.ts`) by Kaana ADR 0002.
+ */
+import { z } from 'zod';
+/**
+ * A delegated end-user identity (Alia's `X-Oxy-User-Id`), branded with a
+ * DIFFERENT brand from {@link oxyAccountIdSchema} so the two cannot be
+ * substituted for one another in either direction, in any consumer, without a
+ * cast that review would catch.
+ *
+ * It exists for attribution and product-side personalisation only. It is never
+ * a billing principal, never an access-control principal, and its presence
+ * never changes which account is charged.
+ */
+export const delegatedUserIdSchema = z.string().min(1).max(64).brand();
+/**
+ * An Oxy `Application._id`. Not branded: no invariant in this contract turns on
+ * confusing it with another id, and brand inflation costs every producer a
+ * parse call for no safety. The two ids above are branded because ADR 0007's
+ * rule is exactly that they must not be interchangeable.
+ */
+export const oxyApplicationIdSchema = z.string().min(1).max(64);
+/** An Oxy `ApplicationCredential._id` — the credential used for this request. */
+export const oxyCredentialIdSchema = z.string().min(1).max(64);
+/**
+ * A request id allocated by the Oxy EDGE, at admission and BEFORE
+ * authentication, so that a request rejected for a bad credential is as
+ * traceable as one that was served (ADR 0007, and step 1 of ADR 0010's edge
+ * order). It is required on the inbound envelope, which is what makes the data
+ * plane a consumer of this id rather than its source: the data plane echoes it
+ * on every stream event, on the usage report, in its response header and on
+ * anything it can be asked about later. It never mints one for a request it
+ * received.
+ *
+ * The one case that is NOT an exception to that: an envelope the data plane
+ * cannot read or authenticate carries no id to echo, so its rejection is
+ * labelled with an id of the data plane's own — visibly local, and never
+ * correlated with an Oxy request, because there is no Oxy request it belongs to.
+ * Saying so is what stops "consumer, not source" from being read as forbidding
+ * the only id such a rejection could have.
+ *
+ * Correlates the Oxy edge, the data plane, the financial ledger and the
+ * customer-visible receipt, so it appears on every stream event and every
+ * ledger record.
+ */
+export const requestIdSchema = z.string().min(1).max(128);
+/**
+ * A generation id generated by the data plane, present when a request produced
+ * a generation that can be looked up later (`GET /v1/generations/:id`).
+ */
+export const generationIdSchema = z.string().min(1).max(128);
+/**
+ * A caller-supplied idempotency key. Every reserve/settle/refund call is keyed
+ * on one so a retry, a redelivered event or a duplicated webhook can never
+ * charge twice.
+ */
+export const idempotencyKeySchema = z.string().min(1).max(255);
+/** Credential environments. A credential is issued into exactly one of them. */
+export const inferenceEnvironmentSchema = z.enum(['development', 'staging', 'production']);
+/**
+ * An instant, as an ISO 8601 string in UTC (`2026-08-15T09:41:00.000Z`).
+ *
+ * Validated rather than left free-form — unlike the session contracts, which
+ * carry legacy expiry strings no consumer interprets, every instant here is
+ * read: a reservation expires, a price version starts applying, a receipt is
+ * settled. One canonical spelling (UTC, `Z`) so two records that describe the
+ * same moment compare and sort as equal, which a mix of offsets would not.
+ */
+export const inferenceTimestampSchema = z.string().datetime();
+/**
+ * A calendar DATE with no instant attached (`2026-05-01`) — a knowledge cutoff
+ * or a release date, which are published as days and become wrong when a
+ * timezone is invented for them.
+ */
+export const inferenceDateSchema = z
+    .string()
+    .regex(/^[0-9]{4}-[0-9]{2}-[0-9]{2}$/, 'must be an ISO 8601 calendar date (YYYY-MM-DD)');
+/** An absolute https URL, for model cards, licenses and provider documentation. */
+export const inferenceHttpsUrlSchema = z
+    .string()
+    .max(2048)
+    .regex(/^https:\/\/[^\s]+$/, 'must be an absolute https URL');
+/**
+ * A content digest, `sha256:<64 lowercase hex>`.
+ *
+ * ONE spelling, because a digest is compared for equality and nothing else: an
+ * uppercase or unprefixed variant of the same hash is a different string, so two
+ * records describing the same bytes would not match. Lowercase hex with the
+ * algorithm prefix is what the `inference_model_revisions` CHECK stores and what
+ * every artifact registry emits.
+ */
+export const sha256DigestSchema = z
+    .string()
+    .regex(/^sha256:[a-f0-9]{64}$/, 'digest must be sha256:<64 lowercase hex>');
+/** Standard base64 in whole, padded 4-character groups. */
+export const PADDED_BASE64_PATTERN = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+/** One path segment of a canonical model id: a lowercase, URL-safe slug. */
+const SLUG_PATTERN = '[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?';
+/** A revision label. Case-preserving, because upstream revisions often are. */
+const REVISION_PATTERN = '[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?';
+/** A publisher slug, e.g. `openai`, `anthropic`, `meta`, `alia`. */
+export const publisherSlugSchema = z
+    .string()
+    .max(64)
+    .regex(new RegExp(`^${SLUG_PATTERN}$`), 'publisher must be a lowercase URL-safe slug');
+/** A model slug within its publisher's namespace, e.g. `gpt-5`, `llama-3.1-70b`. */
+export const modelSlugSchema = z
+    .string()
+    .max(64)
+    .regex(new RegExp(`^${SLUG_PATTERN}$`), 'model must be a lowercase URL-safe slug');
+/**
+ * A canonical model id, `<publisher>/<model>`. This names a MODEL — a
+ * long-lived product identity whose behaviour changes as revisions ship. It
+ * does not name a revision, a deployment or a provider.
+ */
+export const modelIdSchema = z
+    .string()
+    .max(129)
+    .regex(new RegExp(`^${SLUG_PATTERN}/${SLUG_PATTERN}$`), 'model id must be <publisher>/<model>');
+/** An immutable revision label, unique within its model, e.g. `2026-05-01`. */
+export const modelRevisionLabelSchema = z
+    .string()
+    .max(64)
+    .regex(new RegExp(`^${REVISION_PATTERN}$`), 'revision must be a URL-safe label');
+/**
+ * A model reference as a customer writes it: `<publisher>/<model>` (the model's
+ * current revision, chosen by Oxy) or `<publisher>/<model>@<revision>` (an
+ * immutable revision the customer pinned).
+ *
+ * Both forms name a CONCRETE MODEL. Neither can name a routing profile — see
+ * {@link routingProfileSlugSchema} — which is what makes "a request for a
+ * concrete model is never silently replaced with a different model" a
+ * distinction the type system can carry rather than a convention.
+ */
+export const modelReferenceSchema = z
+    .string()
+    .max(194)
+    .regex(new RegExp(`^${SLUG_PATTERN}/${SLUG_PATTERN}(?:@${REVISION_PATTERN})?$`), 'model reference must be <publisher>/<model> or <publisher>/<model>@<revision>');
+/**
+ * A region identifier, e.g. `us-west-2`, `eu-central-1`. Free-form rather than
+ * a closed enum because the set is provider-defined and grows without any
+ * contract change; residency policies match on exact strings.
+ */
+export const inferenceRegionSchema = z
+    .string()
+    .max(64)
+    .regex(new RegExp(`^${SLUG_PATTERN}$`), 'region must be a lowercase URL-safe slug');
+/**
+ * The publisher namespace reserved for models Alia actually owns or derives.
+ *
+ * `alia/*` is never a re-badged third-party route and never a prompt preset —
+ * enforcing that is the job of `modelSchema`'s provenance refinement, which
+ * this constant exists to be checked against.
+ */
+export const RESERVED_ALIA_PUBLISHER = 'alia';

package/dist/public/images.d.ts

@@ -0,0 +1,36 @@
+/**
+ * `POST /v1/images/generations` — text to image, in OpenAI's shapes.
+ *
+ * Moved from the Oxy edge (`packages/api/src/schemas/inferenceEdge.schemas.ts`)
+ * by Kaana ADR 0002, unchanged. `size` and `quality` are forwarded and do not
+ * widen the hold: each size/quality class is its own model reference in the
+ * catalogue, because a price prices a unit, not a `(unit, size, quality)` tuple.
+ */
+import { z } from 'zod';
+export declare const imageGenerationsRequestSchema: z.ZodObject<{
+    model: z.ZodString;
+    prompt: z.ZodString;
+    n: z.ZodOptional<z.ZodNumber>;
+    size: z.ZodOptional<z.ZodString>;
+    quality: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodString>;
+    response_format: z.ZodOptional<z.ZodEnum<{
+        url: "url";
+        b64_json: "b64_json";
+    }>>;
+    user: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/**
+ * A union per element rather than two optional fields: the endpoint returns a
+ * URL or inline base64 and never both.
+ */
+export declare const imageGenerationsSchema: z.ZodObject<{
+    created: z.ZodNumber;
+    data: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        b64_json: z.ZodString;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+export type ImageGenerationsRequest = z.infer<typeof imageGenerationsRequestSchema>;
+export type ImageGenerations = z.infer<typeof imageGenerationsSchema>;

package/dist/public/images.js

@@ -0,0 +1,36 @@
+/**
+ * `POST /v1/images/generations` — text to image, in OpenAI's shapes.
+ *
+ * Moved from the Oxy edge (`packages/api/src/schemas/inferenceEdge.schemas.ts`)
+ * by Kaana ADR 0002, unchanged. `size` and `quality` are forwarded and do not
+ * widen the hold: each size/quality class is its own model reference in the
+ * catalogue, because a price prices a unit, not a `(unit, size, quality)` tuple.
+ */
+import { z } from 'zod';
+import { modelReferenceSchema } from './identifiers.js';
+export const imageGenerationsRequestSchema = z
+    .object({
+    model: modelReferenceSchema,
+    prompt: z.string().min(1).max(32_000),
+    /** OpenAI caps this at 10. Exact, declared, and the whole ceiling. */
+    n: z.number().int().min(1).max(10).optional(),
+    size: z.string().min(1).max(32).optional(),
+    quality: z.string().min(1).max(32).optional(),
+    style: z.string().min(1).max(32).optional(),
+    response_format: z.enum(['url', 'b64_json']).optional(),
+    user: z.string().min(1).max(64).optional(),
+})
+    .strict();
+/**
+ * A union per element rather than two optional fields: the endpoint returns a
+ * URL or inline base64 and never both.
+ */
+export const imageGenerationsSchema = z
+    .object({
+    created: z.number().int().nonnegative(),
+    data: z.array(z.union([
+        z.object({ url: z.string().min(1) }).strict(),
+        z.object({ b64_json: z.string().min(1) }).strict(),
+    ])),
+})
+    .strict();

package/dist/public/messages.d.ts

@@ -0,0 +1,297 @@
+/**
+ * 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';
+/**
+ * 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 declare const inferenceContentSourceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"url">;
+    url: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"inline">;
+    mediaType: z.ZodString;
+    data: z.ZodString;
+}, z.core.$strict>], "kind">;
+/**
+ * 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 declare const inferenceContentPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        mediaType: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    detail: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        high: "high";
+        auto: "auto";
+    }>>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"audio">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        mediaType: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strict>], "kind">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"file">;
+    source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"url">;
+        url: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"inline">;
+        mediaType: z.ZodString;
+        data: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    filename: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"refusal">;
+    text: z.ZodString;
+}, z.core.$strict>], "type">;
+/**
+ * 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 declare const inferenceToolCallSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    arguments: z.ZodString;
+}, z.core.$strict>;
+export declare const inferenceMessageRoleSchema: z.ZodEnum<{
+    user: "user";
+    system: "system";
+    developer: "developer";
+    assistant: "assistant";
+    tool: "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 declare const inferenceMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        user: "user";
+        system: "system";
+        developer: "developer";
+        assistant: "assistant";
+        tool: "tool";
+    }>;
+    content: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            mediaType: z.ZodString;
+            data: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        detail: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            high: "high";
+            auto: "auto";
+        }>>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"audio">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            mediaType: z.ZodString;
+            data: z.ZodString;
+        }, z.core.$strict>], "kind">;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"file">;
+        source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"url">;
+            url: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"inline">;
+            mediaType: z.ZodString;
+            data: z.ZodString;
+        }, z.core.$strict>], "kind">;
+        filename: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"refusal">;
+        text: z.ZodString;
+    }, z.core.$strict>], "type">>;
+    name: z.ZodOptional<z.ZodString>;
+    toolCallId: z.ZodOptional<z.ZodString>;
+    toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        arguments: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+/** Sampling parameters, all optional: absent means the route's own default. */
+export declare const samplingParametersSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    topP: z.ZodOptional<z.ZodNumber>;
+    topK: z.ZodOptional<z.ZodNumber>;
+    frequencyPenalty: z.ZodOptional<z.ZodNumber>;
+    presencePenalty: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    stopSequences: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$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 declare const toolDefinitionSchema: z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    strict: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+/** Whether, and which, tool the model must call. */
+export declare const toolChoiceSchema: z.ZodUnion<readonly [z.ZodEnum<{
+    auto: "auto";
+    none: "none";
+    required: "required";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    name: z.ZodString;
+}, z.core.$strict>]>;
+/** Structured-output request: free text, any JSON object, or a named schema. */
+export declare const responseFormatSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"json_object">;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"json_schema">;
+    name: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    strict: z.ZodBoolean;
+}, z.core.$strict>], "type">;
+/**
+ * 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 declare const inferenceReasoningSchema: z.ZodObject<{
+    effort: z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+    }>;
+}, z.core.$strict>;
+/** Parameters for text-to-speech, preserved in the signed request. */
+export declare const inferenceSpeechParametersSchema: z.ZodObject<{
+    voice: z.ZodString;
+    responseFormat: z.ZodEnum<{
+        mp3: "mp3";
+        opus: "opus";
+        aac: "aac";
+        flac: "flac";
+        wav: "wav";
+        pcm: "pcm";
+    }>;
+    speed: z.ZodOptional<z.ZodNumber>;
+}, z.core.$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 declare const inferenceAudioOutputParametersSchema: z.ZodObject<{
+    voice: z.ZodString;
+    format: z.ZodEnum<{
+        mp3: "mp3";
+        opus: "opus";
+        flac: "flac";
+        wav: "wav";
+        pcm: "pcm";
+    }>;
+}, z.core.$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 declare const requestLabelsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
+export type InferenceSpeechParameters = z.infer<typeof inferenceSpeechParametersSchema>;
+export type InferenceAudioOutputParameters = z.infer<typeof inferenceAudioOutputParametersSchema>;
+export type InferenceContentSource = z.infer<typeof inferenceContentSourceSchema>;
+export type InferenceContentPart = z.infer<typeof inferenceContentPartSchema>;
+export type InferenceToolCall = z.infer<typeof inferenceToolCallSchema>;
+export type InferenceMessageRole = z.infer<typeof inferenceMessageRoleSchema>;
+export type InferenceMessage = z.infer<typeof inferenceMessageSchema>;
+export type SamplingParameters = z.infer<typeof samplingParametersSchema>;
+export type InferenceReasoning = z.infer<typeof inferenceReasoningSchema>;
+export type ToolDefinition = z.infer<typeof toolDefinitionSchema>;
+export type ToolChoice = z.infer<typeof toolChoiceSchema>;
+export type ResponseFormat = z.infer<typeof responseFormatSchema>;
+export type RequestLabels = z.infer<typeof requestLabelsSchema>;