@kaana.ai/contracts 5.0.0 → 6.0.0

package/dist/public/realtime.d.ts

@@ -5,8 +5,7 @@
  */
 import { z } from 'zod';
 import { realtimeOutputModalitySchema } from './audioFormats.js';
-import { type ModelAudioCapabilities, type ModelCapabilities, type RealtimeParameters, realtimeSessionKindSchema } from './catalogue.js';
-import { toolChoiceSchema } from './messages.js';
+import { type ModelAudioCapabilities, type ModelCapabilities, realtimeSessionKindSchema } from './catalogue.js';
 /**
  * The most base64 characters one audio frame may carry: 49 152 bytes of audio,
  * about one second of 24 kHz mono PCM16. Bounded so no frame is large enough to
@@ -38,6 +37,10 @@ export declare const realtimeResponseIdSchema: z.ZodString;
  * them: whether the model answers on its own, and whether new speech cuts it
  * off, are the two behaviours a caller most needs to have chosen, and a default
  * would choose them silently — and differently per provider.
+ *
+ * A `server_vad` that names no `silenceDurationMs` waits Kaana's
+ * {@link REALTIME_DEFAULT_SILENCE_DURATION_MS}, on every provider (contract set
+ * 6.0.0), never the provider's own default.
  */
 export declare const realtimeTurnDetectionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"none">;
