@kaana.ai/contracts 4.4.0 → 5.0.0

package/dist/public/audioFormats.d.ts

@@ -50,6 +50,25 @@ export declare const realtimeAudioFormatSchema: z.ZodEnum<{
     g711_ulaw: "g711_ulaw";
     g711_alaw: "g711_alaw";
 }>;
+/**
+ * What a session's responses produce. Declared here, beside the encodings and
+ * for the same reason, since contract set 5.0.0: the catalogue publishes which
+ * sets of them a model serves (`capabilities.realtime.parameters`).
+ */
+export declare const realtimeOutputModalitySchema: z.ZodEnum<{
+    text: "text";
+    audio: "audio";
+}>;
+/**
+ * How the end of a caller's turn is detected: the discriminant of
+ * `realtimeTurnDetectionSchema`, published per model by the catalogue
+ * (contract set 5.0.0).
+ */
+export declare const realtimeTurnDetectionTypeSchema: z.ZodEnum<{
+    none: "none";
+    server_vad: "server_vad";
+    semantic_vad: "semantic_vad";
+}>;
 /**
  * The media type a speech request's `response_format` produces. A client
  * knows it before the first byte, which is why the speech stream events do

package/dist/public/audioFormats.js

@@ -42,6 +42,18 @@ export const audioInputMediaTypeSchema = z.enum([
  * catalogue cannot import the realtime module that imports it.
  */
 export const realtimeAudioFormatSchema = z.enum(['pcm16_24khz', 'g711_ulaw', 'g711_alaw']);
