@ai-sdk/azure 3.0.130 → 3.0.132

package/dist/index.js

@@ -29,8 +29,8 @@ module.exports = __toCommonJS(index_exports);
 // src/azure-openai-provider.ts
 var import_internal2 = require("@ai-sdk/openai/internal");
 var import_internal3 = require("@ai-sdk/deepseek/internal");
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider2 = require("@ai-sdk/provider");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 
 // src/azure-openai-tools.ts
 var import_internal = require("@ai-sdk/openai/internal");
@@ -42,60 +42,312 @@ var azureOpenaiTools = {
   webSearchPreview: import_internal.webSearchPreview
 };
 
-// src/azure-speech-transcription-model.ts
+// src/azure-speech-model-options.ts
+var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_v42 = require("zod/v4");
+
+// src/azure-speech-speech-model-options.ts
+var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_v4 = require("zod/v4");
+var azureSpeechSpeechModelOptionsShape = () => ({
+  /**
+   * Speaking style applied with `mstts:express-as`, e.g. `excited` or
+   * `whispering`. Supported styles vary by voice.
+   */
+  style: import_v4.z.string().min(1).optional(),
+  /**
+   * Intensity of `style`, from 0.01 to 2. Azure defaults to 1.
+   */
+  styleDegree: import_v4.z.number().min(0.01).max(2).optional()
+});
+var azureSpeechSpeechModelOptions = (0, import_provider_utils.lazySchema)(
+  () => (0, import_provider_utils.zodSchema)(import_v4.z.strictObject(azureSpeechSpeechModelOptionsShape()))
+);
+
+// src/azure-speech-model-options.ts
+var azureSpeechModelOptions = (0, import_provider_utils2.lazySchema)(
+  () => (0, import_provider_utils2.zodSchema)(
+    import_v42.z.strictObject({
+      /**
+       * API to use. Defaults to Speech for MAI-Voice models, OpenAI otherwise.
+       */
+      api: import_v42.z.enum(["openai", "speech"]).optional(),
+      ...azureSpeechSpeechModelOptionsShape()
+    })
+  )
+);
+var maiVoiceModels = /* @__PURE__ */ new Map([
+  ["mai-voice-2-flash", "MAI-Voice-2-Flash"],
+  ["mai-voice-2", "MAI-Voice-2"]
+]);
+function getMAIVoiceModel(modelId) {
+  return maiVoiceModels.get(modelId.toLowerCase());
+}
+
+// src/azure-speech-speech-model.ts
+var import_provider = require("@ai-sdk/provider");
 var import_provider_utils3 = require("@ai-sdk/provider-utils");
 var import_v43 = require("zod/v4");
