@ai-sdk/azure 3.0.130 → 3.0.132

package/dist/index.mjs

@@ -37,73 +37,339 @@ var azureOpenaiTools = {
   webSearchPreview
 };
 
-// src/azure-speech-transcription-model.ts
+// src/azure-speech-model-options.ts
+import {
+  lazySchema as lazySchema2,
+  zodSchema as zodSchema2
+} from "@ai-sdk/provider-utils";
+import { z as z2 } from "zod/v4";
+
+// src/azure-speech-speech-model-options.ts
+import {
+  lazySchema,
+  zodSchema
+} from "@ai-sdk/provider-utils";
+import { z } from "zod/v4";
+var azureSpeechSpeechModelOptionsShape = () => ({
+  /**
+   * Speaking style applied with `mstts:express-as`, e.g. `excited` or
+   * `whispering`. Supported styles vary by voice.
+   */
+  style: z.string().min(1).optional(),
+  /**
+   * Intensity of `style`, from 0.01 to 2. Azure defaults to 1.
+   */
+  styleDegree: z.number().min(0.01).max(2).optional()
+});
+var azureSpeechSpeechModelOptions = lazySchema(
+  () => zodSchema(z.strictObject(azureSpeechSpeechModelOptionsShape()))
+);
+
+// src/azure-speech-model-options.ts
+var azureSpeechModelOptions = lazySchema2(
+  () => zodSchema2(
+    z2.strictObject({
+      /**
+       * API to use. Defaults to Speech for MAI-Voice models, OpenAI otherwise.
+       */
+      api: z2.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
+import {
+  APICallError
+} from "@ai-sdk/provider";
 import {
   combineHeaders,
+  createBinaryResponseHandler,
+  extractResponseHeaders,
+  postToApi,
+  safeParseJSON
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "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 postToApi({
+      url: this.config.url(),
+      headers: combineHeaders(
+        this.config.headers(),
+        {
+          "Content-Type": "application/ssml+xml",
+          "X-Microsoft-OutputFormat": outputFormat
+        },
+        options.headers
+      ),
+      body: { content: ssml, values: ssml },
+      failedResponseHandler,
+      successfulResponseHandler: 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 = z3.object({
+  error: z3.object({ message: z3.string() })
+});
+var failedResponseHandler = async ({
+  response,
+  url,
+  requestBodyValues
+}) => {
+  const responseHeaders = extractResponseHeaders(response);
+  const responseBody = await response.text();
+  const parsed = await 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 APICallError({
+      message,
+      url,
+      requestBodyValues,
+      statusCode: response.status,
+      responseHeaders,
+      responseBody
+    })
+  };
+};
+
+// src/azure-speech-transcription-model.ts
+import {
+  combineHeaders as combineHeaders2,
   convertBase64ToUint8Array,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   mediaTypeToExtension,
   postFormDataToApi
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 
 // src/azure-transcription-model-options.ts
 import {
-  lazySchema as lazySchema2,
-  zodSchema as zodSchema2
+  lazySchema as lazySchema4,
+  zodSchema as zodSchema4
 } from "@ai-sdk/provider-utils";
-import { z as z2 } from "zod/v4";
+import { z as z5 } from "zod/v4";
 
 // src/azure-speech-transcription-model-options.ts
 import {
-  lazySchema,
-  zodSchema
+  lazySchema as lazySchema3,
+  zodSchema as zodSchema3
 } from "@ai-sdk/provider-utils";
-import { z } from "zod/v4";
+import { z as z4 } from "zod/v4";
 var azureSpeechTranscriptionModelOptionsShape = () => ({
   /**
    * Timing granularity. Defaults to `segment` so that transcription results
    * include timed segments (Azure's own default is `none`).
    */
-  timestamps: z.enum(["word", "segment", "none"]).optional(),
+  timestamps: z4.enum(["word", "segment", "none"]).optional(),
   /**
    * `verbatim` keeps fillers and false starts, `clean` removes them.
    * Azure defaults to `verbatim`.
    */
-  transcribeStyle: z.enum(["verbatim", "clean"]).optional(),
+  transcribeStyle: z4.enum(["verbatim", "clean"]).optional(),
   /**
    * Forces a single language, e.g. `['en']`. Omit for automatic language
    * detection and code switching.
    */
-  locales: z.array(z.string()).length(1).optional(),
+  locales: z4.array(z4.string()).length(1).optional(),
   /**
    * Speaker diarization. Speaker IDs are available in provider metadata.
    */
-  diarization: z.strictObject({ enabled: z.boolean() }).optional(),
+  diarization: z4.strictObject({ enabled: z4.boolean() }).optional(),
   /**
    * Keyword biasing for names and domain terminology.
    */
-  phraseList: z.strictObject({ phrases: z.array(z.string()) }).optional()
+  phraseList: z4.strictObject({ phrases: z4.array(z4.string()) }).optional()
 });
-var azureSpeechTranscriptionModelOptions = lazySchema(
-  () => zodSchema(z.strictObject(azureSpeechTranscriptionModelOptionsShape()))
+var azureSpeechTranscriptionModelOptions = lazySchema3(
+  () => zodSchema3(z4.strictObject(azureSpeechTranscriptionModelOptionsShape()))
 );
 
 // src/azure-transcription-model-options.ts
-var azureTranscriptionModelOptions = lazySchema2(
-  () => zodSchema2(
-    z2.strictObject({
+var azureTranscriptionModelOptions = lazySchema4(
+  () => zodSchema4(
+    z5.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: z2.enum(["openai", "speech"]).optional(),
+      api: z5.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
@@ -115,8 +381,9 @@ 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",
@@ -133,9 +400,9 @@ var AzureSpeechTranscriptionModel = class {
       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
           }
         },
@@ -146,20 +413,20 @@ var AzureSpeechTranscriptionModel = class {
     );
     const { value, rawValue, responseHeaders } = await postFormDataToApi({
       url: this.config.url(),
-      headers: combineHeaders(this.config.headers(), options.headers),
+      headers: combineHeaders2(this.config.headers(), options.headers),
       formData,
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: z3.union([
-          z3.object({ error: z3.object({ message: z3.string() }) }),
-          z3.object({ message: z3.string() })
+        errorSchema: z6.union([
+          z6.object({ error: z6.object({ message: z6.string() }) }),
+          z6.object({ message: z6.string() })
         ]),
         errorToMessage: (data) => "error" in data ? data.error.message : data.message
       }),
       successfulResponseHandler: 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()] : []
@@ -193,22 +460,22 @@ var AzureSpeechTranscriptionModel = class {
     };
   }
 };
-var responseSchema = z3.object({
-  combinedPhrases: z3.array(z3.object({ text: z3.string() })),
-  durationMilliseconds: z3.number().nullish(),
-  phrases: z3.array(
-    z3.object({
-      text: z3.string(),
-      offsetMilliseconds: z3.number().nullish(),
-      durationMilliseconds: z3.number().nullish(),
-      locale: z3.string().nullish(),
-      speaker: z3.number().nullish(),
-      confidence: z3.number().nullish(),
-      words: z3.array(
-        z3.object({
-          text: z3.string(),
-          offsetMilliseconds: z3.number().nullish(),
-          durationMilliseconds: z3.number().nullish()
+var responseSchema = z6.object({
+  combinedPhrases: z6.array(z6.object({ text: z6.string() })),
+  durationMilliseconds: z6.number().nullish(),
+  phrases: z6.array(
+    z6.object({
+      text: z6.string(),
+      offsetMilliseconds: z6.number().nullish(),
+      durationMilliseconds: z6.number().nullish(),
+      locale: z6.string().nullish(),
+      speaker: z6.number().nullish(),
+      confidence: z6.number().nullish(),
+      words: z6.array(
+        z6.object({
+          text: z6.string(),
+          offsetMilliseconds: z6.number().nullish(),
+          durationMilliseconds: z6.number().nullish()
         })
       ).nullish()
     })
@@ -216,7 +483,7 @@ var responseSchema = z3.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) {
@@ -273,12 +540,21 @@ function createAzure(options = {}) {
       headers
     });
   } : options.fetch;
-  const getResourceName = () => loadSetting({
-    settingValue: options.resourceName,
-    settingName: "resourceName",
-    environmentVariableName: "AZURE_RESOURCE_NAME",
-    description: "Azure OpenAI resource name"
-  });
+  const getResourceName = () => {
+    const resourceName = 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 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,
@@ -345,6 +621,10 @@ function createAzure(options = {}) {
     headers: getHeaders,
     fetch
   });
+  const speechBaseURL = () => {
+    var _a2;
+    return (_a2 = withoutTrailingSlash(options.speechBaseURL)) != null ? _a2 : `https://${getResourceName()}.cognitiveservices.azure.com`;
+  };
   const createTranscriptionModel = (modelId) => new AzureTranscriptionModel(
     modelId,
     options,
@@ -355,20 +635,25 @@ function createAzure(options = {}) {
       fetch
     }),
     new AzureSpeechTranscriptionModel(modelId, {
-      url: () => {
-        var _a2;
-        return `${(_a2 = 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 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 OpenAISpeechModel(modelId, {
-    provider: "azure.speech",
-    url,
-    headers: getHeaders,
-    fetch
-  });
   const provider = function(deploymentId) {
     if (new.target) {
       throw new Error(
@@ -392,6 +677,7 @@ function createAzure(options = {}) {
   provider.transcription = createTranscriptionModel;
   provider.transcriptionModel = createTranscriptionModel;
   provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
   provider.tools = azureOpenaiTools;
   return provider;
 }
@@ -434,7 +720,41 @@ var AzureTranscriptionModel = class {
     });
     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 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."
+          })
+        )
+      ]
     };
   }
 };