+/**
+ * What a session's responses produce. Declared here, beside the encodings and
+ * for the same reason, since contract set 5.0.0: the catalogue publishes which
+ * sets of them a model serves (`capabilities.realtime.parameters`).
+ */
+export const realtimeOutputModalitySchema = z.enum(['text', 'audio']);
+/**
+ * How the end of a caller's turn is detected: the discriminant of
+ * `realtimeTurnDetectionSchema`, published per model by the catalogue
+ * (contract set 5.0.0).
+ */
+export const realtimeTurnDetectionTypeSchema = z.enum(['none', 'server_vad', 'semantic_vad']);
 const SPEECH_MEDIA_TYPES = {
     mp3: 'audio/mpeg',
     opus: 'audio/ogg',

package/dist/public/catalogue.d.ts

@@ -116,6 +116,120 @@ export declare const realtimeSessionKindSchema: z.ZodEnum<{
 export declare const realtimeSessionTransportSchema: z.ZodEnum<{
     websocket: "websocket";
 }>;
+/** A closed interval. */
+export declare const numberRangeSchema: z.ZodObject<{
+    min: z.ZodNumber;
+    max: z.ZodNumber;
+}, z.core.$strict>;
+/** One kind of tool choice: the modes, and `function` for one that names a tool. */
+export declare const realtimeToolChoiceKindSchema: z.ZodEnum<{
+    function: "function";
+    none: "none";
+    auto: "auto";
+    required: "required";
+}>;
+/**
+ * One turn detection a realtime model serves (contract set 5.0.0).
+ *
+ * - `fixedResponses` — the detection always answers the turn it detected and
+ *   lets the caller's speech interrupt the answer: it has neither switch, so a
+ *   session must state `createResponse: true` and `interruptResponse: true`.
+ * - `threshold` — server_vad's `threshold` range; absent, the contract's 0–1.
+ * - `meteredUnits` — the units a session under this detection is billed in:
+ *   what a caller multiplies the model's prices by to estimate a call. A
+ *   provider that bills by the clock under one detection and by the audio
+ *   under another states each.
+ */
+export declare const realtimeTurnDetectionParametersSchema: z.ZodObject<{
+    type: z.ZodEnum<{
+        none: "none";
+        server_vad: "server_vad";
+        semantic_vad: "semantic_vad";
+    }>;
+    fixedResponses: z.ZodBoolean;
+    threshold: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strict>>;
+    meteredUnits: z.ZodArray<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";
+    }>>;
+}, z.core.$strict>;
+/**
+ * What a realtime model's session configuration may set, and within which
+ * bounds (contract set 5.0.0): the provider's reviewed statement, which Kaana's
+ * adapter enforces and the catalogue publishes, so a session built from it is
+ * one the model serves. `checkRealtimeSessionOpen` applies it.
+ *
+ * - `turnDetection` — every detection served.
+ * - `outputModalities` — every set of modalities one response may produce
+ *   (each sorted): a model that answers aloud whatever it is asked does not
+ *   serve `["text"]`.
+ * - `toolChoice` — every kind of tool choice served; always holds `auto`.
+ * - `maxOutputTokens` — the largest per-response cap; absent, the model has
+ *   none and `maxOutputTokens` is refused.
+ * - `inputTranscriptionPrompt` — `config.inputAudioTranscription.prompt` is
+ *   taken.
+ */
+export declare const realtimeParametersSchema: z.ZodObject<{
+    turnDetection: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            none: "none";
+            server_vad: "server_vad";
+            semantic_vad: "semantic_vad";
+        }>;
+        fixedResponses: z.ZodBoolean;
+        threshold: z.ZodOptional<z.ZodObject<{
+            min: z.ZodNumber;
+            max: z.ZodNumber;
+        }, z.core.$strict>>;
+        meteredUnits: z.ZodArray<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";
+        }>>;
+    }, z.core.$strict>>;
+    outputModalities: z.ZodArray<z.ZodArray<z.ZodEnum<{
+        text: "text";
+        audio: "audio";
+    }>>>;
+    toolChoice: z.ZodArray<z.ZodEnum<{
+        function: "function";
+        none: "none";
+        auto: "auto";
+        required: "required";
+    }>>;
+    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+    inputTranscriptionPrompt: z.ZodBoolean;
+}, z.core.$strict>;
 /**
  * What a deployment can execute as a realtime session. Present only on a model
  * that holds sessions; absent means it holds none, which is the state of every
@@ -133,6 +247,8 @@ export declare const realtimeSessionTransportSchema: z.ZodEnum<{
  * - `audioFormats` — the realtime encodings a session may name as
  *   `config.inputAudioFormat` and `config.outputAudioFormat`. These are not the
  *   media types of `audio.audioFormats`, which describe files.
+ * - `parameters` (contract set 5.0.0) — what a session configuration may set
+ *   ({@link realtimeParametersSchema}). Absent: undeclared, not checked.
  */
 export declare const modelRealtimeCapabilitiesSchema: z.ZodObject<{
     transports: z.ZodArray<z.ZodEnum<{
@@ -156,6 +272,50 @@ export declare const modelRealtimeCapabilitiesSchema: z.ZodObject<{
             g711_alaw: "g711_alaw";
         }>>;
     }, z.core.$strict>>;
+    parameters: z.ZodOptional<z.ZodObject<{
+        turnDetection: z.ZodArray<z.ZodObject<{
+            type: z.ZodEnum<{
+                none: "none";
+                server_vad: "server_vad";
+                semantic_vad: "semantic_vad";
+            }>;
+            fixedResponses: z.ZodBoolean;
+            threshold: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            meteredUnits: z.ZodArray<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";
+            }>>;
+        }, z.core.$strict>>;
+        outputModalities: z.ZodArray<z.ZodArray<z.ZodEnum<{
+            text: "text";
+            audio: "audio";
+        }>>>;
+        toolChoice: z.ZodArray<z.ZodEnum<{
+            function: "function";
+            none: "none";
+            auto: "auto";
+            required: "required";
+        }>>;
+        maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+        inputTranscriptionPrompt: z.ZodBoolean;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 /**
  * What a model can do, in the terms a caller has to decide against before
@@ -225,6 +385,50 @@ export declare const modelCapabilitiesSchema: z.ZodObject<{
                 g711_alaw: "g711_alaw";
             }>>;
         }, z.core.$strict>>;
+        parameters: z.ZodOptional<z.ZodObject<{
+            turnDetection: z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    none: "none";
+                    server_vad: "server_vad";
+                    semantic_vad: "semantic_vad";
+                }>;
+                fixedResponses: z.ZodBoolean;
+                threshold: z.ZodOptional<z.ZodObject<{
+                    min: z.ZodNumber;
+                    max: z.ZodNumber;
+                }, z.core.$strict>>;
+                meteredUnits: z.ZodArray<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";
+                }>>;
+            }, z.core.$strict>>;
+            outputModalities: z.ZodArray<z.ZodArray<z.ZodEnum<{
+                text: "text";
+                audio: "audio";
+            }>>>;
+            toolChoice: z.ZodArray<z.ZodEnum<{
+                function: "function";
+                none: "none";
+                auto: "auto";
+                required: "required";
+            }>>;
+            maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+            inputTranscriptionPrompt: z.ZodBoolean;
+        }, z.core.$strict>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 /**
@@ -352,6 +556,16 @@ export declare const voiceSchema: z.ZodObject<{
  * none; a caller that needs a language then cannot choose the model.
  * `gender` is published only where it has been reviewed against the
  * provider's own catalogue; absent is unknown.
+ *
+ * Contract set 5.0.0:
+ *
+ * - `detectsLanguage` — naming no language lets the model detect it. A caller
+ *   whose language is not in `languages` omits it rather than losing the
+ *   model; absent is undeclared.
+ * - `transcriptionPrompt` — a transcription request may carry a `prompt`.
+ *   Absent or `false`: one that does is refused before anything is held.
+ * - A TRANSCRIPTION model's `languages` are exactly what a request may name in
+ *   `language`, and its `audioFormats.input` exactly what it uploads.
  */
 export declare const modelAudioCapabilitiesSchema: z.ZodObject<{
     voices: z.ZodArray<z.ZodObject<{
@@ -365,6 +579,8 @@ export declare const modelAudioCapabilitiesSchema: z.ZodObject<{
         }>>;
     }, z.core.$strict>>;
     languages: z.ZodArray<z.ZodString>;
+    detectsLanguage: z.ZodOptional<z.ZodBoolean>;
+    transcriptionPrompt: z.ZodOptional<z.ZodBoolean>;
     audioFormats: z.ZodObject<{
         input: z.ZodArray<z.ZodEnum<{
             "audio/mpeg": "audio/mpeg";
@@ -476,6 +692,50 @@ export declare const modelSchema: z.ZodObject<{
                     g711_alaw: "g711_alaw";
                 }>>;
             }, z.core.$strict>>;
+            parameters: z.ZodOptional<z.ZodObject<{
+                turnDetection: z.ZodArray<z.ZodObject<{
+                    type: z.ZodEnum<{
+                        none: "none";
+                        server_vad: "server_vad";
+                        semantic_vad: "semantic_vad";
+                    }>;
+                    fixedResponses: z.ZodBoolean;
+                    threshold: z.ZodOptional<z.ZodObject<{
+                        min: z.ZodNumber;
+                        max: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    meteredUnits: z.ZodArray<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";
+                    }>>;
+                }, z.core.$strict>>;
+                outputModalities: z.ZodArray<z.ZodArray<z.ZodEnum<{
+                    text: "text";
+                    audio: "audio";
+                }>>>;
+                toolChoice: z.ZodArray<z.ZodEnum<{
+                    function: "function";
+                    none: "none";
+                    auto: "auto";
+                    required: "required";
+                }>>;
+                maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+                inputTranscriptionPrompt: z.ZodBoolean;
+            }, z.core.$strict>>;
         }, z.core.$strict>>;
     }, z.core.$strict>;
     audio: z.ZodOptional<z.ZodObject<{
@@ -490,6 +750,8 @@ export declare const modelSchema: z.ZodObject<{
             }>>;
         }, z.core.$strict>>;
         languages: z.ZodArray<z.ZodString>;
+        detectsLanguage: z.ZodOptional<z.ZodBoolean>;
+        transcriptionPrompt: z.ZodOptional<z.ZodBoolean>;
         audioFormats: z.ZodObject<{
             input: z.ZodArray<z.ZodEnum<{
                 "audio/mpeg": "audio/mpeg";
@@ -691,6 +953,50 @@ export declare const modelListSchema: z.ZodObject<{
                         g711_alaw: "g711_alaw";
                     }>>;
                 }, z.core.$strict>>;
+                parameters: z.ZodOptional<z.ZodObject<{
+                    turnDetection: z.ZodArray<z.ZodObject<{
+                        type: z.ZodEnum<{
+                            none: "none";
+                            server_vad: "server_vad";
+                            semantic_vad: "semantic_vad";
+                        }>;
+                        fixedResponses: z.ZodBoolean;
+                        threshold: z.ZodOptional<z.ZodObject<{
+                            min: z.ZodNumber;
+                            max: z.ZodNumber;
+                        }, z.core.$strict>>;
+                        meteredUnits: z.ZodArray<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";
+                        }>>;
+                    }, z.core.$strict>>;
+                    outputModalities: z.ZodArray<z.ZodArray<z.ZodEnum<{
+                        text: "text";
+                        audio: "audio";
+                    }>>>;
+                    toolChoice: z.ZodArray<z.ZodEnum<{
+                        function: "function";
+                        none: "none";
+                        auto: "auto";
+                        required: "required";
+                    }>>;
+                    maxOutputTokens: z.ZodOptional<z.ZodNumber>;
+                    inputTranscriptionPrompt: z.ZodBoolean;
+                }, z.core.$strict>>;
             }, z.core.$strict>>;
         }, z.core.$strict>;
         audio: z.ZodOptional<z.ZodObject<{
@@ -705,6 +1011,8 @@ export declare const modelListSchema: z.ZodObject<{
                 }>>;
             }, z.core.$strict>>;
             languages: z.ZodArray<z.ZodString>;