+var DEFAULT_VOICE = "en-US-Harper";
+var DEFAULT_VOICES = /* @__PURE__ */ new Map([
+  ["de", "de-DE-Mia"],
+  ["en", DEFAULT_VOICE],
+  ["es", "es-MX-Valeria"],
+  ["fr", "fr-FR-Soleil"],
+  ["hi", "hi-IN-Kavya"],
+  ["hu", "hu-HU-Lilla"],
+  ["it", "it-IT-Rosa"],
+  ["ko", "ko-KR-Haena"],
+  ["nl", "nl-NL-Fleur"],
+  ["pt", "pt-BR-Luana"],
+  ["ro", "ro-RO-Elena"],
+  ["ru", "ru-RU-Masha"],
+  ["th", "th-TH-Krit"],
+  ["tr", "tr-TR-Elif"],
+  ["zh", "zh-CN-Mei"]
+]);
+var DEFAULT_OUTPUT_FORMAT = "audio-24khz-160kbitrate-mono-mp3";
+var OUTPUT_FORMATS = /* @__PURE__ */ new Map([
+  ["mp3", DEFAULT_OUTPUT_FORMAT],
+  ["opus", "ogg-24khz-16bit-mono-opus"],
+  ["pcm", "raw-24khz-16bit-mono-pcm"],
+  ["wav", "riff-24khz-16bit-mono-pcm"]
+]);
+var NATIVE_OUTPUT_FORMAT = /^(?:amr|audio|g722|ogg|raw|riff|webm)-[a-z0-9-]+$/;
+var AzureSpeechSpeechModel = class {
+  constructor(modelId, config) {
+    this.modelId = modelId;
+    this.config = config;
+    this.specificationVersion = "v3";
+    this.provider = "azure.speech";
+  }
+  async doGenerate(options, azureOptions = {}) {
+    var _a, _b, _c, _d, _e;
+    const currentDate = (_c = (_b = (_a = this.config._internal) == null ? void 0 : _a.currentDate) == null ? void 0 : _b.call(_a)) != null ? _c : /* @__PURE__ */ new Date();
+    const warnings = [];
+    const { style, styleDegree } = azureOptions;
+    if (options.instructions != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "instructions",
+        details: "Use providerOptions.azure.style to control speaking style."
+      });
+    }
+    const { voice, languageWarning } = resolveVoice(
+      options.voice,
+      options.language
+    );
+    if (languageWarning != null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "language",
+        details: languageWarning
+      });
+    }
+    if (styleDegree != null && style == null) {
+      warnings.push({
+        type: "unsupported",
+        feature: "providerOptions.azure.styleDegree",
+        details: "styleDegree requires style."
+      });
+    }
+    let outputFormat = DEFAULT_OUTPUT_FORMAT;
+    if (options.outputFormat != null) {
+      const format = options.outputFormat.toLowerCase();
+      const shorthand = OUTPUT_FORMATS.get(format);
+      if (shorthand != null) {
+        outputFormat = shorthand;
+      } else if (NATIVE_OUTPUT_FORMAT.test(format)) {
+        outputFormat = format;
+      } else {
+        warnings.push({
+          type: "unsupported",
+          feature: "outputFormat",
+          details: `Unsupported output format: ${options.outputFormat}. Using mp3 instead.`
+        });
+      }
+    }
+    const ssml = buildSsml({
+      text: options.text,
+      voiceName: voice.includes(":") ? voice : `${voice}:${(_d = getMAIVoiceModel(this.modelId)) != null ? _d : this.modelId}`,
+      locale: (_e = /^([a-z]{2,3}-[a-z]{2,4})-/i.exec(voice)) == null ? void 0 : _e[1],
+      speed: options.speed,
+      style,
+      styleDegree: style != null ? styleDegree : void 0
+    });
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue
+    } = await (0, import_provider_utils3.postToApi)({
+      url: this.config.url(),
+      headers: (0, import_provider_utils3.combineHeaders)(
+        this.config.headers(),
+        {
+          "Content-Type": "application/ssml+xml",
+          "X-Microsoft-OutputFormat": outputFormat
+        },
+        options.headers
+      ),
+      body: { content: ssml, values: ssml },
+      failedResponseHandler,
+      successfulResponseHandler: (0, import_provider_utils3.createBinaryResponseHandler)(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch
+    });
+    return {
+      audio,
+      warnings,
+      request: { body: ssml },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawValue
+      }
+    };
+  }
+};
+function buildSsml({
+  text,
+  voiceName,
+  locale = "en-US",
+  speed,
+  style,
+  styleDegree
+}) {
+  let content = escapeXml(text);
+  if (speed != null) {
+    content = `<prosody rate="${speed}">${content}</prosody>`;
+  }
+  if (style != null) {
+    const degree = styleDegree != null ? ` styledegree="${styleDegree}"` : "";
+    content = `<mstts:express-as style="${escapeXml(style)}"${degree}>${content}</mstts:express-as>`;
+  }
+  return `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xmlns:mstts="http://www.w3.org/2001/mstts" xml:lang="${escapeXml(locale)}"><voice name="${escapeXml(voiceName)}">${content}</voice></speak>`;
+}
+var XML_ESCAPES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+function escapeXml(value) {
+  return value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char]);
+}
+function resolveVoice(voice, language) {
+  var _a, _b;
+  const code = language ? language.split("-")[0].toLowerCase() : void 0;
+  if (voice == null) {
+    if (code == null) return { voice: DEFAULT_VOICE };
+    if (code === "auto") {
+      return {
+        voice: DEFAULT_VOICE,
+        languageWarning: `Automatic language detection is not supported. ${DEFAULT_VOICE} was used.`
+      };
+    }
+    const defaultVoice = DEFAULT_VOICES.get(code);
+    return defaultVoice != null ? { voice: defaultVoice } : {
+      voice: DEFAULT_VOICE,
+      languageWarning: `No default MAI voice for language "${language}". ${DEFAULT_VOICE} was used.`
+    };
+  }
+  const voiceLanguage = (_b = (_a = /^([a-z]{2,3})-[a-z]{2,4}-/i.exec(voice)) == null ? void 0 : _a[1]) == null ? void 0 : _b.toLowerCase();
+  return code != null && code !== "auto" && voiceLanguage != null && code !== voiceLanguage ? {
+    voice,
+    languageWarning: `The voice ${voice} selects the language. Language "${language}" was ignored.`
+  } : { voice };
+}
+var errorSchema = import_v43.z.object({
+  error: import_v43.z.object({ message: import_v43.z.string() })
+});
+var failedResponseHandler = async ({
+  response,
+  url,
+  requestBodyValues
+}) => {
+  const responseHeaders = (0, import_provider_utils3.extractResponseHeaders)(response);
+  const responseBody = await response.text();
+  const parsed = await (0, import_provider_utils3.safeParseJSON)({
+    text: responseBody,
+    schema: errorSchema
+  });
+  const message = parsed.success ? parsed.value.error.message : response.status === 400 ? "Azure Speech request failed with status 400. Check the voice name, style, and output format." : `Azure Speech request failed with status ${response.status}.`;
+  return {
+    responseHeaders,
+    value: new import_provider.APICallError({
+      message,
+      url,
+      requestBodyValues,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody
+    })
+  };
+};
+
+// src/azure-speech-transcription-model.ts
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_v46 = require("zod/v4");
 
 // src/azure-transcription-model-options.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_v45 = require("zod/v4");
 
 // src/azure-speech-transcription-model-options.ts
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var import_v4 = require("zod/v4");
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_v44 = require("zod/v4");
 var azureSpeechTranscriptionModelOptionsShape = () => ({
   /**
    * Timing granularity. Defaults to `segment` so that transcription results
    * include timed segments (Azure's own default is `none`).
    */
-  timestamps: import_v4.z.enum(["word", "segment", "none"]).optional(),
+  timestamps: import_v44.z.enum(["word", "segment", "none"]).optional(),
   /**
    * `verbatim` keeps fillers and false starts, `clean` removes them.
    * Azure defaults to `verbatim`.
    */
-  transcribeStyle: import_v4.z.enum(["verbatim", "clean"]).optional(),
+  transcribeStyle: import_v44.z.enum(["verbatim", "clean"]).optional(),
   /**
    * Forces a single language, e.g. `['en']`. Omit for automatic language
    * detection and code switching.
    */
-  locales: import_v4.z.array(import_v4.z.string()).length(1).optional(),
+  locales: import_v44.z.array(import_v44.z.string()).length(1).optional(),
   /**
    * Speaker diarization. Speaker IDs are available in provider metadata.
    */
-  diarization: import_v4.z.strictObject({ enabled: import_v4.z.boolean() }).optional(),
+  diarization: import_v44.z.strictObject({ enabled: import_v44.z.boolean() }).optional(),
   /**
    * Keyword biasing for names and domain terminology.
    */
-  phraseList: import_v4.z.strictObject({ phrases: import_v4.z.array(import_v4.z.string()) }).optional()
+  phraseList: import_v44.z.strictObject({ phrases: import_v44.z.array(import_v44.z.string()) }).optional()
 });
