@meetkai/mka1 0.55.17 → 0.55.20

package/src/lib/config.ts

@@ -65,7 +65,7 @@ export function serverURLFromOptions(options: SDKOptions): URL | null {
 export const SDK_METADATA = {
   language: "typescript",
   openapiDocVersion: "1.1.0",
-  sdkVersion: "0.55.17",
+  sdkVersion: "0.55.20",
   genVersion: "2.950.2",
-  userAgent: "speakeasy-sdk/typescript 0.55.17 2.950.2 1.1.0 @meetkai/mka1",
+  userAgent: "speakeasy-sdk/typescript 0.55.20 2.950.2 1.1.0 @meetkai/mka1",
 } as const;

package/src/mcp-server/mcp-server.ts

@@ -19,7 +19,7 @@ const routes = buildRouteMap({
 export const app = buildApplication(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "0.55.17",
+    currentVersion: "0.55.20",
   },
 });
 

package/src/mcp-server/server.ts

@@ -513,7 +513,7 @@ export function createMCPServer(deps: {
 }) {
   const server = new McpServer({
     name: "SDK",
-    version: "0.55.17",
+    version: "0.55.20",
   });
 
   const client = new SDKCore({

package/src/mcp-server/tools/llmSpeechSpeak.ts

@@ -19,6 +19,7 @@ Convert text to speech with automatic language detection.
 **Request Body:**
 - \`text\`: Input text to convert to speech - required
 - \`language\`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
+- \`voice\`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured \`meetkai:speech\` model exposing \`sophia\`; use IDs advertised by your deployment
 - \`model\`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider
 
 **Response:** Returns audio file in WAV format with X-Language-Code header. When \`store\` is \`true\`, the generation is persisted before the response returns and the new history record id is included in the X-Tts-Id header.`,

package/src/mcp-server/tools/llmSpeechSpeakStreaming.ts

@@ -26,6 +26,7 @@ Convert text to speech with real-time streaming audio delivery.
 - \`text\`: Input text to convert to speech - required
 - \`language\`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
 - \`format\`: Audio format (default: "mp3") - "mp3" for compressed MPEG audio (96 kbps) or "pcm" for uncompressed WAV
+- \`voice\`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured \`meetkai:speech\` model exposing \`sophia\`; use IDs advertised by your deployment
 - \`model\`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider (note: not all providers support \`format: "mp3"\`)
 
 **Response:**

package/src/models/components/addcatalogmodelrequest.ts

@@ -25,6 +25,7 @@ export const ApiProviderType = {
   Meetkai: "meetkai",
   MeetkaiGateway: "meetkaiGateway",
   Openai: "openai",
+  Openrouter: "openrouter",
 } as const;
 export type ApiProviderType = ClosedEnum<typeof ApiProviderType>;
 

package/src/models/components/texttospeechrequest.ts

@@ -49,6 +49,10 @@ export type TextToSpeechRequest = {
    * Input text to convert to speech
    */
   text: string;
+  /**
+   * Public voice ID from model discovery. Overrides the model's language default. With language=auto, the selected voice determines the language; an explicit conflicting language is rejected.
+   */
+  voice?: string | undefined;
   /**
    * Language code: 'auto' for automatic detection, or ISO 639-1 language codes. With 'auto', text confidently detected as a language without a voice is rejected with a 400 naming it.
    */
@@ -77,6 +81,7 @@ export const TextToSpeechRequest$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   text: z.string(),
+  voice: z.string().optional(),
   language: Language$inboundSchema.default("auto"),
   model: z.string().default("auto"),
   store: z.boolean().default(false),
@@ -84,6 +89,7 @@ export const TextToSpeechRequest$inboundSchema: z.ZodType<
 /** @internal */
 export type TextToSpeechRequest$Outbound = {
   text: string;
+  voice?: string | undefined;
   language: string;
   model: string;
   store: boolean;
@@ -96,6 +102,7 @@ export const TextToSpeechRequest$outboundSchema: z.ZodType<
   TextToSpeechRequest
 > = z.object({
   text: z.string(),
+  voice: z.string().optional(),
   language: Language$outboundSchema.default("auto"),
   model: z.string().default("auto"),
   store: z.boolean().default(false),

package/src/models/components/texttospeechstreamingrequest.ts

@@ -63,6 +63,10 @@ export type TextToSpeechStreamingRequest = {
    * Input text to convert to speech
    */
   text: string;
+  /**
+   * Public voice ID from model discovery. Overrides the model's language default. With language=auto, the selected voice determines the language; an explicit conflicting language is rejected.
+   */
+  voice?: string | undefined;
   /**
    * Language code: 'auto' for automatic detection, or ISO 639-1 language codes. With 'auto', text confidently detected as a language without a voice is rejected with a 400 naming it.
    */
@@ -105,6 +109,7 @@ export const TextToSpeechStreamingRequest$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   text: z.string(),
+  voice: z.string().optional(),
   language: TextToSpeechStreamingRequestLanguage$inboundSchema.default("auto"),
   model: z.string().default("auto"),
   store: z.boolean().default(false),
@@ -113,6 +118,7 @@ export const TextToSpeechStreamingRequest$inboundSchema: z.ZodType<
 /** @internal */
 export type TextToSpeechStreamingRequest$Outbound = {
   text: string;
+  voice?: string | undefined;
   language: string;
   model: string;
   store: boolean;
@@ -126,6 +132,7 @@ export const TextToSpeechStreamingRequest$outboundSchema: z.ZodType<
   TextToSpeechStreamingRequest
 > = z.object({
   text: z.string(),
+  voice: z.string().optional(),
   language: TextToSpeechStreamingRequestLanguage$outboundSchema.default("auto"),
   model: z.string().default("auto"),
   store: z.boolean().default(false),

package/src/models/components/updatecatalogmodelrequest.ts

@@ -25,6 +25,7 @@ export const UpdateCatalogModelRequestApiProviderType = {
   Meetkai: "meetkai",
   MeetkaiGateway: "meetkaiGateway",
   Openai: "openai",
+  Openrouter: "openrouter",
 } as const;
 export type UpdateCatalogModelRequestApiProviderType = ClosedEnum<
   typeof UpdateCatalogModelRequestApiProviderType

package/src/models/operations/getmodel.ts

@@ -70,6 +70,17 @@ export const Weights = {
 } as const;
 export type Weights = ClosedEnum<typeof Weights>;
 
+export type Voices = {
+  id: string;
+  name: string;
+  language: string;
+};
+
+export type Tts = {
+  defaultVoice: { [k: string]: string };
+  voices: Array<Voices>;
+};
+
 /**
  * `active`, `deprecated` (still served, retirement announced or pending) or `retired` (the retirement date has passed). Informational in this version: the gateway does not yet refuse a retired model.
  */
@@ -200,6 +211,10 @@ export type GetModelResponseBody = {
    * Languages the model is intended for, as ISO 639-1 codes, mirroring `modelCard.languages`. Null when unrecorded.
    */
   languages: Array<string> | null;
+  /**
+   * Available public TTS voices and default voice IDs by language. Provider voice identifiers are not exposed.
+   */
+  tts: Tts | null;
   /**
    * Known limitations in one short paragraph, mirroring `modelCard.limitations`. Null when unrecorded.
    */
@@ -407,6 +422,84 @@ export const Weights$inboundSchema: z.ZodNativeEnum<typeof Weights> = z
 export const Weights$outboundSchema: z.ZodNativeEnum<typeof Weights> =
   Weights$inboundSchema;
 
+/** @internal */
+export const Voices$inboundSchema: z.ZodType<Voices, z.ZodTypeDef, unknown> = z
+  .object({
+    id: z.string(),
+    name: z.string(),
+    language: z.string(),
+  });
+/** @internal */
+export type Voices$Outbound = {
+  id: string;
+  name: string;
+  language: string;
+};
+
+/** @internal */
+export const Voices$outboundSchema: z.ZodType<
+  Voices$Outbound,
+  z.ZodTypeDef,
+  Voices
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+  language: z.string(),
+});
+
+export function voicesToJSON(voices: Voices): string {
+  return JSON.stringify(Voices$outboundSchema.parse(voices));
+}
+export function voicesFromJSON(
+  jsonString: string,
+): SafeParseResult<Voices, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Voices$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Voices' from JSON`,
+  );
+}
+
+/** @internal */
+export const Tts$inboundSchema: z.ZodType<Tts, z.ZodTypeDef, unknown> = z
+  .object({
+    default_voice: z.record(z.string()),
+    voices: z.array(z.lazy(() => Voices$inboundSchema)),
+  }).transform((v) => {
+    return remap$(v, {
+      "default_voice": "defaultVoice",
+    });
+  });
+/** @internal */
+export type Tts$Outbound = {
+  default_voice: { [k: string]: string };
+  voices: Array<Voices$Outbound>;
+};
+
+/** @internal */
+export const Tts$outboundSchema: z.ZodType<Tts$Outbound, z.ZodTypeDef, Tts> = z
+  .object({
+    defaultVoice: z.record(z.string()),
+    voices: z.array(z.lazy(() => Voices$outboundSchema)),
+  }).transform((v) => {
+    return remap$(v, {
+      defaultVoice: "default_voice",
+    });
+  });
+
+export function ttsToJSON(tts: Tts): string {
+  return JSON.stringify(Tts$outboundSchema.parse(tts));
+}
+export function ttsFromJSON(
+  jsonString: string,
+): SafeParseResult<Tts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Tts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Tts' from JSON`,
+  );
+}
+
 /** @internal */
 export const GetModelStatus$inboundSchema: z.ZodNativeEnum<
   typeof GetModelStatus
