@ai-sdk/gladia 3.0.0-beta.3 → 3.0.0-beta.31

package/dist/index.js

@@ -1,321 +1,325 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  VERSION: () => VERSION,
-  createGladia: () => createGladia,
-  gladia: () => gladia
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/gladia-provider.ts
-var import_provider2 = require("@ai-sdk/provider");
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+import {
+  NoSuchModelError
+} from "@ai-sdk/provider";
+import {
+  loadApiKey,
+  withUserAgentSuffix
+} from "@ai-sdk/provider-utils";
 
 // src/gladia-transcription-model.ts
-var import_provider = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_v42 = require("zod/v4");
+import {
+  AISDKError
+} from "@ai-sdk/provider";
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  mediaTypeToExtension,
+  delay,
+  getFromApi,
+  parseProviderOptions,
+  postFormDataToApi,
+  postJsonToApi,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE
+} from "@ai-sdk/provider-utils";
+import { z as z3 } from "zod/v4";
 
 // src/gladia-error.ts
-var import_v4 = require("zod/v4");
-var import_provider_utils = require("@ai-sdk/provider-utils");
-var gladiaErrorDataSchema = import_v4.z.object({
-  error: import_v4.z.object({
-    message: import_v4.z.string(),
-    code: import_v4.z.number()
+import { z } from "zod/v4";
+import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils";
+var gladiaErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.number()
   })
 });
