@ai-sdk/assemblyai 3.0.3 → 3.0.4

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @ai-sdk/assemblyai
 
+## 3.0.4
+
+### Patch Changes
+
+- ec598e2: feat(assemblyai): support universal-3-5-pro and expand the transcription provider
+
+  - Add current speech models `universal-3-5-pro`, `universal-3-pro`, and
+    `universal-2`, routed via AssemblyAI's `speech_models` parameter (the
+    deprecated singular `speech_model` is used only for the legacy `best` model).
+    Using `universal-3-pro`/`universal-2` emits an informational warning
+    suggesting `universal-3-5-pro`.
+  - Deprecate the legacy `best` model (still works, warns) and remove `nano`,
+    which AssemblyAI no longer accepts.
+  - Surface speaker diarization and audio-intelligence results: `doGenerate` now
+    returns the full raw response on `response.body` and populates
+    `providerMetadata.assemblyai` with `utterances`, `entities`,
+    `sentimentAnalysisResults`, `contentSafetyLabels`, `iabCategoriesResult`, and
+    `autoHighlightsResult`.
+  - Add provider options for newer request parameters: `prompt`, `keytermsPrompt`,
+    `temperature`, `removeAudioTags`, `domain`, `speakerOptions`,
+    `languageDetectionOptions`, `redactPiiAudioOptions`,
+    `redactPiiReturnUnredacted`, and `redactStaticEntities`. Deprecate
+    `wordBoost`/`boostParam` in favor of `keytermsPrompt` (AssemblyAI rejects
+    `word_boost` on the newer models).
+  - Fix transcription segment timings, which were reported in milliseconds instead
+    of seconds.
+
+- Updated dependencies [c6f5e62]
+  - @ai-sdk/provider-utils@5.0.4
+
 ## 3.0.3
 
 ### Patch Changes

package/README.md