@@ -565,6 +658,7 @@ export const GetModelResponseBody$inboundSchema: z.ZodType<
   weights: z.nullable(Weights$inboundSchema),
   license: z.nullable(z.string()),
   languages: z.nullable(z.array(z.string())),
+  tts: z.nullable(z.lazy(() => Tts$inboundSchema)),
   limitations: z.nullable(z.string()),
   lifecycle: z.lazy(() => Lifecycle$inboundSchema),
   capabilities: z.lazy(() => Capabilities$inboundSchema),
@@ -607,6 +701,7 @@ export type GetModelResponseBody$Outbound = {
   weights: string | null;
   license: string | null;
   languages: Array<string> | null;
+  tts: Tts$Outbound | null;
   limitations: string | null;
   lifecycle: Lifecycle$Outbound;
   capabilities: Capabilities$Outbound;
@@ -644,6 +739,7 @@ export const GetModelResponseBody$outboundSchema: z.ZodType<
   weights: z.nullable(Weights$outboundSchema),
   license: z.nullable(z.string()),
   languages: z.nullable(z.array(z.string())),
+  tts: z.nullable(z.lazy(() => Tts$outboundSchema)),
   limitations: z.nullable(z.string()),
   lifecycle: z.lazy(() => Lifecycle$outboundSchema),
   capabilities: z.lazy(() => Capabilities$outboundSchema),

package/src/models/operations/getspeechtotexthistorycontent.ts

@@ -16,6 +16,23 @@ export type GetSpeechToTextHistoryContentRequest = {
   xOnBehalfOf?: string | undefined;
 };
 
+export type GetSpeechToTextHistoryContentResponse =
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>;
+
 /** @internal */
 export const GetSpeechToTextHistoryContentRequest$inboundSchema: z.ZodType<
   GetSpeechToTextHistoryContentRequest,
@@ -70,3 +87,86 @@ export function getSpeechToTextHistoryContentRequestFromJSON(
     `Failed to parse 'GetSpeechToTextHistoryContentRequest' from JSON`,
   );
 }