-var gladiaFailedResponseHandler = (0, import_provider_utils.createJsonErrorResponseHandler)({
+var gladiaFailedResponseHandler = createJsonErrorResponseHandler({
   errorSchema: gladiaErrorDataSchema,
   errorToMessage: (data) => data.error.message
 });
 
-// src/gladia-transcription-model.ts
-var gladiaTranscriptionModelOptionsSchema = import_v42.z.object({
+// src/gladia-transcription-model-options.ts
+import { z as z2 } from "zod/v4";
+var gladiaTranscriptionModelOptionsSchema = z2.object({
   /**
    * Optional context prompt to guide the transcription.
    */
-  contextPrompt: import_v42.z.string().nullish(),
+  contextPrompt: z2.string().nullish(),
   /**
    * Custom vocabulary to improve transcription accuracy.
    * Can be a boolean or an array of custom terms.
    */
-  customVocabulary: import_v42.z.union([import_v42.z.boolean(), import_v42.z.array(import_v42.z.any())]).nullish(),
+  customVocabulary: z2.union([z2.boolean(), z2.array(z2.any())]).nullish(),
   /**
    * Configuration for custom vocabulary.
    */
-  customVocabularyConfig: import_v42.z.object({
+  customVocabularyConfig: z2.object({
     /**
      * Array of vocabulary terms or objects with pronunciation details.
      */
-    vocabulary: import_v42.z.array(
-      import_v42.z.union([
-        import_v42.z.string(),
-        import_v42.z.object({
+    vocabulary: z2.array(
+      z2.union([
+        z2.string(),
+        z2.object({
           /**
            * The vocabulary term.
            */
-          value: import_v42.z.string(),
+          value: z2.string(),
           /**
            * Intensity of the term in recognition (optional).
            */
-          intensity: import_v42.z.number().nullish(),
+          intensity: z2.number().nullish(),
           /**
            * Alternative pronunciations for the term (optional).
            */
-          pronunciations: import_v42.z.array(import_v42.z.string()).nullish(),
+          pronunciations: z2.array(z2.string()).nullish(),
           /**
            * Language of the term (optional).
            */
-          language: import_v42.z.string().nullish()
+          language: z2.string().nullish()
         })
       ])
     ),
     /**
      * Default intensity for all vocabulary terms.
      */
-    defaultIntensity: import_v42.z.number().nullish()
+    defaultIntensity: z2.number().nullish()
   }).nullish(),
   /**
    * Whether to automatically detect the language of the audio.
    */
-  detectLanguage: import_v42.z.boolean().nullish(),
+  detectLanguage: z2.boolean().nullish(),
   /**
    * Whether to enable code switching (multiple languages in the same audio).
    */
-  enableCodeSwitching: import_v42.z.boolean().nullish(),
+  enableCodeSwitching: z2.boolean().nullish(),
   /**
    * Configuration for code switching.
    */
-  codeSwitchingConfig: import_v42.z.object({
+  codeSwitchingConfig: z2.object({
     /**
      * Languages to consider for code switching.
      */
-    languages: import_v42.z.array(import_v42.z.string()).nullish()
+    languages: z2.array(z2.string()).nullish()
   }).nullish(),
   /**
    * Specific language for transcription.
    */
-  language: import_v42.z.string().nullish(),
+  language: z2.string().nullish(),
   /**
    * Whether to enable callback when transcription is complete.
    */
-  callback: import_v42.z.boolean().nullish(),
+  callback: z2.boolean().nullish(),
   /**
    * Configuration for callback.
    */
-  callbackConfig: import_v42.z.object({
+  callbackConfig: z2.object({
     /**
      * URL to send the callback to.
      */
-    url: import_v42.z.string(),
+    url: z2.string(),
     /**
      * HTTP method for the callback.
      */
-    method: import_v42.z.enum(["POST", "PUT"]).nullish()
+    method: z2.enum(["POST", "PUT"]).nullish()
   }).nullish(),
   /**
    * Whether to generate subtitles.
    */
-  subtitles: import_v42.z.boolean().nullish(),
+  subtitles: z2.boolean().nullish(),
   /**
    * Configuration for subtitles generation.
    */
-  subtitlesConfig: import_v42.z.object({
+  subtitlesConfig: z2.object({
     /**
      * Subtitle file formats to generate.
      */
-    formats: import_v42.z.array(import_v42.z.enum(["srt", "vtt"])).nullish(),
+    formats: z2.array(z2.enum(["srt", "vtt"])).nullish(),
     /**
      * Minimum duration for subtitle segments.
      */
-    minimumDuration: import_v42.z.number().nullish(),
+    minimumDuration: z2.number().nullish(),
     /**
      * Maximum duration for subtitle segments.
      */
-    maximumDuration: import_v42.z.number().nullish(),
+    maximumDuration: z2.number().nullish(),
     /**
      * Maximum characters per row in subtitles.
      */
-    maximumCharactersPerRow: import_v42.z.number().nullish(),
+    maximumCharactersPerRow: z2.number().nullish(),
     /**
      * Maximum rows per caption in subtitles.
      */
-    maximumRowsPerCaption: import_v42.z.number().nullish(),
+    maximumRowsPerCaption: z2.number().nullish(),
     /**
      * Style of subtitles.
      */
-    style: import_v42.z.enum(["default", "compliance"]).nullish()
+    style: z2.enum(["default", "compliance"]).nullish()
   }).nullish(),
   /**
    * Whether to enable speaker diarization (speaker identification).
    */
-  diarization: import_v42.z.boolean().nullish(),
+  diarization: z2.boolean().nullish(),
   /**
    * Configuration for diarization.
    */
-  diarizationConfig: import_v42.z.object({
+  diarizationConfig: z2.object({
     /**
      * Exact number of speakers to identify.
      */
-    numberOfSpeakers: import_v42.z.number().nullish(),
+    numberOfSpeakers: z2.number().nullish(),
     /**
      * Minimum number of speakers to identify.
      */
-    minSpeakers: import_v42.z.number().nullish(),
+    minSpeakers: z2.number().nullish(),
     /**
      * Maximum number of speakers to identify.
      */
-    maxSpeakers: import_v42.z.number().nullish(),
+    maxSpeakers: z2.number().nullish(),
     /**
      * Whether to use enhanced diarization.
      */
-    enhanced: import_v42.z.boolean().nullish()
+    enhanced: z2.boolean().nullish()
   }).nullish(),
   /**
    * Whether to translate the transcription.
    */
-  translation: import_v42.z.boolean().nullish(),
+  translation: z2.boolean().nullish(),
   /**
    * Configuration for translation.
    */
-  translationConfig: import_v42.z.object({
+  translationConfig: z2.object({
     /**
      * Target languages for translation.
      */
-    targetLanguages: import_v42.z.array(import_v42.z.string()),
+    targetLanguages: z2.array(z2.string()),
     /**
      * Translation model to use.
      */
-    model: import_v42.z.enum(["base", "enhanced"]).nullish(),
+    model: z2.enum(["base", "enhanced"]).nullish(),
     /**
      * Whether to match original utterances in translation.
      */
-    matchOriginalUtterances: import_v42.z.boolean().nullish()
+    matchOriginalUtterances: z2.boolean().nullish()
   }).nullish(),
   /**
    * Whether to generate a summary of the transcription.
    */
-  summarization: import_v42.z.boolean().nullish(),
+  summarization: z2.boolean().nullish(),
   /**
    * Configuration for summarization.
    */
-  summarizationConfig: import_v42.z.object({
+  summarizationConfig: z2.object({
     /**
      * Type of summary to generate.
      */
-    type: import_v42.z.enum(["general", "bullet_points", "concise"]).nullish()
+    type: z2.enum(["general", "bullet_points", "concise"]).nullish()
   }).nullish(),
   /**
    * Whether to enable content moderation.
    */
-  moderation: import_v42.z.boolean().nullish(),
+  moderation: z2.boolean().nullish(),
   /**
    * Whether to enable named entity recognition.
    */
-  namedEntityRecognition: import_v42.z.boolean().nullish(),
+  namedEntityRecognition: z2.boolean().nullish(),
   /**
    * Whether to enable automatic chapter creation.
    */
-  chapterization: import_v42.z.boolean().nullish(),
+  chapterization: z2.boolean().nullish(),
   /**
    * Whether to ensure consistent naming of entities.
    */
-  nameConsistency: import_v42.z.boolean().nullish(),
+  nameConsistency: z2.boolean().nullish(),
   /**
    * Whether to enable custom spelling.
    */
-  customSpelling: import_v42.z.boolean().nullish(),
+  customSpelling: z2.boolean().nullish(),
   /**
    * Configuration for custom spelling.
    */
-  customSpellingConfig: import_v42.z.object({
+  customSpellingConfig: z2.object({
     /**
      * Dictionary of custom spellings.
      */
-    spellingDictionary: import_v42.z.record(import_v42.z.string(), import_v42.z.array(import_v42.z.string()))
+    spellingDictionary: z2.record(z2.string(), z2.array(z2.string()))
   }).nullish(),
   /**
    * Whether to extract structured data from the transcription.
    */
-  structuredDataExtraction: import_v42.z.boolean().nullish(),
+  structuredDataExtraction: z2.boolean().nullish(),
   /**
    * Configuration for structured data extraction.
    */
-  structuredDataExtractionConfig: import_v42.z.object({
+  structuredDataExtractionConfig: z2.object({
     /**
      * Classes of data to extract.
      */
-    classes: import_v42.z.array(import_v42.z.string())
+    classes: z2.array(z2.string())
   }).nullish(),
   /**
    * Whether to perform sentiment analysis on the transcription.
    */
-  sentimentAnalysis: import_v42.z.boolean().nullish(),
+  sentimentAnalysis: z2.boolean().nullish(),
   /**
    * Whether to send audio to a language model for processing.
    */
-  audioToLlm: import_v42.z.boolean().nullish(),
+  audioToLlm: z2.boolean().nullish(),
   /**
    * Configuration for audio to language model processing.
    */
-  audioToLlmConfig: import_v42.z.object({
+  audioToLlmConfig: z2.object({
     /**
      * Prompts to send to the language model.
      */
-    prompts: import_v42.z.array(import_v42.z.string())
+    prompts: z2.array(z2.string())
   }).nullish(),
   /**
    * Custom metadata to include with the transcription.
    */
-  customMetadata: import_v42.z.record(import_v42.z.string(), import_v42.z.any()).nullish(),
+  customMetadata: z2.record(z2.string(), z2.any()).nullish(),
   /**
    * Whether to include sentence-level segmentation.
    */
-  sentences: import_v42.z.boolean().nullish(),
+  sentences: z2.boolean().nullish(),
   /**
    * Whether to enable display mode.
    */
-  displayMode: import_v42.z.boolean().nullish(),
+  displayMode: z2.boolean().nullish(),
   /**
    * Whether to enhance punctuation in the transcription.
    */
-  punctuationEnhanced: import_v42.z.boolean().nullish()
+  punctuationEnhanced: z2.boolean().nullish()
 });
-var GladiaTranscriptionModel = class {
+
+// src/gladia-transcription-model.ts
+var GladiaTranscriptionModel = class _GladiaTranscriptionModel {
   constructor(modelId, config) {
     this.modelId = modelId;
     this.config = config;
-    this.specificationVersion = "v3";
+    this.specificationVersion = "v4";
   }
   get provider() {
     return this.config.provider;
   }
+  static [WORKFLOW_SERIALIZE](model) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config
+    });
+  }
+  static [WORKFLOW_DESERIALIZE](options) {
+    return new _GladiaTranscriptionModel(options.modelId, options.config);
+  }
   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, _I, _J, _K, _L, _M, _N;
     const warnings = [];
-    const gladiaOptions = await (0, import_provider_utils2.parseProviderOptions)({
+    const gladiaOptions = await parseProviderOptions({
       provider: "gladia",
       providerOptions,
       schema: gladiaTranscriptionModelOptionsSchema
@@ -416,43 +420,43 @@ var GladiaTranscriptionModel = class {
     };
   }
   async doGenerate(options) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
     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 formData = new FormData();
-    const blob = options.audio instanceof Uint8Array ? new Blob([options.audio]) : new Blob([(0, import_provider_utils2.convertBase64ToUint8Array)(options.audio)]);
-    const fileExtension = (0, import_provider_utils2.mediaTypeToExtension)(options.mediaType);
+    const blob = options.audio instanceof Uint8Array ? new Blob([options.audio]) : new Blob([convertBase64ToUint8Array(options.audio)]);
+    const fileExtension = mediaTypeToExtension(options.mediaType);
     formData.append(
       "audio",
       new File([blob], "audio", { type: options.mediaType }),
       `audio.${fileExtension}`
     );
-    const { value: uploadResponse } = await (0, import_provider_utils2.postFormDataToApi)({
+    const { value: uploadResponse } = await postFormDataToApi({
       url: this.config.url({
         path: "/v2/upload",
         modelId: "default"
       }),
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_e = (_d = this.config).headers) == null ? void 0 : _e.call(_d), options.headers),
       formData,
       failedResponseHandler: gladiaFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         gladiaUploadResponseSchema
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch
     });
     const { body, warnings } = await this.getArgs(options);
-    const { value: transcriptionInitResponse } = await (0, import_provider_utils2.postJsonToApi)({
+    const { value: transcriptionInitResponse } = await postJsonToApi({
       url: this.config.url({
         path: "/v2/pre-recorded",
         modelId: "default"
       }),
-      headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+      headers: combineHeaders((_g = (_f = this.config).headers) == null ? void 0 : _g.call(_f), options.headers),
       body: {
         ...body,
         audio_url: uploadResponse.audio_url
       },
       failedResponseHandler: gladiaFailedResponseHandler,
-      successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+      successfulResponseHandler: createJsonResponseHandler(
         gladiaTranscriptionInitializeResponseSchema
       ),
       abortSignal: options.abortSignal,
@@ -466,17 +470,17 @@ var GladiaTranscriptionModel = class {
     const pollingInterval = 1e3;
     while (true) {
       if (Date.now() - startTime > timeoutMs) {
-        throw new import_provider.AISDKError({
+        throw new AISDKError({
           message: "Transcription job polling timed out",
           name: "TranscriptionJobPollingTimedOut",
           cause: transcriptionResult
         });
       }
-      const response = await (0, import_provider_utils2.getFromApi)({
+      const response = await getFromApi({
         url: resultUrl,
-        headers: (0, import_provider_utils2.combineHeaders)(this.config.headers(), options.headers),
+        headers: combineHeaders((_i = (_h = this.config).headers) == null ? void 0 : _i.call(_h), options.headers),
         failedResponseHandler: gladiaFailedResponseHandler,
-        successfulResponseHandler: (0, import_provider_utils2.createJsonResponseHandler)(
+        successfulResponseHandler: createJsonResponseHandler(
           gladiaTranscriptionResultResponseSchema
         ),
         abortSignal: options.abortSignal,
@@ -488,16 +492,16 @@ var GladiaTranscriptionModel = class {
         break;
       }
       if (transcriptionResult.status === "error") {
-        throw new import_provider.AISDKError({
+        throw new AISDKError({
           message: "Transcription job failed",
           name: "TranscriptionJobFailed",
           cause: transcriptionResult
         });
       }
-      await (0, import_provider_utils2.delay)(pollingInterval);
+      await delay(pollingInterval);
     }
     if (!transcriptionResult.result) {
-      throw new import_provider.AISDKError({
+      throw new AISDKError({
         message: "Transcription result is empty",
         name: "TranscriptionResultEmpty",
         cause: transcriptionResult
@@ -526,26 +530,26 @@ var GladiaTranscriptionModel = class {
     };
   }
 };
-var gladiaUploadResponseSchema = import_v42.z.object({
-  audio_url: import_v42.z.string()
+var gladiaUploadResponseSchema = z3.object({
+  audio_url: z3.string()
 });
-var gladiaTranscriptionInitializeResponseSchema = import_v42.z.object({
-  result_url: import_v42.z.string()
+var gladiaTranscriptionInitializeResponseSchema = z3.object({
+  result_url: z3.string()
 });
-var gladiaTranscriptionResultResponseSchema = import_v42.z.object({
-  status: import_v42.z.enum(["queued", "processing", "done", "error"]),
-  result: import_v42.z.object({
-    metadata: import_v42.z.object({
-      audio_duration: import_v42.z.number()
+var gladiaTranscriptionResultResponseSchema = z3.object({
+  status: z3.enum(["queued", "processing", "done", "error"]),
+  result: z3.object({
+    metadata: z3.object({
+      audio_duration: z3.number()
     }),
-    transcription: import_v42.z.object({
-      full_transcript: import_v42.z.string(),
-      languages: import_v42.z.array(import_v42.z.string()),
-      utterances: import_v42.z.array(
-        import_v42.z.object({
-          start: import_v42.z.number(),
-          end: import_v42.z.number(),
-          text: import_v42.z.string()
+    transcription: z3.object({
+      full_transcript: z3.string(),
+      languages: z3.array(z3.string()),
+      utterances: z3.array(
+        z3.object({
+          start: z3.number(),
+          end: z3.number(),
+          text: z3.string()
         })
       )
     })
@@ -553,13 +557,13 @@ var gladiaTranscriptionResultResponseSchema = import_v42.z.object({
 });
 
 // src/version.ts
-var VERSION = true ? "3.0.0-beta.3" : "0.0.0-test";
+var VERSION = true ? "3.0.0-beta.31" : "0.0.0-test";
 
 // src/gladia-provider.ts
 function createGladia(options = {}) {
-  const getHeaders = () => (0, import_provider_utils3.withUserAgentSuffix)(
+  const getHeaders = () => withUserAgentSuffix(
     {
-      "x-gladia-key": (0, import_provider_utils3.loadApiKey)({
+      "x-gladia-key": loadApiKey({
         apiKey: options.apiKey,
         environmentVariableName: "GLADIA_API_KEY",
         description: "Gladia"
@@ -579,18 +583,18 @@ function createGladia(options = {}) {
       transcription: createTranscriptionModel()
     };
   };
-  provider.specificationVersion = "v3";
+  provider.specificationVersion = "v4";
   provider.transcription = createTranscriptionModel;
   provider.transcriptionModel = createTranscriptionModel;
   provider.languageModel = (modelId) => {
-    throw new import_provider2.NoSuchModelError({
+    throw new NoSuchModelError({
       modelId,
       modelType: "languageModel",
       message: "Gladia does not provide language models"
     });
   };
   provider.embeddingModel = (modelId) => {
-    throw new import_provider2.NoSuchModelError({
+    throw new NoSuchModelError({
       modelId,
       modelType: "embeddingModel",
       message: "Gladia does not provide embedding models"
@@ -598,7 +602,7 @@ function createGladia(options = {}) {
   };
   provider.textEmbeddingModel = provider.embeddingModel;
   provider.imageModel = (modelId) => {
-    throw new import_provider2.NoSuchModelError({
+    throw new NoSuchModelError({
       modelId,
       modelType: "imageModel",
       message: "Gladia does not provide image models"
@@ -607,10 +611,9 @@ function createGladia(options = {}) {
   return provider;
 }
 var gladia = createGladia();
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   VERSION,
   createGladia,
   gladia
-});
+};
 //# sourceMappingURL=index.js.map