@@ -36,7 +36,7 @@ import { assemblyai } from '@ai-sdk/assemblyai';
 import { transcribe } from 'ai';
 
 const { text } = await transcribe({
-  model: assemblyai.transcription('best'),
+  model: assemblyai.transcription('universal-3-5-pro'),
   audio: new URL(
     'https://github.com/vercel/ai/raw/refs/heads/main/examples/ai-functions/data/galileo.mp3',
   ),

package/dist/index.d.ts

@@ -14,7 +14,15 @@ type AssemblyAIConfig = {
     generateId?: () => string;
 };
 
-type AssemblyAITranscriptionModelId = 'best' | 'nano' | (string & {});
+/**
+ * Legacy AssemblyAI speech model, sent via the deprecated singular
+ * `speech_model` request parameter.
+ *
+ * @deprecated Use `universal-3-5-pro` instead.
+ * @see https://www.assemblyai.com/docs/pre-recorded-audio/select-the-speech-model
+ */
+type AssemblyAIDeprecatedTranscriptionModelId = 'best';
+type AssemblyAITranscriptionModelId = 'universal-2' | 'universal-3-pro' | 'universal-3-5-pro' | AssemblyAIDeprecatedTranscriptionModelId | (string & {});
 
 interface AssemblyAITranscriptionModelConfig extends AssemblyAIConfig {
     _internal?: {
@@ -51,7 +59,7 @@ declare class AssemblyAITranscriptionModel implements TranscriptionModelV4 {
 }
 
 interface AssemblyAIProvider extends ProviderV4 {
-    (modelId: 'best', settings?: {}): {
+    (modelId: AssemblyAITranscriptionModelId, settings?: {}): {
         transcription: AssemblyAITranscriptionModel;
     };
     /**
@@ -100,27 +108,53 @@ declare const assemblyaiTranscriptionModelOptionsSchema: z.ZodObject<{
         to: z.ZodString;
     }, z.core.$strip>>>>;
     disfluencies: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    domain: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     entityDetection: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     filterProfanity: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     formatText: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     iabCategories: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    keytermsPrompt: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
     languageCode: z.ZodOptional<z.ZodNullable<z.ZodUnion<readonly [z.ZodLiteral<"en">, z.ZodString]>>>;
     languageConfidenceThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     languageDetection: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    languageDetectionOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        expectedLanguages: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        fallbackLanguage: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        codeSwitching: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        codeSwitchingConfidenceThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
     multichannel: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    prompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     punctuate: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     redactPii: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     redactPiiAudio: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    redactPiiAudioOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        returnRedactedNoSpeechAudio: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        overrideAudioRedactionMethod: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            silence: "silence";
+        }>>>;
+    }, z.core.$strip>>>;
     redactPiiAudioQuality: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     redactPiiPolicies: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    redactPiiReturnUnredacted: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     redactPiiSub: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    redactStaticEntities: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+    removeAudioTags: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        all: "all";
+        speaker: "speaker";
+    }>>>;
     sentimentAnalysis: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     speakerLabels: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    speakerOptions: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        minSpeakersExpected: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        maxSpeakersExpected: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strip>>>;
     speakersExpected: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     speechThreshold: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     summarization: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
     summaryModel: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     summaryType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    temperature: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     webhookAuthHeaderName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     webhookAuthHeaderValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     webhookUrl: z.ZodOptional<z.ZodNullable<z.ZodString>>;

package/dist/index.js

@@ -55,8 +55,12 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    */
   autoHighlights: z2.boolean().nullish(),
   /**
-   * Boost parameter for the transcription.
+   * Boost parameter for word boost (used with `wordBoost`).
    * Allowed values: 'low', 'default', 'high'.
+   *
+   * @deprecated Only applies to the deprecated `wordBoost` option. Use
+   * `keytermsPrompt` instead, which works with the recommended `universal-*`
+   * models.
    */
   boostParam: z2.string().nullish(),
   /**
@@ -80,6 +84,11 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Whether to include filler words (um, uh, etc.) in the transcription.
    */
   disfluencies: z2.boolean().nullish(),
+  /**
+   * Enable a domain-specific model to improve accuracy for specialized
+   * terminology. Currently supports `'medical-v1'` (Medical Mode).
+   */
+  domain: z2.string().nullish(),
   /**
    * Whether to enable entity detection.
    */
@@ -96,6 +105,13 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Whether to enable IAB categories detection.
    */
   iabCategories: z2.boolean().nullish(),
+  /**
+   * Domain-specific keyterms to boost recognition for (max 6 words per phrase).
+   * Replaces `wordBoost` for newer models: supported by `universal-3-pro` /
+   * `universal-3-5-pro` and `slam-1` (and `universal-2` when metaphone is
+   * enabled for the account).
+   */
+  keytermsPrompt: z2.array(z2.string()).nullish(),
   /**
    * Language code for the transcription.
    */
@@ -108,10 +124,28 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Whether to enable language detection.
    */
   languageDetection: z2.boolean().nullish(),
+  /**
+   * Options for automatic language detection.
+   */
+  languageDetectionOptions: z2.object({
+    /** List of languages expected in the audio file. */
+    expectedLanguages: z2.array(z2.string()).nullish(),
+    /** Fallback language if the detected language is not expected. */
+    fallbackLanguage: z2.string().nullish(),
+    /** Whether code switching should be detected. */
+    codeSwitching: z2.boolean().nullish(),
+    /** Confidence threshold for code switching detection (0-1). */
+    codeSwitchingConfidenceThreshold: z2.number().min(0).max(1).nullish()
+  }).nullish(),
   /**
    * Whether to process audio as multichannel.
    */
   multichannel: z2.boolean().nullish(),
+  /**
+   * Provide natural-language context (up to 1,500 words) to steer the model.
+   * Only supported by `universal-3-pro` / `universal-3-5-pro` and `slam-1`.
+   */
+  prompt: z2.string().nullish(),
   /**
    * Whether to add punctuation to the transcription.
    */
@@ -124,6 +158,15 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Whether to redact PII in the audio file.
    */
   redactPiiAudio: z2.boolean().nullish(),
+  /**
+   * Options for PII-redacted audio files. Requires `redactPiiAudio`.
+   */
+  redactPiiAudioOptions: z2.object({
+    /** Return redacted audio even for files without detected speech. */
+    returnRedactedNoSpeechAudio: z2.boolean().nullish(),
+    /** Redaction method; set to `'silence'` to replace PII with silence. */
+    overrideAudioRedactionMethod: z2.enum(["silence"]).nullish()
+  }).nullish(),
   /**
    * Audio format for PII redaction.
    */
@@ -132,10 +175,26 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * List of PII types to redact.
    */
   redactPiiPolicies: z2.array(z2.string()).nullish(),
+  /**
+   * Return the original unredacted transcript alongside the redacted one.
+   * Requires `redactPii`.
+   */
+  redactPiiReturnUnredacted: z2.boolean().nullish(),
   /**
    * Substitution method for redacted PII.
    */
   redactPiiSub: z2.string().nullish(),
+  /**
+   * Map of user-defined labels to exact terms to redact, e.g.
+   * `{ INTERNAL_TOOL: ['Bearclaw'] }`. Applied on top of standard PII redaction
+   * using `redactPiiSub`. Requires `redactPii`.
+   */
+  redactStaticEntities: z2.record(z2.string(), z2.array(z2.string())).nullish(),
+  /**
+   * Remove inline annotations from rich transcripts. `'all'` removes all inline
+   * annotations; `'speaker'` removes only speaker cues. Universal-3 Pro models.
+   */
+  removeAudioTags: z2.enum(["all", "speaker"]).nullish(),
   /**
    * Whether to enable sentiment analysis.
    */
@@ -144,6 +203,15 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Whether to identify different speakers in the audio.
    */
   speakerLabels: z2.boolean().nullish(),
+  /**
+   * Options for speaker diarization, e.g. a range of possible speakers.
+   */
+  speakerOptions: z2.object({
+    /** Minimum number of speakers expected in the audio file. */
+    minSpeakersExpected: z2.number().int().nullish(),
+    /** Maximum number of speakers expected in the audio file. */
+    maxSpeakersExpected: z2.number().int().nullish()
+  }).nullish(),
   /**
    * Number of speakers expected in the audio.
    */
@@ -164,6 +232,10 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
    * Type of summary to generate.
    */
   summaryType: z2.string().nullish(),
+  /**
+   * Sampling temperature (0-1) controlling randomness. Universal-3 Pro models.
+   */
+  temperature: z2.number().min(0).max(1).nullish(),
   /**
    * Name of the authentication header for webhook requests.
    */
@@ -178,6 +250,10 @@ var assemblyaiTranscriptionModelOptionsSchema = z2.object({
   webhookUrl: z2.string().nullish(),
   /**
    * List of words to boost recognition for.
+   *
+   * @deprecated `wordBoost` is rejected by `universal-3-pro` /
+   * `universal-3-5-pro` and `slam-1` (it only works on `universal-2`/`best`).
+   * Use `keytermsPrompt` instead.
    */
   wordBoost: z2.array(z2.string()).nullish()
 });
@@ -205,16 +281,31 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
   async getArgs({
     providerOptions
   }) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F, _G, _H, _I, _J, _K, _L, _M, _N, _O, _P, _Q, _R, _S, _T, _U, _V, _W;
     const warnings = [];
     const assemblyaiOptions = await parseProviderOptions({
       provider: "assemblyai",
       providerOptions,
       schema: assemblyaiTranscriptionModelOptionsSchema
     });
-    const body = {
-      speech_model: this.modelId
-    };
+    const body = {};
+    if (this.modelId === "best") {
+      body.speech_model = this.modelId;
+      warnings.push({
+        type: "deprecated",
+        setting: `model '${this.modelId}'`,
+        message: "The 'best' model is a legacy AssemblyAI model. Use 'universal-3-5-pro' instead. See documentation: https://www.assemblyai.com/docs/pre-recorded-audio/select-the-speech-model"
+      });
+    } else {
+      body.speech_models = [this.modelId];
+      if (this.modelId === "universal-3-pro" || this.modelId === "universal-2") {
+        const docsUrl = "https://www.assemblyai.com/docs/pre-recorded-audio/select-the-speech-model";
+        warnings.push({
+          type: "other",
+          message: this.modelId === "universal-3-pro" ? `'universal-3-5-pro' is AssemblyAI's latest flagship model and is set to replace 'universal-3-pro'. See ${docsUrl}` : `'universal-3-5-pro' is AssemblyAI's latest flagship model. See ${docsUrl}`
+        });
+      }
+    }
     if (assemblyaiOptions) {
       body.audio_end_at = (_a = assemblyaiOptions.audioEndAt) != null ? _a : void 0;
       body.audio_start_from = (_b = assemblyaiOptions.audioStartFrom) != null ? _b : void 0;
@@ -250,6 +341,65 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
       body.webhook_auth_header_value = (_F = assemblyaiOptions.webhookAuthHeaderValue) != null ? _F : void 0;
       body.webhook_url = (_G = assemblyaiOptions.webhookUrl) != null ? _G : void 0;
       body.word_boost = (_H = assemblyaiOptions.wordBoost) != null ? _H : void 0;
+      body.keyterms_prompt = (_I = assemblyaiOptions.keytermsPrompt) != null ? _I : void 0;
+      body.prompt = (_J = assemblyaiOptions.prompt) != null ? _J : void 0;
+      body.temperature = (_K = assemblyaiOptions.temperature) != null ? _K : void 0;
+      body.remove_audio_tags = (_L = assemblyaiOptions.removeAudioTags) != null ? _L : void 0;
+      body.domain = (_M = assemblyaiOptions.domain) != null ? _M : void 0;
+      body.redact_pii_return_unredacted = (_N = assemblyaiOptions.redactPiiReturnUnredacted) != null ? _N : void 0;
+      body.redact_static_entities = (_O = assemblyaiOptions.redactStaticEntities) != null ? _O : void 0;
+      if (assemblyaiOptions.speakerOptions) {
+        body.speaker_options = {
+          min_speakers_expected: (_P = assemblyaiOptions.speakerOptions.minSpeakersExpected) != null ? _P : void 0,
+          max_speakers_expected: (_Q = assemblyaiOptions.speakerOptions.maxSpeakersExpected) != null ? _Q : void 0
+        };
+      }
+      if (assemblyaiOptions.languageDetectionOptions) {
+        body.language_detection_options = {
+          expected_languages: (_R = assemblyaiOptions.languageDetectionOptions.expectedLanguages) != null ? _R : void 0,
+          fallback_language: (_S = assemblyaiOptions.languageDetectionOptions.fallbackLanguage) != null ? _S : void 0,
+          code_switching: (_T = assemblyaiOptions.languageDetectionOptions.codeSwitching) != null ? _T : void 0,
+          code_switching_confidence_threshold: (_U = assemblyaiOptions.languageDetectionOptions.codeSwitchingConfidenceThreshold) != null ? _U : void 0
+        };
+      }
+      if (assemblyaiOptions.redactPiiAudioOptions) {
+        body.redact_pii_audio_options = {
+          return_redacted_no_speech_audio: (_V = assemblyaiOptions.redactPiiAudioOptions.returnRedactedNoSpeechAudio) != null ? _V : void 0,
+          override_audio_redaction_method: (_W = assemblyaiOptions.redactPiiAudioOptions.overrideAudioRedactionMethod) != null ? _W : void 0
+        };
+      }
+      const deprecatedBoostOptions = [];
+      if (assemblyaiOptions.wordBoost != null) {
+        deprecatedBoostOptions.push("wordBoost");
+      }
+      if (assemblyaiOptions.boostParam != null) {
+        deprecatedBoostOptions.push("boostParam");
+      }
+      if (deprecatedBoostOptions.length > 0) {
+        warnings.push({
+          type: "deprecated",
+          setting: deprecatedBoostOptions.join(", "),
+          message: "'wordBoost' and 'boostParam' are deprecated and are rejected by 'universal-3-pro' / 'universal-3-5-pro' and 'slam-1'. Use 'keytermsPrompt' instead."
+        });
+      }
+      if ((assemblyaiOptions.redactPiiReturnUnredacted != null || assemblyaiOptions.redactStaticEntities != null) && !assemblyaiOptions.redactPii) {
+        warnings.push({
+          type: "other",
+          message: "'redactPiiReturnUnredacted' and 'redactStaticEntities' require 'redactPii' to be enabled; AssemblyAI rejects the request otherwise."
+        });
+      }
+      if (assemblyaiOptions.redactPiiAudioOptions != null && !assemblyaiOptions.redactPiiAudio) {
+        warnings.push({
+          type: "other",
+          message: "'redactPiiAudioOptions' only applies when 'redactPiiAudio' is enabled; it is otherwise ignored."
+        });
+      }
+      if (assemblyaiOptions.languageCode != null && assemblyaiOptions.languageDetection) {
+        warnings.push({
+          type: "other",
+          message: "'languageDetection' cannot be combined with an explicit 'languageCode'; AssemblyAI rejects requests that set both."
+        });
+      }
     }
     return {
       body,
@@ -262,13 +412,14 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
    * @see https://www.assemblyai.com/docs/getting-started/transcribe-an-audio-file#step-33
    */
   async waitForCompletion(transcriptId, headers, abortSignal) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     const pollingInterval = (_a = this.config.pollingInterval) != null ? _a : this.POLLING_INTERVAL_MS;
+    const fetchImpl = (_b = this.config.fetch) != null ? _b : globalThis.fetch;
     while (true) {
       if (abortSignal == null ? void 0 : abortSignal.aborted) {
         throw new Error("Transcription request was aborted");
       }
-      const response = await fetch(
+      const response = await fetchImpl(
         this.config.url({
           path: `/v2/transcript/${transcriptId}`,
           modelId: this.modelId
@@ -276,7 +427,7 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
         {
           method: "GET",
           headers: combineHeaders(
-            (_c = (_b = this.config).headers) == null ? void 0 : _c.call(_b),
+            (_d = (_c = this.config).headers) == null ? void 0 : _d.call(_c),
             headers
           ),
           signal: abortSignal
@@ -292,25 +443,25 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
           requestBodyValues: {}
         });
       }
-      const transcript = assemblyaiTranscriptionResponseSchema.parse(
-        await response.json()
-      );
+      const rawTranscript = await response.json();
+      const transcript = assemblyaiTranscriptionResponseSchema.parse(rawTranscript);
       if (transcript.status === "completed") {
         return {
           transcript,
+          rawTranscript,
           responseHeaders: extractResponseHeaders(response)
         };
       }
       if (transcript.status === "error") {
         throw new Error(
-          `Transcription failed: ${(_d = transcript.error) != null ? _d : "Unknown error"}`
+          `Transcription failed: ${(_e = transcript.error) != null ? _e : "Unknown error"}`
         );
       }
       await new Promise((resolve) => setTimeout(resolve, pollingInterval));
     }
   }
   async doGenerate(options) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     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 { value: uploadResponse } = await postToApi({
       url: this.config.url({
@@ -350,28 +501,56 @@ var AssemblyAITranscriptionModel = class _AssemblyAITranscriptionModel {
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
-    const { transcript, responseHeaders } = await this.waitForCompletion(
+    const { transcript, rawTranscript, responseHeaders } = await this.waitForCompletion(
       submitResponse.id,
       options.headers,
       options.abortSignal
     );
+    const raw = rawTranscript != null ? rawTranscript : {};
+    const assemblyaiMetadata = {};
+    if (transcript.utterances != null) {
+      assemblyaiMetadata.utterances = raw.utterances;
+    }
+    if (transcript.sentiment_analysis_results != null) {
+      assemblyaiMetadata.sentimentAnalysisResults = raw.sentiment_analysis_results;
+    }
+    if (transcript.entities != null) {
+      assemblyaiMetadata.entities = raw.entities;
+    }
+    if (transcript.content_safety_labels != null) {
+      assemblyaiMetadata.contentSafetyLabels = raw.content_safety_labels;
+    }
+    if (transcript.iab_categories_result != null) {
+      assemblyaiMetadata.iabCategoriesResult = raw.iab_categories_result;
+    }
+    if (transcript.auto_highlights_result != null) {
+      assemblyaiMetadata.autoHighlightsResult = raw.auto_highlights_result;
+    }
+    const lastWordEndMs = (_i = (_h = transcript.words) == null ? void 0 : _h.at(-1)) == null ? void 0 : _i.end;
     return {
-      text: (_h = transcript.text) != null ? _h : "",
-      segments: (_j = (_i = transcript.words) == null ? void 0 : _i.map((word) => ({
+      text: (_j = transcript.text) != null ? _j : "",
+      // AssemblyAI returns word timings in milliseconds; the AI SDK reports
+      // segment timings in seconds.
+      segments: (_l = (_k = transcript.words) == null ? void 0 : _k.map((word) => ({
         text: word.text,
-        startSecond: word.start,
-        endSecond: word.end
-      }))) != null ? _j : [],
-      language: (_k = transcript.language_code) != null ? _k : void 0,
-      durationInSeconds: (_o = (_n = transcript.audio_duration) != null ? _n : (_m = (_l = transcript.words) == null ? void 0 : _l.at(-1)) == null ? void 0 : _m.end) != null ? _o : void 0,
+        startSecond: word.start / 1e3,
+        endSecond: word.end / 1e3
+      }))) != null ? _l : [],
+      language: (_m = transcript.language_code) != null ? _m : void 0,
+      durationInSeconds: (_n = transcript.audio_duration) != null ? _n : lastWordEndMs != null ? lastWordEndMs / 1e3 : void 0,
       warnings,
+      ...Object.keys(assemblyaiMetadata).length > 0 && {
+        providerMetadata: {
+          assemblyai: assemblyaiMetadata
+        }
+      },
       response: {
         timestamp: currentDate,
         modelId: this.modelId,
         headers: responseHeaders,
         // Headers from final GET request
-        body: transcript
-        // Raw response from final GET request
+        body: rawTranscript
+        // Full raw response from final GET request
       }
     };
   }
@@ -383,24 +562,64 @@ var assemblyaiSubmitResponseSchema = z3.object({
   id: z3.string(),
   status: z3.enum(["queued", "processing", "completed", "error"])
 });
+var assemblyaiWordSchema = z3.object({
+  start: z3.number(),
+  end: z3.number(),
+  text: z3.string(),
+  confidence: z3.number().nullish(),
+  // Speaker label (e.g. 'A', 'B') when speaker diarization is enabled, else null.
+  speaker: z3.string().nullish(),
+  channel: z3.string().nullish()
+});
 var assemblyaiTranscriptionResponseSchema = z3.object({
   id: z3.string(),
   status: z3.enum(["queued", "processing", "completed", "error"]),
   text: z3.string().nullish(),
   language_code: z3.string().nullish(),
-  words: z3.array(
+  speech_model_used: z3.string().nullish(),
+  words: z3.array(assemblyaiWordSchema).nullish(),
+  // Speaker-diarized utterances (present when `speaker_labels` is enabled).
+  utterances: z3.array(
     z3.object({
       start: z3.number(),
       end: z3.number(),
-      text: z3.string()
+      text: z3.string(),
+      confidence: z3.number().nullish(),
+      speaker: z3.string().nullish(),
+      channel: z3.string().nullish(),
+      words: z3.array(assemblyaiWordSchema).nullish()
+    })
+  ).nullish(),
+  // Audio-intelligence results, present only when the matching feature is
+  // enabled. Kept intentionally permissive (the full structures are also
+  // available on the raw `response.body`).
+  sentiment_analysis_results: z3.array(
+    z3.object({
+      text: z3.string(),
+      start: z3.number().nullish(),
+      end: z3.number().nullish(),
+      sentiment: z3.string(),
+      confidence: z3.number().nullish(),
+      speaker: z3.string().nullish()
+    })
+  ).nullish(),
+  entities: z3.array(
+    z3.object({
+      entity_type: z3.string(),
+      text: z3.string(),
+      start: z3.number().nullish(),
+      end: z3.number().nullish()
     })
   ).nullish(),
+  content_safety_labels: z3.record(z3.string(), z3.any()).nullish(),
+  iab_categories_result: z3.record(z3.string(), z3.any()).nullish(),
+  auto_highlights_result: z3.record(z3.string(), z3.any()).nullish(),
   audio_duration: z3.number().nullish(),
   error: z3.string().nullish()
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.3" : "0.0.0-test";
+var VERSION = true ? "3.0.4" : "0.0.0-test";
 
 // src/assemblyai-provider.ts
 function createAssemblyAI(options = {}) {