+
+/** @internal */
+export const GetSpeechToTextHistoryContentResponse$inboundSchema: z.ZodType<
+  GetSpeechToTextHistoryContentResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+]);
+/** @internal */
+export type GetSpeechToTextHistoryContentResponse$Outbound =
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>
+  | ReadableStream<Uint8Array>;
+
+/** @internal */
+export const GetSpeechToTextHistoryContentResponse$outboundSchema: z.ZodType<
+  GetSpeechToTextHistoryContentResponse$Outbound,
+  z.ZodTypeDef,
+  GetSpeechToTextHistoryContentResponse
+> = z.union([
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+  z.instanceof(ReadableStream<Uint8Array>),
+]);
+
+export function getSpeechToTextHistoryContentResponseToJSON(
+  getSpeechToTextHistoryContentResponse: GetSpeechToTextHistoryContentResponse,
+): string {
+  return JSON.stringify(
+    GetSpeechToTextHistoryContentResponse$outboundSchema.parse(
+      getSpeechToTextHistoryContentResponse,
+    ),
+  );
+}
+export function getSpeechToTextHistoryContentResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<GetSpeechToTextHistoryContentResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetSpeechToTextHistoryContentResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetSpeechToTextHistoryContentResponse' from JSON`,
+  );
+}