+            detectsLanguage: z.ZodOptional<z.ZodBoolean>;
+            transcriptionPrompt: z.ZodOptional<z.ZodBoolean>;
             audioFormats: z.ZodObject<{
                 input: z.ZodArray<z.ZodEnum<{
                     "audio/mpeg": "audio/mpeg";
@@ -898,6 +1206,9 @@ export type InferenceApiFormat = z.infer<typeof inferenceApiFormatSchema>;
 export type RealtimeSessionKind = z.infer<typeof realtimeSessionKindSchema>;
 export type RealtimeSessionTransport = z.infer<typeof realtimeSessionTransportSchema>;
 export type ModelRealtimeCapabilities = z.infer<typeof modelRealtimeCapabilitiesSchema>;
+export type RealtimeParameters = z.infer<typeof realtimeParametersSchema>;
+export type RealtimeTurnDetectionParameters = z.infer<typeof realtimeTurnDetectionParametersSchema>;
+export type RealtimeToolChoiceKind = z.infer<typeof realtimeToolChoiceKindSchema>;
 export type ModelCapabilities = z.infer<typeof modelCapabilitiesSchema>;
 export type ModelLicense = z.infer<typeof modelLicenseSchema>;
 export type ModelProvenance = z.infer<typeof modelProvenanceSchema>;

package/dist/public/catalogue.js

@@ -5,8 +5,8 @@
  */
 import { z } from 'zod';
 import { inferenceDateSchema, inferenceHttpsUrlSchema, inferenceRegionSchema, inferenceTimestampSchema, modelIdSchema, modelReferenceSchema, modelRevisionLabelSchema, publisherSlugSchema, } from './identifiers.js';
-import { audioInputMediaTypeSchema, languageTagSchema, realtimeAudioFormatSchema, } from './audioFormats.js';
-import { priceSnapshotSchema } from './money.js';
+import { audioInputMediaTypeSchema, languageTagSchema, realtimeAudioFormatSchema, realtimeOutputModalitySchema, realtimeTurnDetectionTypeSchema, } from './audioFormats.js';
+import { priceSnapshotSchema, usageUnitSchema } from './money.js';
 import { inferenceAudioMediaTypeSchema } from './streamEvents.js';
 /** Input/request modalities; structured decisions are an output, never an input. */
 export const inferenceModalitySchema = z.enum(['text', 'image', 'audio', 'video', 'embedding']);
@@ -94,6 +94,68 @@ export const realtimeSessionKindSchema = z.enum(['conversation', 'transcription'
  * deployment can actually execute them.
  */
 export const realtimeSessionTransportSchema = z.enum(['websocket']);
+/** A closed interval. */
+export const numberRangeSchema = z.object({ min: z.number(), max: z.number() }).strict();
+/** One kind of tool choice: the modes, and `function` for one that names a tool. */
+export const realtimeToolChoiceKindSchema = z.enum(['auto', 'none', 'required', 'function']);
+/**
+ * One turn detection a realtime model serves (contract set 5.0.0).
+ *
+ * - `fixedResponses` — the detection always answers the turn it detected and
+ *   lets the caller's speech interrupt the answer: it has neither switch, so a
+ *   session must state `createResponse: true` and `interruptResponse: true`.
+ * - `threshold` — server_vad's `threshold` range; absent, the contract's 0–1.
+ * - `meteredUnits` — the units a session under this detection is billed in:
+ *   what a caller multiplies the model's prices by to estimate a call. A
+ *   provider that bills by the clock under one detection and by the audio
+ *   under another states each.
+ */
+export const realtimeTurnDetectionParametersSchema = z
+    .object({
+    type: realtimeTurnDetectionTypeSchema,
+    fixedResponses: z.boolean(),
+    threshold: numberRangeSchema.optional(),
+    meteredUnits: z.array(usageUnitSchema).min(1),
+})
+    .strict();
+/**
+ * What a realtime model's session configuration may set, and within which
+ * bounds (contract set 5.0.0): the provider's reviewed statement, which Kaana's
+ * adapter enforces and the catalogue publishes, so a session built from it is
+ * one the model serves. `checkRealtimeSessionOpen` applies it.
+ *
+ * - `turnDetection` — every detection served.
+ * - `outputModalities` — every set of modalities one response may produce
+ *   (each sorted): a model that answers aloud whatever it is asked does not
+ *   serve `["text"]`.
+ * - `toolChoice` — every kind of tool choice served; always holds `auto`.
+ * - `maxOutputTokens` — the largest per-response cap; absent, the model has
+ *   none and `maxOutputTokens` is refused.
+ * - `inputTranscriptionPrompt` — `config.inputAudioTranscription.prompt` is
+ *   taken.
+ */
+export const realtimeParametersSchema = z
+    .object({
+    turnDetection: z.array(realtimeTurnDetectionParametersSchema).min(1),
+    outputModalities: z.array(z.array(realtimeOutputModalitySchema).min(1).max(2)).min(1),
+    toolChoice: z.array(realtimeToolChoiceKindSchema).min(1),
+    maxOutputTokens: z.number().int().positive().safe().optional(),
+    inputTranscriptionPrompt: z.boolean(),
+})
+    .strict()
+    .superRefine((parameters, ctx) => {
+    if (!parameters.toolChoice.includes('auto')) {
+        ctx.addIssue({ code: 'custom', path: ['toolChoice'], message: 'auto is always served' });
+    }
+    const kinds = parameters.turnDetection.map((detection) => detection.type);
+    if (new Set(kinds).size !== kinds.length) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['turnDetection'],
+            message: 'each detection is declared once',
+        });
+    }
+});
 /**
  * What a deployment can execute as a realtime session. Present only on a model
  * that holds sessions; absent means it holds none, which is the state of every
@@ -111,6 +173,8 @@ export const realtimeSessionTransportSchema = z.enum(['websocket']);
  * - `audioFormats` — the realtime encodings a session may name as
  *   `config.inputAudioFormat` and `config.outputAudioFormat`. These are not the
  *   media types of `audio.audioFormats`, which describe files.
+ * - `parameters` (contract set 5.0.0) — what a session configuration may set
+ *   ({@link realtimeParametersSchema}). Absent: undeclared, not checked.
  */
 export const modelRealtimeCapabilitiesSchema = z
     .object({
@@ -124,6 +188,7 @@ export const modelRealtimeCapabilitiesSchema = z
     })
         .strict()
         .optional(),
+    parameters: realtimeParametersSchema.optional(),
 })
     .strict();
 /**
@@ -378,11 +443,23 @@ export const voiceSchema = z
  * none; a caller that needs a language then cannot choose the model.
  * `gender` is published only where it has been reviewed against the
  * provider's own catalogue; absent is unknown.
+ *
+ * Contract set 5.0.0:
+ *
+ * - `detectsLanguage` — naming no language lets the model detect it. A caller
+ *   whose language is not in `languages` omits it rather than losing the
+ *   model; absent is undeclared.
+ * - `transcriptionPrompt` — a transcription request may carry a `prompt`.
+ *   Absent or `false`: one that does is refused before anything is held.
+ * - A TRANSCRIPTION model's `languages` are exactly what a request may name in
+ *   `language`, and its `audioFormats.input` exactly what it uploads.
  */
 export const modelAudioCapabilitiesSchema = z
     .object({
     voices: z.array(voiceSchema),
     languages: z.array(languageTagSchema),
+    detectsLanguage: z.boolean().optional(),
+    transcriptionPrompt: z.boolean().optional(),
     audioFormats: z
         .object({
         input: z.array(audioInputMediaTypeSchema),

package/dist/public/chatCompletions.d.ts

@@ -172,8 +172,8 @@ export declare const chatCompletionsRequestSchema: z.ZodObject<{
         }, z.core.$strict>;
     }, z.core.$strict>>>;
     tool_choice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        auto: "auto";
         none: "none";
+        auto: "auto";
         required: "required";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"function">;

package/dist/public/messages.d.ts

@@ -205,8 +205,8 @@ export declare const toolDefinitionSchema: z.ZodObject<{
 }, z.core.$strict>;
 /** Whether, and which, tool the model must call. */
 export declare const toolChoiceSchema: z.ZodUnion<readonly [z.ZodEnum<{
-    auto: "auto";
     none: "none";
+    auto: "auto";
     required: "required";
 }>, z.ZodObject<{
     type: z.ZodLiteral<"function">;
@@ -250,6 +250,17 @@ export declare const inferenceSpeechParametersSchema: z.ZodObject<{
     }>;
     speed: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>;
+/**
+ * Parameters for a file transcription, preserved in the signed request
+ * (contract set 4.5.0). `language` is the caller's statement of what is spoken,
+ * in the tag the model's catalogue `audio.languages` declares; absent lets the
+ * model detect it. An adapter whose provider takes no language refuses one
+ * rather than dropping it.
+ */
+export declare const inferenceTranscriptionParametersSchema: z.ZodObject<{
+    language: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, 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
@@ -283,6 +294,7 @@ export declare const inferenceAudioOutputParametersSchema: z.ZodObject<{
  */
 export declare const requestLabelsSchema: z.ZodRecord<z.ZodString, z.ZodString>;
 export type InferenceSpeechParameters = z.infer<typeof inferenceSpeechParametersSchema>;
+export type InferenceTranscriptionParameters = z.infer<typeof inferenceTranscriptionParametersSchema>;
 export type InferenceAudioOutputParameters = z.infer<typeof inferenceAudioOutputParametersSchema>;
 export type InferenceContentSource = z.infer<typeof inferenceContentSourceSchema>;
 export type InferenceContentPart = z.infer<typeof inferenceContentPartSchema>;

package/dist/public/messages.js

@@ -5,6 +5,7 @@
  * Moved from `@oxy.so/contracts` 4.12.0 (`src/inference/request.ts`) by Kaana ADR 0002.
  */
 import { z } from 'zod';
+import { languageTagSchema } from './audioFormats.js';
 import { reasoningEffortSchema } from './catalogue.js';
 /**
  * Where binary or remote content comes from.
@@ -219,6 +220,20 @@ export const inferenceSpeechParametersSchema = z
     speed: z.number().min(0.25).max(4).optional(),
 })
     .strict();
+/**
+ * Parameters for a file transcription, preserved in the signed request
+ * (contract set 4.5.0). `language` is the caller's statement of what is spoken,
+ * in the tag the model's catalogue `audio.languages` declares; absent lets the
+ * model detect it. An adapter whose provider takes no language refuses one
+ * rather than dropping it.
+ */
+export const inferenceTranscriptionParametersSchema = z
+    .object({
+    language: languageTagSchema.optional(),
+    /** Vocabulary or context, never an instruction (contract set 5.0.0). */
+    prompt: z.string().max(4096).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