@@ -66,13 +69,12 @@ export declare const realtimeTurnDetectionSchema: z.ZodDiscriminatedUnion<[z.Zod
  *
  * In a `conversation` it is served only by a model whose catalogue entry says
  * so (`capabilities.realtime.inputAudioTranscription`, contract set 4.1.0),
- * and each transcribed turn arrives as `transcript.delta` / `transcript.done`
- * with `source: 'input_audio'`. What it costs is settled with the session:
- * where the provider bills the transcription apart from the session model, as
- * `input_transcription_milliseconds` (see `USAGE_UNITS`); where the session's
- * own price includes it, as nothing more.
- *
- * `language`, when given, is one of the model's published `audio.languages`.
+ * and each transcribed turn arrives as deltas that only append and EXACTLY
+ * ONE `transcript.done` with `source: 'input_audio'`, the final transcript of
+ * that item (contract set 6.0.0), whatever its provider sends. What it costs
+ * is settled with the session: where the provider bills the transcription
+ * apart from the session model, as `input_transcription_milliseconds` (see
+ * `USAGE_UNITS`); where the session's own price includes it, as nothing more.
  */
 export declare const realtimeInputTranscriptionSchema: z.ZodObject<{
     language: z.ZodOptional<z.ZodString>;
@@ -89,8 +91,8 @@ export declare const realtimeTranslationSchema: z.ZodObject<{
 export declare const realtimeToolDefinitionSchema: z.ZodObject<{
     type: z.ZodLiteral<"function">;
     name: z.ZodString;
-    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     description: z.ZodOptional<z.ZodString>;
+    parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>;
 /**
  * A session's full configuration, as signed at open and as echoed back by
@@ -148,12 +150,12 @@ export declare const realtimeSessionConfigSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodLiteral<"function">;
         name: z.ZodString;
-        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strict>>>;
     toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        none: "none";
         auto: "auto";
+        none: "none";
         required: "required";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"function">;
@@ -202,12 +204,12 @@ export declare const realtimeSessionConfigUpdateSchema: z.ZodObject<{
     tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
         type: z.ZodLiteral<"function">;
         name: z.ZodString;
-        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strict>>>;
     toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        none: "none";
         auto: "auto";
+        none: "none";
         required: "required";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"function">;
@@ -318,8 +320,8 @@ export declare const realtimeResponseParametersSchema: z.ZodObject<{
     }>>>;
     maxOutputTokens: z.ZodOptional<z.ZodNumber>;
     toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        none: "none";
         auto: "auto";
+        none: "none";
         required: "required";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"function">;
@@ -361,12 +363,12 @@ export declare const realtimeSessionUpdateCommandSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -479,8 +481,8 @@ export declare const realtimeResponseCreateCommandSchema: z.ZodObject<{
         }>>>;
         maxOutputTokens: z.ZodOptional<z.ZodNumber>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -551,12 +553,12 @@ export declare const realtimeClientCommandSchema: z.ZodDiscriminatedUnion<[z.Zod
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -657,8 +659,8 @@ export declare const realtimeClientCommandSchema: z.ZodDiscriminatedUnion<[z.Zod
         }>>>;
         maxOutputTokens: z.ZodOptional<z.ZodNumber>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -735,12 +737,12 @@ export declare const realtimeSessionUpdatedEventSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -1079,6 +1081,16 @@ export declare const realtimeOpenLimitsSchema: z.ZodObject<{
  * frame closes the connection before it is read.
  */
 export declare const MAX_REALTIME_OPEN_FRAME_BYTES: number;
+/**
+ * The silence, in milliseconds, after which `server_vad` ends a caller's turn
+ * when the session names none (contract set 6.0.0, Kaana ADR 0003). Kaana
+ * sends it to every provider, so a turn ends the same way whichever serves
+ * the session. Measured on x-ai/grok-voice-3.0 (2026-10-16): with xAI's own
+ * default a phrase with pauses of 0.56 s and 0.79 s was cut into three
+ * responses, two cancelled, the model speaking before the phrase ended; at
+ * 500 ms it was one response, answered 490–576 ms after the phrase.
+ */
+export declare const REALTIME_DEFAULT_SILENCE_DURATION_MS = 500;
 /**
  * The first frame a client sends on `GET /v1/realtime?model=…` to OPEN a
  * session (a reconnection instead sends `session.resume`). One grant covers the
@@ -1143,12 +1155,12 @@ export declare const realtimeSessionOpenSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -1192,28 +1204,6 @@ export declare function checkRealtimeSessionOpen(open: z.infer<typeof realtimeSe
     readonly capabilities: ModelCapabilities;
     readonly audio?: ModelAudioCapabilities;
 }): RealtimeOpenIssue[];
-/**
- * The part of a session configuration, of a `session.update` or of a
- * `response.create` that a model's {@link RealtimeParameters} govern.
- */
-export interface RealtimeGovernedFields {
-    readonly outputModalities?: readonly RealtimeOutputModality[];
-    readonly turnDetection?: RealtimeTurnDetection;
-    readonly inputAudioTranscription?: {
-        readonly prompt?: string;
-    };
-    readonly toolChoice?: z.infer<typeof toolChoiceSchema>;
-    readonly maxOutputTokens?: number;
-}
-/**
- * Every field that `parameters` do not serve, each with the `param` Kaana's
- * refusal names (`prefix` is `config` for an open or a `session.update`,
- * `response` for a `response.create`), in the order Kaana checks them. It is
- * exactly Kaana's own check (Go's `RealtimeParameters.Issues`, held to the
- * same vectors), so a client that builds its session from a model's
- * parameters, or filters models with this, is never refused for one.
- */
-export declare function realtimeParameterIssues(prefix: 'config' | 'response', fields: RealtimeGovernedFields, parameters: RealtimeParameters): RealtimeOpenIssue[];
 /**
  * The session opened: the revision-pinned model, fixed for the rest of the
  * session, and the effective configuration and limits. The signed lane's
@@ -1275,12 +1265,12 @@ export declare const realtimePublicSessionCreatedEventSchema: z.ZodObject<{
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -1512,12 +1502,12 @@ export declare const realtimePublicServerEventSchema: z.ZodDiscriminatedUnion<[z
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;
@@ -1588,12 +1578,12 @@ export declare const realtimePublicServerEventSchema: z.ZodDiscriminatedUnion<[z
         tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
             type: z.ZodLiteral<"function">;
             name: z.ZodString;
-            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         }, z.core.$strict>>>;
         toolChoice: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            none: "none";
             auto: "auto";
+            none: "none";
             required: "required";
         }>, z.ZodObject<{
             type: z.ZodLiteral<"function">;

package/dist/public/realtime.js

@@ -49,6 +49,10 @@ const milliseconds = z.number().int().nonnegative().safe();
  * them: whether the model answers on its own, and whether new speech cuts it
  * off, are the two behaviours a caller most needs to have chosen, and a default
  * would choose them silently — and differently per provider.
+ *
+ * A `server_vad` that names no `silenceDurationMs` waits Kaana's
+ * {@link REALTIME_DEFAULT_SILENCE_DURATION_MS}, on every provider (contract set
+ * 6.0.0), never the provider's own default.
  */
 export const realtimeTurnDetectionSchema = z.discriminatedUnion('type', [
     z.object({ type: z.literal('none') }).strict(),
@@ -78,18 +82,22 @@ export const realtimeTurnDetectionSchema = z.discriminatedUnion('type', [
  *
  * In a `conversation` it is served only by a model whose catalogue entry says
  * so (`capabilities.realtime.inputAudioTranscription`, contract set 4.1.0),
- * and each transcribed turn arrives as `transcript.delta` / `transcript.done`
- * with `source: 'input_audio'`. What it costs is settled with the session:
- * where the provider bills the transcription apart from the session model, as
- * `input_transcription_milliseconds` (see `USAGE_UNITS`); where the session's
- * own price includes it, as nothing more.
- *
- * `language`, when given, is one of the model's published `audio.languages`.
+ * and each transcribed turn arrives as deltas that only append and EXACTLY
+ * ONE `transcript.done` with `source: 'input_audio'`, the final transcript of
+ * that item (contract set 6.0.0), whatever its provider sends. What it costs
+ * is settled with the session: where the provider bills the transcription
+ * apart from the session model, as `input_transcription_milliseconds` (see
+ * `USAGE_UNITS`); where the session's own price includes it, as nothing more.
  */
 export const realtimeInputTranscriptionSchema = z
     .object({
-    /** A BCP 47 tag, when the caller knows the language. */
+    /**
+     * The client's own BCP 47 tag, when it knows the language. Kaana sends
+     * the provider its spelling of that language, or none for the model to
+     * detect; it is never refused.
+     */
     language: z.string().min(2).max(35).optional(),
+    /** A hint — vocabulary or context — used where the model takes one. */
     prompt: z.string().max(4_096).optional(),
 })
     .strict();
@@ -598,6 +606,16 @@ export const realtimeOpenLimitsSchema = realtimeSessionLimitsSchema.partial().st
  * frame closes the connection before it is read.
  */
 export const MAX_REALTIME_OPEN_FRAME_BYTES = 1024 * 1024;
+/**
+ * The silence, in milliseconds, after which `server_vad` ends a caller's turn
+ * when the session names none (contract set 6.0.0, Kaana ADR 0003). Kaana
+ * sends it to every provider, so a turn ends the same way whichever serves
+ * the session. Measured on x-ai/grok-voice-3.0 (2026-10-16): with xAI's own
+ * default a phrase with pauses of 0.56 s and 0.79 s was cut into three
+ * responses, two cancelled, the model speaking before the phrase ended; at
+ * 500 ms it was one response, answered 490–576 ms after the phrase.
+ */
+export const REALTIME_DEFAULT_SILENCE_DURATION_MS = 500;
 /**
  * The first frame a client sends on `GET /v1/realtime?model=…` to OPEN a
  * session (a reconnection instead sends `session.resume`). One grant covers the
@@ -693,84 +711,6 @@ export function checkRealtimeSessionOpen(open, model) {
             message: 'this model does not transcribe its input inside a conversation',
         });
     }
-    if (transcription?.language !== undefined &&
-        audio !== undefined &&
-        !audio.languages.includes(transcription.language)) {
-        issues.push({
-            param: 'config.inputAudioTranscription.language',
-            message: `this model does not declare the language ${transcription.language}` +
-                (audio.detectsLanguage === true ? '; omit it to let the model detect the language' : ''),
-        });
-    }
-    if (realtime.parameters !== undefined) {
-        issues.push(...realtimeParameterIssues('config', config, realtime.parameters));
-    }
-    return issues;
-}
-function toolChoiceKind(choice) {
-    return typeof choice === 'string' ? choice : 'function';
-}
-function sameModalities(a, b) {
-    const left = [...a].sort();
-    const right = [...b].sort();
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-/**
- * Every field that `parameters` do not serve, each with the `param` Kaana's
- * refusal names (`prefix` is `config` for an open or a `session.update`,
- * `response` for a `response.create`), in the order Kaana checks them. It is
- * exactly Kaana's own check (Go's `RealtimeParameters.Issues`, held to the
- * same vectors), so a client that builds its session from a model's
- * parameters, or filters models with this, is never refused for one.
- */
-export function realtimeParameterIssues(prefix, fields, parameters) {
-    const issues = [];
-    const issue = (param, message) => issues.push({ param: `${prefix}.${param}`, message });
-    if (fields.outputModalities !== undefined &&
-        !parameters.outputModalities.some((set) => sameModalities(set, fields.outputModalities ?? []))) {
-        issue('outputModalities', `this model produces ${parameters.outputModalities.map((set) => `[${set.join(' ')}]`).join(' or ')} in one response`);
-    }
-    const detection = fields.turnDetection;
-    if (detection !== undefined) {
-        const served = parameters.turnDetection.find((candidate) => candidate.type === detection.type);
-        if (served === undefined) {
-            issue('turnDetection', `this model has no ${detection.type} turn detection`);
-        }
-        else {
-            if (served.fixedResponses && detection.type !== 'none') {
-                if (!detection.createResponse) {
-                    issue('turnDetection.createResponse', `this model's ${detection.type} always answers the turn it detected; createResponse must be true`);
-                }
-                if (!detection.interruptResponse) {
-                    issue('turnDetection.interruptResponse', `this model's ${detection.type} lets the caller's speech interrupt an answer; interruptResponse must be true`);
-                }
-            }
-            if (detection.type === 'server_vad') {
-                const threshold = served.threshold;
-                if (threshold !== undefined &&
-                    detection.threshold !== undefined &&
-                    (detection.threshold < threshold.min || detection.threshold > threshold.max)) {
-                    issue('turnDetection.threshold', `this model's ${detection.type} threshold is ${threshold.min} to ${threshold.max}`);
-                }
-            }
-        }
-    }
-    if (fields.inputAudioTranscription?.prompt !== undefined &&
-        !parameters.inputTranscriptionPrompt) {
-        issue('inputAudioTranscription.prompt', "this model's input transcription takes no prompt");
-    }
-    if (fields.toolChoice !== undefined &&
-        !parameters.toolChoice.includes(toolChoiceKind(fields.toolChoice))) {
-        issue('toolChoice', `this model serves the tool choices ${parameters.toolChoice.join(', ')}`);
-    }
-    if (fields.maxOutputTokens !== undefined) {
-        if (parameters.maxOutputTokens === undefined) {
-            issue('maxOutputTokens', 'this model has no output token cap');
-        }
-        else if (fields.maxOutputTokens > parameters.maxOutputTokens) {
-            issue('maxOutputTokens', `this model caps a response at most at ${parameters.maxOutputTokens} output tokens`);
-        }
-    }
     return issues;
 }
 /* -------------------------------------------------------------------------- */

package/dist/public/responses.d.ts

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

package/dist/public/version.d.ts

@@ -100,7 +100,7 @@
  * change to, say, the catalogue reject every in-flight inference request; the
  * per-shape `schemaVersion` is what a message is validated against.
  */
-export declare const INFERENCE_CONTRACT_VERSION = "5.0.0";
+export declare const INFERENCE_CONTRACT_VERSION = "6.0.0";
 /**
  * Contract set 4.0.0 (Kaana ADR 0002) is the first published as
  * `@kaana.ai/contracts`. MAJOR because the set changed hands and split in two:
@@ -155,6 +155,21 @@ export declare const INFERENCE_CONTRACT_VERSION = "5.0.0";
  * `MAX_REALTIME_TEXT_ITEMS`, and a transcription's `timestamps`, `segments`
  * and `words`. A request that parsed under 4.5.0 and that Kaana served
  * still parses and is served the same.
+ *
+ * Contract set 6.0.0 (Kaana ADR 0003) is one canonical API: no provider's
+ * variant reaches a client. Kaana translates or emulates every value the
+ * contract offers on every model, so the catalogue publishes product
+ * capabilities only. MAJOR because it REMOVES what 5.0.0 published of each
+ * provider's wire: `capabilities.realtime.parameters`
+ * (`realtimeParametersSchema`, `realtimeTurnDetectionParametersSchema`,
+ * `numberRangeSchema`, `realtimeToolChoiceKindSchema`),
+ * `realtimeParameterIssues`, `audio.detectsLanguage` and
+ * `audio.transcriptionPrompt`; and `checkTranscriptionRequest` takes the
+ * upload's media type alone, since a language or a prompt is never refused.
+ * Additive: a model's `pricePerMinute`, exactly one input `transcript.done`
+ * per item, and `REALTIME_DEFAULT_SILENCE_DURATION_MS`, the silence a
+ * `server_vad` that names none waits on every provider. A client on 5.0.0
+ * parses every 6.0.0 response.
  */
 /** The public API's one origin and version. */
 export declare const KAANA_API_BASE_URL = "https://kaana.ai/v1";
@@ -163,9 +178,8 @@ export declare const KAANA_REQUEST_ID_HEADER = "Kaana-Request-Id";
 /**
  * The header that carries {@link INFERENCE_CONTRACT_VERSION}: on every
  * response, the set Kaana serves; on a request (`@kaana.ai/sdk` 2.0.0 and
- * later), the set the client parses. The catalogue's leaves are strict, so
- * Kaana renders `GET /v1/models` in the shape of the client's set: a client
- * that states none is served the 4.x shape, without what set 5.0.0 added.
+ * later), the set the client parses. Every set since 4.0.0 parses the
+ * catalogue Kaana serves.
  */
 export declare const KAANA_CONTRACT_VERSION_HEADER = "Kaana-Contract-Version";
 /**

package/dist/public/version.js

@@ -100,7 +100,7 @@
  * change to, say, the catalogue reject every in-flight inference request; the
  * per-shape `schemaVersion` is what a message is validated against.
  */
-export const INFERENCE_CONTRACT_VERSION = '5.0.0';
+export const INFERENCE_CONTRACT_VERSION = '6.0.0';
 /**
  * Contract set 4.0.0 (Kaana ADR 0002) is the first published as
  * `@kaana.ai/contracts`. MAJOR because the set changed hands and split in two:
@@ -155,6 +155,21 @@ export const INFERENCE_CONTRACT_VERSION = '5.0.0';
  * `MAX_REALTIME_TEXT_ITEMS`, and a transcription's `timestamps`, `segments`
  * and `words`. A request that parsed under 4.5.0 and that Kaana served
  * still parses and is served the same.
+ *
+ * Contract set 6.0.0 (Kaana ADR 0003) is one canonical API: no provider's
+ * variant reaches a client. Kaana translates or emulates every value the
+ * contract offers on every model, so the catalogue publishes product
+ * capabilities only. MAJOR because it REMOVES what 5.0.0 published of each
+ * provider's wire: `capabilities.realtime.parameters`
+ * (`realtimeParametersSchema`, `realtimeTurnDetectionParametersSchema`,
+ * `numberRangeSchema`, `realtimeToolChoiceKindSchema`),
+ * `realtimeParameterIssues`, `audio.detectsLanguage` and
+ * `audio.transcriptionPrompt`; and `checkTranscriptionRequest` takes the
+ * upload's media type alone, since a language or a prompt is never refused.
+ * Additive: a model's `pricePerMinute`, exactly one input `transcript.done`
+ * per item, and `REALTIME_DEFAULT_SILENCE_DURATION_MS`, the silence a
+ * `server_vad` that names none waits on every provider. A client on 5.0.0
+ * parses every 6.0.0 response.
  */
 /** The public API's one origin and version. */
 export const KAANA_API_BASE_URL = 'https://kaana.ai/v1';
@@ -163,9 +178,8 @@ export const KAANA_REQUEST_ID_HEADER = 'Kaana-Request-Id';
 /**
  * The header that carries {@link INFERENCE_CONTRACT_VERSION}: on every
  * response, the set Kaana serves; on a request (`@kaana.ai/sdk` 2.0.0 and
- * later), the set the client parses. The catalogue's leaves are strict, so
- * Kaana renders `GET /v1/models` in the shape of the client's set: a client
- * that states none is served the 4.x shape, without what set 5.0.0 added.
+ * later), the set the client parses. Every set since 4.0.0 parses the
+ * catalogue Kaana serves.
  */
 export const KAANA_CONTRACT_VERSION_HEADER = 'Kaana-Contract-Version';
 /**