package/src/models/operations/listmodels.ts

@@ -69,6 +69,17 @@ export const ListModelsWeights = {
 } as const;
 export type ListModelsWeights = ClosedEnum<typeof ListModelsWeights>;
 
+export type TtsVoices = {
+  id: string;
+  name: string;
+  language: string;
+};
+
+export type ListModelsTts = {
+  defaultVoice: { [k: string]: string };
+  voices: Array<TtsVoices>;
+};
+
 /**
  * `active`, `deprecated` (still served, retirement announced or pending) or `retired` (the retirement date has passed). Informational in this version: the gateway does not yet refuse a retired model.
  */
@@ -196,6 +207,10 @@ export type ListModelsData = {
    * Languages the model is intended for, as ISO 639-1 codes, mirroring `modelCard.languages`. Null when unrecorded.
    */
   languages: Array<string> | null;
+  /**
+   * Available public TTS voices and default voice IDs by language. Provider voice identifiers are not exposed.
+   */
+  tts: ListModelsTts | null;
   /**
    * Known limitations in one short paragraph, mirroring `modelCard.limitations`. Null when unrecorded.
    */
@@ -418,6 +433,93 @@ export const ListModelsWeights$outboundSchema: z.ZodNativeEnum<
   typeof ListModelsWeights
 > = ListModelsWeights$inboundSchema;
 
+/** @internal */
+export const TtsVoices$inboundSchema: z.ZodType<
+  TtsVoices,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+  language: z.string(),
+});
+/** @internal */
+export type TtsVoices$Outbound = {
+  id: string;
+  name: string;
+  language: string;
+};
+
+/** @internal */
+export const TtsVoices$outboundSchema: z.ZodType<
+  TtsVoices$Outbound,
+  z.ZodTypeDef,
+  TtsVoices
+> = z.object({
+  id: z.string(),
+  name: z.string(),
+  language: z.string(),
+});
+
+export function ttsVoicesToJSON(ttsVoices: TtsVoices): string {
+  return JSON.stringify(TtsVoices$outboundSchema.parse(ttsVoices));
+}
+export function ttsVoicesFromJSON(
+  jsonString: string,
+): SafeParseResult<TtsVoices, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TtsVoices$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TtsVoices' from JSON`,
+  );
+}
+
+/** @internal */
+export const ListModelsTts$inboundSchema: z.ZodType<
+  ListModelsTts,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  default_voice: z.record(z.string()),
+  voices: z.array(z.lazy(() => TtsVoices$inboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    "default_voice": "defaultVoice",
+  });
+});
+/** @internal */
+export type ListModelsTts$Outbound = {
+  default_voice: { [k: string]: string };
+  voices: Array<TtsVoices$Outbound>;
+};
+
+/** @internal */
+export const ListModelsTts$outboundSchema: z.ZodType<
+  ListModelsTts$Outbound,
+  z.ZodTypeDef,
+  ListModelsTts
+> = z.object({
+  defaultVoice: z.record(z.string()),
+  voices: z.array(z.lazy(() => TtsVoices$outboundSchema)),
+}).transform((v) => {
+  return remap$(v, {
+    defaultVoice: "default_voice",
+  });
+});
+
+export function listModelsTtsToJSON(listModelsTts: ListModelsTts): string {
+  return JSON.stringify(ListModelsTts$outboundSchema.parse(listModelsTts));
+}
+export function listModelsTtsFromJSON(
+  jsonString: string,
+): SafeParseResult<ListModelsTts, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ListModelsTts$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ListModelsTts' from JSON`,
+  );
+}
+
 /** @internal */
 export const ListModelsStatus$inboundSchema: z.ZodNativeEnum<
   typeof ListModelsStatus