-var azureSpeechTranscriptionModelOptions = (0, import_provider_utils.lazySchema)(
-  () => (0, import_provider_utils.zodSchema)(import_v4.z.strictObject(azureSpeechTranscriptionModelOptionsShape()))
+var azureSpeechTranscriptionModelOptions = (0, import_provider_utils4.lazySchema)(
+  () => (0, import_provider_utils4.zodSchema)(import_v44.z.strictObject(azureSpeechTranscriptionModelOptionsShape()))
 );
 
 // src/azure-transcription-model-options.ts
-var azureTranscriptionModelOptions = (0, import_provider_utils2.lazySchema)(
-  () => (0, import_provider_utils2.zodSchema)(
-    import_v42.z.strictObject({
+var azureTranscriptionModelOptions = (0, import_provider_utils5.lazySchema)(
+  () => (0, import_provider_utils5.zodSchema)(
+    import_v45.z.strictObject({
       /**
-       * API to use. Defaults to Speech for MAI-Transcribe-2, OpenAI otherwise.
+       * API to use. Defaults to Speech for MAI-Transcribe models, OpenAI otherwise.
        */
-      api: import_v42.z.enum(["openai", "speech"]).optional(),
+      api: import_v45.z.enum(["openai", "speech"]).optional(),
       ...azureSpeechTranscriptionModelOptionsShape()
     })
   )
 );
-function isMAITranscribe2(modelId) {
-  return modelId.toLowerCase() === "mai-transcribe-2";
+var maiTranscribeModels = /* @__PURE__ */ new Map([
+  ["mai-transcribe-2", { name: "MAI-Transcribe-2", supportsTimestamps: true }],
+  [
+    "mai-transcribe-1.5",
+    { name: "MAI-Transcribe-1.5", supportsTimestamps: false }
+  ]
+]);
+function getMAITranscribeModel(modelId) {
+  return maiTranscribeModels.get(modelId.toLowerCase());
 }
 
 // src/azure-speech-transcription-model.ts
@@ -107,27 +359,28 @@ var AzureSpeechTranscriptionModel = class {
     this.provider = "azure.transcription";
   }
   async doGenerate(options, azureOptions = {}) {
-    var _a, _b;
+    var _a, _b, _c;
     const timestamp = /* @__PURE__ */ new Date();
+    const maiModel = getMAITranscribeModel(this.modelId);
     const formData = new FormData();
     formData.append(
       "audio",
       new Blob(
         [
-          typeof options.audio === "string" ? (0, import_provider_utils3.convertBase64ToUint8Array)(options.audio) : options.audio
+          typeof options.audio === "string" ? (0, import_provider_utils6.convertBase64ToUint8Array)(options.audio) : options.audio
         ],
         { type: options.mediaType }
       ),
-      `audio.${(0, import_provider_utils3.mediaTypeToExtension)(options.mediaType)}`
+      `audio.${(0, import_provider_utils6.mediaTypeToExtension)(options.mediaType)}`
     );
     formData.append(
       "definition",
       JSON.stringify({
         enhancedMode: {
           enabled: true,
-          model: isMAITranscribe2(this.modelId) ? "MAI-Transcribe-2" : this.modelId,
+          model: (_a = maiModel == null ? void 0 : maiModel.name) != null ? _a : this.modelId,
           modelOptions: {
-            timestamps: (_a = azureOptions.timestamps) != null ? _a : "segment",
+            timestamps: (_b = azureOptions.timestamps) != null ? _b : (maiModel == null ? void 0 : maiModel.supportsTimestamps) === false ? void 0 : "segment",
             transcribeStyle: azureOptions.transcribeStyle
           }
         },
@@ -136,22 +389,22 @@ var AzureSpeechTranscriptionModel = class {
         phraseList: azureOptions.phraseList
       })
     );
-    const { value, rawValue, responseHeaders } = await (0, import_provider_utils3.postFormDataToApi)({
+    const { value, rawValue, responseHeaders } = await (0, import_provider_utils6.postFormDataToApi)({
       url: this.config.url(),
-      headers: (0, import_provider_utils3.combineHeaders)(this.config.headers(), options.headers),
+      headers: (0, import_provider_utils6.combineHeaders)(this.config.headers(), options.headers),
       formData,
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
-      failedResponseHandler: (0, import_provider_utils3.createJsonErrorResponseHandler)({
-        errorSchema: import_v43.z.union([
-          import_v43.z.object({ error: import_v43.z.object({ message: import_v43.z.string() }) }),
-          import_v43.z.object({ message: import_v43.z.string() })
+      failedResponseHandler: (0, import_provider_utils6.createJsonErrorResponseHandler)({
+        errorSchema: import_v46.z.union([
+          import_v46.z.object({ error: import_v46.z.object({ message: import_v46.z.string() }) }),
+          import_v46.z.object({ message: import_v46.z.string() })
         ]),
         errorToMessage: (data) => "error" in data ? data.error.message : data.message
       }),
-      successfulResponseHandler: (0, import_provider_utils3.createJsonResponseHandler)(responseSchema)
+      successfulResponseHandler: (0, import_provider_utils6.createJsonResponseHandler)(responseSchema)
     });
-    const phrases = (_b = value.phrases) != null ? _b : [];
+    const phrases = (_c = value.phrases) != null ? _c : [];
     const languages = new Set(
       phrases.flatMap(
         (phrase) => phrase.locale ? [phrase.locale.split("-")[0].toLowerCase()] : []
@@ -185,22 +438,22 @@ var AzureSpeechTranscriptionModel = class {
     };
   }
 };
-var responseSchema = import_v43.z.object({
-  combinedPhrases: import_v43.z.array(import_v43.z.object({ text: import_v43.z.string() })),
-  durationMilliseconds: import_v43.z.number().nullish(),
-  phrases: import_v43.z.array(
-    import_v43.z.object({
-      text: import_v43.z.string(),
-      offsetMilliseconds: import_v43.z.number().nullish(),
-      durationMilliseconds: import_v43.z.number().nullish(),
-      locale: import_v43.z.string().nullish(),
-      speaker: import_v43.z.number().nullish(),
-      confidence: import_v43.z.number().nullish(),
-      words: import_v43.z.array(
-        import_v43.z.object({
-          text: import_v43.z.string(),
-          offsetMilliseconds: import_v43.z.number().nullish(),
-          durationMilliseconds: import_v43.z.number().nullish()
+var responseSchema = import_v46.z.object({
+  combinedPhrases: import_v46.z.array(import_v46.z.object({ text: import_v46.z.string() })),
+  durationMilliseconds: import_v46.z.number().nullish(),
+  phrases: import_v46.z.array(
+    import_v46.z.object({
+      text: import_v46.z.string(),
+      offsetMilliseconds: import_v46.z.number().nullish(),
+      durationMilliseconds: import_v46.z.number().nullish(),
+      locale: import_v46.z.string().nullish(),
+      speaker: import_v46.z.number().nullish(),
+      confidence: import_v46.z.number().nullish(),
+      words: import_v46.z.array(
+        import_v46.z.object({
+          text: import_v46.z.string(),
+          offsetMilliseconds: import_v46.z.number().nullish(),
+          durationMilliseconds: import_v46.z.number().nullish()
         })
       ).nullish()
     })
@@ -208,7 +461,7 @@ var responseSchema = import_v43.z.object({
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.130" : "0.0.0-test";
+var VERSION = true ? "3.0.132" : "0.0.0-test";
 
 // src/azure-openai-provider.ts
 function getAzureOpenAIBaseURLInfo(baseURL) {
@@ -233,20 +486,20 @@ function createAzure(options = {}) {
   var _a;
   const tokenProvider = options.tokenProvider;
   if (options.apiKey && tokenProvider) {
-    throw new import_provider.InvalidArgumentError({
+    throw new import_provider2.InvalidArgumentError({
       argument: "apiKey/tokenProvider",
       message: "Both apiKey and tokenProvider were provided. Please use only one authentication method."
     });
   }
   const getHeaders = (api = "openai") => {
     const authHeaders = tokenProvider ? {} : {
-      [api === "speech" ? "Ocp-Apim-Subscription-Key" : "api-key"]: (0, import_provider_utils4.loadApiKey)({
+      [api === "speech" ? "Ocp-Apim-Subscription-Key" : "api-key"]: (0, import_provider_utils7.loadApiKey)({
         apiKey: options.apiKey,
         environmentVariableName: "AZURE_API_KEY",
         description: api === "speech" ? "Azure Speech" : "Azure OpenAI"
       })
     };
-    return (0, import_provider_utils4.withUserAgentSuffix)(
+    return (0, import_provider_utils7.withUserAgentSuffix)(
       {
         ...authHeaders,
         ...options.headers
@@ -256,7 +509,7 @@ function createAzure(options = {}) {
   };
   const fetch = tokenProvider ? async (input, init) => {
     var _a2;
-    const headers = (0, import_provider_utils4.normalizeHeaders)(init == null ? void 0 : init.headers);
+    const headers = (0, import_provider_utils7.normalizeHeaders)(init == null ? void 0 : init.headers);
     if (headers.authorization == null) {
       headers.authorization = `Bearer ${await tokenProvider()}`;
     }
@@ -265,12 +518,21 @@ function createAzure(options = {}) {
       headers
     });
   } : options.fetch;
-  const getResourceName = () => (0, import_provider_utils4.loadSetting)({
-    settingValue: options.resourceName,
-    settingName: "resourceName",
-    environmentVariableName: "AZURE_RESOURCE_NAME",
-    description: "Azure OpenAI resource name"
-  });
+  const getResourceName = () => {
+    const resourceName = (0, import_provider_utils7.loadSetting)({
+      settingValue: options.resourceName,
+      settingName: "resourceName",
+      environmentVariableName: "AZURE_RESOURCE_NAME",
+      description: "Azure OpenAI resource name"
+    });
+    if (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i.test(resourceName)) {
+      throw new import_provider2.InvalidArgumentError({
+        argument: "resourceName",
+        message: "Invalid Azure resource name. Expected a single DNS label (letters, digits, and hyphens). Use `baseURL` for custom endpoints."
+      });
+    }
+    return resourceName;
+  };
   const apiVersion = (_a = options.apiVersion) != null ? _a : "v1";
   const {
     isAzureOpenAI,
@@ -279,7 +541,7 @@ function createAzure(options = {}) {
   } = getAzureOpenAIBaseURLInfo(options.baseURL);
   const url = ({ path, modelId }) => {
     var _a2;
-    const baseUrlPrefix = (0, import_provider_utils4.withoutTrailingSlash)(
+    const baseUrlPrefix = (0, import_provider_utils7.withoutTrailingSlash)(
       (_a2 = options.baseURL) != null ? _a2 : `https://${getResourceName()}.openai.azure.com/openai`
     );
     let fullUrl;
@@ -337,6 +599,10 @@ function createAzure(options = {}) {
     headers: getHeaders,
     fetch
   });
+  const speechBaseURL = () => {
+    var _a2;
+    return (_a2 = (0, import_provider_utils7.withoutTrailingSlash)(options.speechBaseURL)) != null ? _a2 : `https://${getResourceName()}.cognitiveservices.azure.com`;
+  };
   const createTranscriptionModel = (modelId) => new AzureTranscriptionModel(
     modelId,
     options,
@@ -347,20 +613,25 @@ function createAzure(options = {}) {
       fetch
     }),
     new AzureSpeechTranscriptionModel(modelId, {
-      url: () => {
-        var _a2;
-        return `${(_a2 = (0, import_provider_utils4.withoutTrailingSlash)(options.speechBaseURL)) != null ? _a2 : `https://${getResourceName()}.cognitiveservices.azure.com`}/speechtotext/transcriptions:transcribe?api-version=2025-10-15`;
-      },
+      url: () => `${speechBaseURL()}/speechtotext/transcriptions:transcribe?api-version=2025-10-15`,
+      headers: () => getHeaders("speech"),
+      fetch
+    })
+  );
+  const createSpeechModel = (modelId) => new AzureSpeechModel(
+    modelId,
+    new import_internal2.OpenAISpeechModel(modelId, {
+      provider: "azure.speech",
+      url,
+      headers: getHeaders,
+      fetch
+    }),
+    new AzureSpeechSpeechModel(modelId, {
+      url: () => `${speechBaseURL()}/tts/cognitiveservices/v1`,
       headers: () => getHeaders("speech"),
       fetch
     })
   );
-  const createSpeechModel = (modelId) => new import_internal2.OpenAISpeechModel(modelId, {
-    provider: "azure.speech",
-    url,
-    headers: getHeaders,
-    fetch
-  });
   const provider = function(deploymentId) {
     if (new.target) {
       throw new Error(
@@ -384,6 +655,7 @@ function createAzure(options = {}) {
   provider.transcription = createTranscriptionModel;
   provider.transcriptionModel = createTranscriptionModel;
   provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
   provider.tools = azureOpenaiTools;
   return provider;
 }
@@ -419,14 +691,48 @@ var AzureTranscriptionModel = class {
   }
   async getOptions(providerOptions) {
     var _a;
-    const options = await (0, import_provider_utils4.parseProviderOptions)({
+    const options = await (0, import_provider_utils7.parseProviderOptions)({
       provider: "azure",
       providerOptions,
       schema: azureTranscriptionModelOptions
     });
     return {
       ...options,
-      api: (_a = options == null ? void 0 : options.api) != null ? _a : isMAITranscribe2(this.modelId) ? "speech" : "openai"
+      api: (_a = options == null ? void 0 : options.api) != null ? _a : getMAITranscribeModel(this.modelId) ? "speech" : "openai"
+    };
+  }
+};
+var AzureSpeechModel = class {
+  constructor(modelId, openai, speech) {
+    this.modelId = modelId;
+    this.openai = openai;
+    this.speech = speech;
+    this.specificationVersion = "v3";
+    this.provider = "azure.speech";
+  }
+  async doGenerate(options) {
+    var _a;
+    const { api, ...speechOptions } = (_a = await (0, import_provider_utils7.parseProviderOptions)({
+      provider: "azure",
+      providerOptions: options.providerOptions,
+      schema: azureSpeechModelOptions
+    })) != null ? _a : {};
+    if ((api != null ? api : getMAIVoiceModel(this.modelId) ? "speech" : "openai") === "speech") {
+      return this.speech.doGenerate(options, speechOptions);
+    }
+    const result = await this.openai.doGenerate(options);
+    return {
+      ...result,
+      warnings: [
+        ...result.warnings,
+        ...Object.entries(speechOptions).filter(([, value]) => value !== void 0).map(
+          ([key]) => ({
+            type: "unsupported",
+            feature: `providerOptions.azure.${key}`,
+            details: "This option requires the Azure Speech API."
+          })
+        )
+      ]
     };
   }
 };