@@ -584,6 +686,7 @@ export const ListModelsData$inboundSchema: z.ZodType<
   weights: z.nullable(ListModelsWeights$inboundSchema),
   license: z.nullable(z.string()),
   languages: z.nullable(z.array(z.string())),
+  tts: z.nullable(z.lazy(() => ListModelsTts$inboundSchema)),
   limitations: z.nullable(z.string()),
   lifecycle: z.lazy(() => ListModelsLifecycle$inboundSchema),
   capabilities: z.lazy(() => ListModelsCapabilities$inboundSchema),
@@ -626,6 +729,7 @@ export type ListModelsData$Outbound = {
   weights: string | null;
   license: string | null;
   languages: Array<string> | null;
+  tts: ListModelsTts$Outbound | null;
   limitations: string | null;
   lifecycle: ListModelsLifecycle$Outbound;
   capabilities: ListModelsCapabilities$Outbound;
@@ -663,6 +767,7 @@ export const ListModelsData$outboundSchema: z.ZodType<
   weights: z.nullable(ListModelsWeights$outboundSchema),
   license: z.nullable(z.string()),
   languages: z.nullable(z.array(z.string())),
+  tts: z.nullable(z.lazy(() => ListModelsTts$outboundSchema)),
   limitations: z.nullable(z.string()),
   lifecycle: z.lazy(() => ListModelsLifecycle$outboundSchema),
   capabilities: z.lazy(() => ListModelsCapabilities$outboundSchema),

package/src/react-query/llmSpeechGetTranscriptionHistoryContent.core.ts

@@ -8,20 +8,24 @@ import {
   QueryKey,
 } from "@tanstack/react-query";
 import { SDKCore } from "../core.js";
-import { llmSpeechGetTranscriptionHistoryContent } from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
+import {
+  GetTranscriptionHistoryContentAcceptEnum,
+  llmSpeechGetTranscriptionHistoryContent,
+} from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
 import { combineSignals } from "../lib/primitives.js";
 import { RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
-export type LlmSpeechGetTranscriptionHistoryContentQueryData = ReadableStream<
-  Uint8Array
->;
+export type LlmSpeechGetTranscriptionHistoryContentQueryData =
+  operations.GetSpeechToTextHistoryContentResponse;
 
 export function prefetchLlmSpeechGetTranscriptionHistoryContent(
   queryClient: QueryClient,
   client$: SDKCore,
   request: operations.GetSpeechToTextHistoryContentRequest,
-  options?: RequestOptions,
+  options?: RequestOptions & {
+    acceptHeaderOverride?: GetTranscriptionHistoryContentAcceptEnum;
+  },
 ): Promise<void> {
   return queryClient.prefetchQuery({
     ...buildLlmSpeechGetTranscriptionHistoryContentQuery(
@@ -35,7 +39,9 @@ export function prefetchLlmSpeechGetTranscriptionHistoryContent(
 export function buildLlmSpeechGetTranscriptionHistoryContentQuery(
   client$: SDKCore,
   request: operations.GetSpeechToTextHistoryContentRequest,
-  options?: RequestOptions,
+  options?: RequestOptions & {
+    acceptHeaderOverride?: GetTranscriptionHistoryContentAcceptEnum;
+  },
 ): {
   queryKey: QueryKey;
   queryFn: (

package/src/react-query/llmSpeechGetTranscriptionHistoryContent.ts

@@ -50,6 +50,8 @@ export type LlmSpeechGetTranscriptionHistoryContentQueryError =
   | UnexpectedClientError
   | SDKValidationError;
 
+export { GetTranscriptionHistoryContentAcceptEnum } from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
+
 /**
  * Retrieve speech-to-text audio
  *

package/src/react-query/llmSpeechSpeak.ts

@@ -52,6 +52,7 @@ export type LlmSpeechSpeakMutationError =
  * **Request Body:**
  * - `text`: Input text to convert to speech - required
  * - `language`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
+ * - `voice`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured `meetkai:speech` model exposing `sophia`; use IDs advertised by your deployment
  * - `model`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider
  *
  * **Response:** Returns audio file in WAV format with X-Language-Code header. When `store` is `true`, the generation is persisted before the response returns and the new history record id is included in the X-Tts-Id header.

package/src/react-query/llmSpeechSpeakStreaming.ts

@@ -67,6 +67,7 @@ export type LlmSpeechSpeakStreamingMutationError =
  * - `text`: Input text to convert to speech - required
  * - `language`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
  * - `format`: Audio format (default: "mp3") - "mp3" for compressed MPEG audio (96 kbps) or "pcm" for uncompressed WAV
+ * - `voice`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured `meetkai:speech` model exposing `sophia`; use IDs advertised by your deployment
  * - `model`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider (note: not all providers support `format: "mp3"`)
  *
  * **Response:**

package/src/sdk/speech.ts

@@ -5,7 +5,10 @@
 import { llmSpeechDeleteTranscriptionHistory } from "../funcs/llmSpeechDeleteTranscriptionHistory.js";
 import { llmSpeechDeleteTtsHistory } from "../funcs/llmSpeechDeleteTtsHistory.js";
 import { llmSpeechGetTranscriptionHistory } from "../funcs/llmSpeechGetTranscriptionHistory.js";
-import { llmSpeechGetTranscriptionHistoryContent } from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
+import {
+  GetTranscriptionHistoryContentAcceptEnum,
+  llmSpeechGetTranscriptionHistoryContent,
+} from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
 import { llmSpeechGetTtsHistory } from "../funcs/llmSpeechGetTtsHistory.js";
 import {
   GetTtsHistoryContentAcceptEnum,
@@ -29,6 +32,8 @@ export { SpeakStreamingAcceptEnum } from "../funcs/llmSpeechSpeakStreaming.js";
 
 export { GetTtsHistoryContentAcceptEnum } from "../funcs/llmSpeechGetTtsHistoryContent.js";
 
+export { GetTranscriptionHistoryContentAcceptEnum } from "../funcs/llmSpeechGetTranscriptionHistoryContent.js";
+
 export class Speech extends ClientSDK {
   /**
    * Speech to text transcription
@@ -87,6 +92,7 @@ export class Speech extends ClientSDK {
    * **Request Body:**
    * - `text`: Input text to convert to speech - required
    * - `language`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
+   * - `voice`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured `meetkai:speech` model exposing `sophia`; use IDs advertised by your deployment
    * - `model`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider
    *
    * **Response:** Returns audio file in WAV format with X-Language-Code header. When `store` is `true`, the generation is persisted before the response returns and the new history record id is included in the X-Tts-Id header.
@@ -118,6 +124,7 @@ export class Speech extends ClientSDK {
    * - `text`: Input text to convert to speech - required
    * - `language`: Language code (default: "auto") - "auto" for automatic detection, or one of the supported ISO 639-1 codes: en, zh, hi, es, ar, bn, pt, ru, ja, pa, de, ko, fr, tr, it, th, pl, nl, id, vi, ur, uk
    * - `format`: Audio format (default: "mp3") - "mp3" for compressed MPEG audio (96 kbps) or "pcm" for uncompressed WAV
+   * - `voice`: Optional public voice ID from model discovery; otherwise the resolved language selects its configured default. The example assumes an operator-configured `meetkai:speech` model exposing `sophia`; use IDs advertised by your deployment
    * - `model`: TTS model identifier (default: "auto") - "auto" selects the default provider; a registry-resolvable id dispatches to the matching provider (note: not all providers support `format: "mp3"`)
    *
    * **Response:**
@@ -290,8 +297,10 @@ export class Speech extends ClientSDK {
    */
   async getTranscriptionHistoryContent(
     request: operations.GetSpeechToTextHistoryContentRequest,
-    options?: RequestOptions,
-  ): Promise<ReadableStream<Uint8Array>> {
+    options?: RequestOptions & {
+      acceptHeaderOverride?: GetTranscriptionHistoryContentAcceptEnum;
+    },
+  ): Promise<operations.GetSpeechToTextHistoryContentResponse> {
     return unwrapAsync(llmSpeechGetTranscriptionHistoryContent(
       this,
       request,