@ai-sdk/gladia 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/gladia
 
+## 2.0.9
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
+## 2.0.8
+
+### Patch Changes
+
+- Updated dependencies [5c090e7]
+  - @ai-sdk/provider@3.0.4
+  - @ai-sdk/provider-utils@4.0.8
+
 ## 2.0.7
 
 ### Patch Changes

package/dist/index.js

@@ -553,7 +553,7 @@ var gladiaTranscriptionResultResponseSchema = import_v42.z.object({
 });
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/gladia-provider.ts
 function createGladia(options = {}) {

package/dist/index.mjs

@@ -542,7 +542,7 @@ var gladiaTranscriptionResultResponseSchema = z2.object({
 });
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/gladia-provider.ts
 function createGladia(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/gladia",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -20,15 +21,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "4.0.7"
+    "@ai-sdk/provider": "3.0.4",
+    "@ai-sdk/provider-utils": "4.0.8"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.6.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "1.0.2",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/gladia-api-types.ts

@@ -0,0 +1,134 @@
+export type GladiaTranscriptionInitiateAPITypes = {
+  /** URL to a Gladia file or to an external audio or video file */
+  audio_url: string;
+  /** [Alpha] Context to feed the transcription model with for possible better accuracy */
+  context_prompt?: string;
+  /** [Beta] Can be either boolean to enable custom_vocabulary or an array with specific vocabulary */
+  custom_vocabulary?: boolean | any[];
+  /** [Beta] Custom vocabulary configuration */
+  custom_vocabulary_config?: {
+    /** Vocabulary array with string or object containing value, intensity, pronunciations, and language */
+    vocabulary: Array<
+      | string
+      | {
+          /** Vocabulary value */
+          value: string;
+          /** Intensity of the vocabulary */
+          intensity?: number;
+          /** Pronunciation variations */
+          pronunciations?: string[];
+          /** Language of the vocabulary */
+          language?: string;
+        }
+    >;
+    /** Default intensity for vocabulary */
+    default_intensity?: number;
+  };
+  /** Detect the language from the given audio */
+  detect_language?: boolean;
+  /** Detect multiple languages in the given audio */
+  enable_code_switching?: boolean;
+  /** Configuration for code-switching */
+  code_switching_config?: {
+    /** Specify the languages you want to use when detecting multiple languages */
+    languages?: string[];
+  };
+  /** The original language in iso639-1 format */
+  language?: string;
+  /** Enable callback for this transcription */
+  callback?: boolean;
+  /** Configuration for callback */
+  callback_config?: {
+    /** The URL to be called with the result of the transcription */
+    url: string;
+    /** The HTTP method to be used */
+    method?: 'POST' | 'PUT';
+  };
+  /** Enable subtitles generation for this transcription */
+  subtitles?: boolean;
+  /** Configuration for subtitles */
+  subtitles_config?: {
+    /** Subtitles formats */
+    formats?: ('srt' | 'vtt')[];
+    /** Minimum duration of a subtitle in seconds */
+    minimum_duration?: number;
+    /** Maximum duration of a subtitle in seconds */
+    maximum_duration?: number;
+    /** Maximum number of characters per row */
+    maximum_characters_per_row?: number;
+    /** Maximum number of rows per caption */
+    maximum_rows_per_caption?: number;
+    /** Style of the subtitles */
+    style?: 'default' | 'compliance';
+  };
+  /** Enable speaker recognition (diarization) for this audio */
+  diarization?: boolean;
+  /** Configuration for diarization */
+  diarization_config?: {
+    /** Exact number of speakers in the audio */
+    number_of_speakers?: number;
+    /** Minimum number of speakers in the audio */
+    min_speakers?: number;
+    /** Maximum number of speakers in the audio */
+    max_speakers?: number;
+    /** [Alpha] Use enhanced diarization for this audio */
+    enhanced?: boolean;
+  };
+  /** [Beta] Enable translation for this audio */
+  translation?: boolean;
+  /** Configuration for translation */
+  translation_config?: {
+    /** The target language in iso639-1 format */
+    target_languages: string[];
+    /** Model for translation */
+    model?: 'base' | 'enhanced';
+    /** Align translated utterances with the original ones */
+    match_original_utterances?: boolean;
+  };
+  /** [Beta] Enable summarization for this audio */
+  summarization?: boolean;
+  /** Configuration for summarization */
+  summarization_config?: {
+    /** The type of summarization to apply */
+    type?: 'general' | 'bullet_points' | 'concise';
+  };
+  /** [Alpha] Enable moderation for this audio */
+  moderation?: boolean;
+  /** [Alpha] Enable named entity recognition for this audio */
+  named_entity_recognition?: boolean;
+  /** [Alpha] Enable chapterization for this audio */
+  chapterization?: boolean;
+  /** [Alpha] Enable names consistency for this audio */
+  name_consistency?: boolean;
+  /** [Alpha] Enable custom spelling for this audio */
+  custom_spelling?: boolean;
+  /** Configuration for custom spelling */
+  custom_spelling_config?: {
+    /** The list of spelling applied on the audio transcription */
+    spelling_dictionary: Record<string, string[]>;
+  };
+  /** [Alpha] Enable structured data extraction for this audio */
+  structured_data_extraction?: boolean;
+  /** Configuration for structured data extraction */
+  structured_data_extraction_config?: {
+    /** The list of classes to extract from the audio transcription */
+    classes: string[];
+  };
+  /** [Alpha] Enable sentiment analysis for this audio */
+  sentiment_analysis?: boolean;
+  /** [Alpha] Enable audio to llm processing for this audio */
+  audio_to_llm?: boolean;
+  /** Configuration for audio to llm */
+  audio_to_llm_config?: {
+    /** The list of prompts applied on the audio transcription */
+    prompts: string[];
+  };
+  /** Custom metadata you can attach to this transcription */
+  custom_metadata?: Record<string, any>;
+  /** Enable sentences for this audio */
+  sentences?: boolean;
+  /** [Alpha] Allows to change the output display_mode for this audio */
+  display_mode?: boolean;
+  /** [Alpha] Use enhanced punctuation for this audio */
+  punctuation_enhanced?: boolean;
+};

package/src/gladia-config.ts

@@ -0,0 +1,9 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export type GladiaConfig = {
+  provider: string;
+  url: (options: { modelId: string; path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+};

package/src/gladia-error.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { gladiaErrorDataSchema } from './gladia-error';
+import { describe, it, expect } from 'vitest';
+
+describe('gladiaErrorDataSchema', () => {
+  it('should parse Gladia resource exhausted error', async () => {
+    const error = `
+{"error":{"message":"{\\n  \\"error\\": {\\n    \\"code\\": 429,\\n    \\"message\\": \\"Resource has been exhausted (e.g. check quota).\\",\\n    \\"status\\": \\"RESOURCE_EXHAUSTED\\"\\n  }\\n}\\n","code":429}}
+`;
+
+    const result = await safeParseJSON({
+      text: error,
+      schema: gladiaErrorDataSchema,
+    });
+
+    expect(result).toStrictEqual({
+      success: true,
+      value: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+      rawValue: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+    });
+  });
+});

package/src/gladia-error.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+
+export const gladiaErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.number(),
+  }),
+});
+
+export type GladiaErrorData = z.infer<typeof gladiaErrorDataSchema>;
+
+export const gladiaFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: gladiaErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/gladia-provider.ts

@@ -0,0 +1,117 @@
+import {
+  TranscriptionModelV3,
+  ProviderV3,
+  NoSuchModelError,
+} from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { GladiaTranscriptionModel } from './gladia-transcription-model';
+import { VERSION } from './version';
+
+export interface GladiaProvider extends ProviderV3 {
+  (): {
+    transcription: GladiaTranscriptionModel;
+  };
+
+  /**
+Creates a model for transcription.
+   */
+  transcription(): TranscriptionModelV3;
+
+  /**
+   * @deprecated Use `embeddingModel` instead.
+   */
+  textEmbeddingModel(modelId: string): never;
+}
+
+export interface GladiaProviderSettings {
+  /**
+API key for authenticating requests.
+     */
+  apiKey?: string;
+
+  /**
+Custom headers to include in the requests.
+     */
+  headers?: Record<string, string>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+    */
+  fetch?: FetchFunction;
+}
+
+/**
+Create a Gladia provider instance.
+ */
+export function createGladia(
+  options: GladiaProviderSettings = {},
+): GladiaProvider {
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        'x-gladia-key': loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'GLADIA_API_KEY',
+          description: 'Gladia',
+        }),
+        ...options.headers,
+      },
+      `ai-sdk/gladia/${VERSION}`,
+    );
+
+  const createTranscriptionModel = () =>
+    new GladiaTranscriptionModel('default', {
+      provider: `gladia.transcription`,
+      url: ({ path }) => `https://api.gladia.io${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function () {
+    return {
+      transcription: createTranscriptionModel(),
+    };
+  };
+
+  provider.specificationVersion = 'v3' as const;
+  provider.transcription = createTranscriptionModel;
+  provider.transcriptionModel = createTranscriptionModel;
+
+  // Required ProviderV3 methods that are not supported
+  provider.languageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'languageModel',
+      message: 'Gladia does not provide language models',
+    });
+  };
+
+  provider.embeddingModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'embeddingModel',
+      message: 'Gladia does not provide embedding models',
+    });
+  };
+  provider.textEmbeddingModel = provider.embeddingModel;
+
+  provider.imageModel = (modelId: string) => {
+    throw new NoSuchModelError({
+      modelId,
+      modelType: 'imageModel',
+      message: 'Gladia does not provide image models',
+    });
+  };
+
+  return provider as GladiaProvider;
+}
+
+/**
+Default Gladia provider instance.
+ */
+export const gladia = createGladia();

package/src/gladia-transcription-model.test.ts

@@ -0,0 +1,230 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { GladiaTranscriptionModel } from './gladia-transcription-model';
+import { createGladia } from './gladia-provider';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const audioData = await readFile(path.join(__dirname, 'transcript-test.mp3'));
+const provider = createGladia({ apiKey: 'test-api-key' });
+const model = provider.transcription();
+
+const server = createTestServer({
+  'https://api.gladia.io/v2/upload': {
+    response: {
+      type: 'json-value',
+      body: {
+        audio_url: 'https://storage.gladia.io/mock-upload-url',
+        audio_metadata: {
+          id: 'test-id',
+          filename: 'test-file.mp3',
+          extension: 'mp3',
+          size: 1024,
+          audio_duration: 60,
+          number_of_channels: 2,
+        },
+      },
+    },
+  },
+  'https://api.gladia.io/v2/pre-recorded': {},
+  'https://api.gladia.io/v2/transcription/test-id': {},
+});
+
+describe('doGenerate', () => {
+  function prepareJsonResponse({
+    headers,
+  }: {
+    headers?: Record<string, string>;
+  } = {}) {
+    // No need to set the upload response here as it's already set in the server creation
+    server.urls['https://api.gladia.io/v2/pre-recorded'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        id: 'test-id',
+        result_url: 'https://api.gladia.io/v2/transcription/test-id',
+      },
+    };
+    server.urls['https://api.gladia.io/v2/transcription/test-id'].response = {
+      type: 'json-value',
+      headers,
+      body: {
+        id: '45463597-20b7-4af7-b3b3-f5fb778203ab',
+        request_id: 'G-45463597',
+        version: 2,
+        status: 'done',
+        created_at: '2023-12-28T09:04:17.210Z',
+        completed_at: '2023-12-28T09:04:37.210Z',
+        custom_metadata: {},
+        error_code: null,
+        kind: 'pre-recorded',
+        file: {
+          id: 'test-id',
+          filename: 'test-file.mp3',
+          source: 'upload',
+          audio_duration: 60,
+          number_of_channels: 2,
+        },
+        request_params: {
+          audio_url: 'https://storage.gladia.io/mock-upload-url',
+        },
+        result: {
+          metadata: {
+            audio_duration: 60,
+            number_of_distinct_channels: 2,
+            billing_time: 60,
+            transcription_time: 20,
+          },
+          transcription: {
+            full_transcript: 'Smoke from hundreds of wildfires.',
+            languages: ['en'],
+            utterances: [
+              {
+                language: 'en',
+                start: 0,
+                end: 3,
+                confidence: 0.95,
+                channel: 1,
+                speaker: 1,
+                words: [
+                  {
+                    word: 'Smoke',
+                    start: 0,
+                    end: 1,
+                    confidence: 0.95,
+                  },
+                  {
+                    word: 'from',
+                    start: 1,
+                    end: 2,
+                    confidence: 0.95,
+                  },
+                  {
+                    word: 'hundreds',
+                    start: 2,
+                    end: 3,
+                    confidence: 0.95,
+                  },
+                ],
+                text: 'Smoke from hundreds of wildfires.',
+              },
+            ],
+          },
+        },
+      },
+    };
+  }
+
+  it('should pass the model', async () => {
+    prepareJsonResponse();
+
+    await model.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(await server.calls[1].requestBodyJson).toMatchObject({
+      audio_url: 'https://storage.gladia.io/mock-upload-url',
+    });
+  });
+
+  it('should pass headers', async () => {
+    prepareJsonResponse();
+
+    const provider = createGladia({
+      apiKey: 'test-api-key',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.transcription().doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[1].requestHeaders).toMatchObject({
+      'x-gladia-key': 'test-api-key',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/gladia/0.0.0-test`,
+    );
+  });
+
+  it('should extract the transcription text', async () => {
+    prepareJsonResponse();
+
+    const result = await model.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.text).toBe('Smoke from hundreds of wildfires.');
+  });
+
+  it('should include response data with timestamp, modelId and headers', async () => {
+    prepareJsonResponse({
+      headers: {
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+
+    const testDate = new Date(0);
+    const customModel = new GladiaTranscriptionModel('default', {
+      provider: 'test-provider',
+      url: ({ path }) => `https://api.gladia.io${path}`,
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.response).toMatchObject({
+      timestamp: testDate,
+      modelId: 'default',
+      headers: {
+        'content-type': 'application/json',
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+  });
+
+  it('should use real date when no custom date provider is specified', async () => {
+    prepareJsonResponse();
+
+    const testDate = new Date(0);
+    const customModel = new GladiaTranscriptionModel('default', {
+      provider: 'test-provider',
+      url: ({ path }) => `https://api.gladia.io${path}`,
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      audio: audioData,
+      mediaType: 'audio/wav',
+    });
+
+    expect(result.response.timestamp.getTime()).toEqual(testDate.getTime());
+    expect(result.response.modelId).toBe('default');
+  });
+});

package/src/gladia-transcription-model.ts

@@ -0,0 +1,652 @@
+import {
+  AISDKError,
+  TranscriptionModelV3,
+  SharedV3Warning,
+} from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  convertBase64ToUint8Array,
+  createJsonResponseHandler,
+  mediaTypeToExtension,
+  delay,
+  getFromApi,
+  parseProviderOptions,
+  postFormDataToApi,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { GladiaConfig } from './gladia-config';
+import { gladiaFailedResponseHandler } from './gladia-error';
+import { GladiaTranscriptionInitiateAPITypes } from './gladia-api-types';
+
+// https://docs.gladia.io/api-reference/v2/pre-recorded/init
+const gladiaProviderOptionsSchema = z.object({
+  /**
+   * Optional context prompt to guide the transcription.
+   */
+  contextPrompt: z.string().nullish(),
+
+  /**
+   * Custom vocabulary to improve transcription accuracy.
+   * Can be a boolean or an array of custom terms.
+   */
+  customVocabulary: z.union([z.boolean(), z.array(z.any())]).nullish(),
+
+  /**
+   * Configuration for custom vocabulary.
+   */
+  customVocabularyConfig: z
+    .object({
+      /**
+       * Array of vocabulary terms or objects with pronunciation details.
+       */
+      vocabulary: z.array(
+        z.union([
+          z.string(),
+          z.object({
+            /**
+             * The vocabulary term.
+             */
+            value: z.string(),
+            /**
+             * Intensity of the term in recognition (optional).
+             */
+            intensity: z.number().nullish(),
+            /**
+             * Alternative pronunciations for the term (optional).
+             */
+            pronunciations: z.array(z.string()).nullish(),
+            /**
+             * Language of the term (optional).
+             */
+            language: z.string().nullish(),
+          }),
+        ]),
+      ),
+      /**
+       * Default intensity for all vocabulary terms.
+       */
+      defaultIntensity: z.number().nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to automatically detect the language of the audio.
+   */
+  detectLanguage: z.boolean().nullish(),
+
+  /**
+   * Whether to enable code switching (multiple languages in the same audio).
+   */
+  enableCodeSwitching: z.boolean().nullish(),
+
+  /**
+   * Configuration for code switching.
+   */
+  codeSwitchingConfig: z
+    .object({
+      /**
+       * Languages to consider for code switching.
+       */
+      languages: z.array(z.string()).nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Specific language for transcription.
+   */
+  language: z.string().nullish(),
+
+  /**
+   * Whether to enable callback when transcription is complete.
+   */
+  callback: z.boolean().nullish(),
+
+  /**
+   * Configuration for callback.
+   */
+  callbackConfig: z
+    .object({
+      /**
+       * URL to send the callback to.
+       */
+      url: z.string(),
+      /**
+       * HTTP method for the callback.
+       */
+      method: z.enum(['POST', 'PUT']).nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to generate subtitles.
+   */
+  subtitles: z.boolean().nullish(),
+
+  /**
+   * Configuration for subtitles generation.
+   */
+  subtitlesConfig: z
+    .object({
+      /**
+       * Subtitle file formats to generate.
+       */
+      formats: z.array(z.enum(['srt', 'vtt'])).nullish(),
+      /**
+       * Minimum duration for subtitle segments.
+       */
+      minimumDuration: z.number().nullish(),
+      /**
+       * Maximum duration for subtitle segments.
+       */
+      maximumDuration: z.number().nullish(),
+      /**
+       * Maximum characters per row in subtitles.
+       */
+      maximumCharactersPerRow: z.number().nullish(),
+      /**
+       * Maximum rows per caption in subtitles.
+       */
+      maximumRowsPerCaption: z.number().nullish(),
+      /**
+       * Style of subtitles.
+       */
+      style: z.enum(['default', 'compliance']).nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to enable speaker diarization (speaker identification).
+   */
+  diarization: z.boolean().nullish(),
+
+  /**
+   * Configuration for diarization.
+   */
+  diarizationConfig: z
+    .object({
+      /**
+       * Exact number of speakers to identify.
+       */
+      numberOfSpeakers: z.number().nullish(),
+      /**
+       * Minimum number of speakers to identify.
+       */
+      minSpeakers: z.number().nullish(),
+      /**
+       * Maximum number of speakers to identify.
+       */
+      maxSpeakers: z.number().nullish(),
+      /**
+       * Whether to use enhanced diarization.
+       */
+      enhanced: z.boolean().nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to translate the transcription.
+   */
+  translation: z.boolean().nullish(),
+
+  /**
+   * Configuration for translation.
+   */
+  translationConfig: z
+    .object({
+      /**
+       * Target languages for translation.
+       */
+      targetLanguages: z.array(z.string()),
+      /**
+       * Translation model to use.
+       */
+      model: z.enum(['base', 'enhanced']).nullish(),
+      /**
+       * Whether to match original utterances in translation.
+       */
+      matchOriginalUtterances: z.boolean().nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to generate a summary of the transcription.
+   */
+  summarization: z.boolean().nullish(),
+
+  /**
+   * Configuration for summarization.
+   */
+  summarizationConfig: z
+    .object({
+      /**
+       * Type of summary to generate.
+       */
+      type: z.enum(['general', 'bullet_points', 'concise']).nullish(),
+    })
+    .nullish(),
+
+  /**
+   * Whether to enable content moderation.
+   */
+  moderation: z.boolean().nullish(),
+
+  /**
+   * Whether to enable named entity recognition.
+   */
+  namedEntityRecognition: z.boolean().nullish(),
+
+  /**
+   * Whether to enable automatic chapter creation.
+   */
+  chapterization: z.boolean().nullish(),
+
+  /**
+   * Whether to ensure consistent naming of entities.
+   */
+  nameConsistency: z.boolean().nullish(),
+
+  /**
+   * Whether to enable custom spelling.
+   */
+  customSpelling: z.boolean().nullish(),
+
+  /**
+   * Configuration for custom spelling.
+   */
+  customSpellingConfig: z
+    .object({
+      /**
+       * Dictionary of custom spellings.
+       */
+      spellingDictionary: z.record(z.string(), z.array(z.string())),
+    })
+    .nullish(),
+
+  /**
+   * Whether to extract structured data from the transcription.
+   */
+  structuredDataExtraction: z.boolean().nullish(),
+
+  /**
+   * Configuration for structured data extraction.
+   */
+  structuredDataExtractionConfig: z
+    .object({
+      /**
+       * Classes of data to extract.
+       */
+      classes: z.array(z.string()),
+    })
+    .nullish(),
+
+  /**
+   * Whether to perform sentiment analysis on the transcription.
+   */
+  sentimentAnalysis: z.boolean().nullish(),
+
+  /**
+   * Whether to send audio to a language model for processing.
+   */
+  audioToLlm: z.boolean().nullish(),
+
+  /**
+   * Configuration for audio to language model processing.
+   */
+  audioToLlmConfig: z
+    .object({
+      /**
+       * Prompts to send to the language model.
+       */
+      prompts: z.array(z.string()),
+    })
+    .nullish(),
+
+  /**
+   * Custom metadata to include with the transcription.
+   */
+  customMetadata: z.record(z.string(), z.any()).nullish(),
+
+  /**
+   * Whether to include sentence-level segmentation.
+   */
+  sentences: z.boolean().nullish(),
+
+  /**
+   * Whether to enable display mode.
+   */
+  displayMode: z.boolean().nullish(),
+
+  /**
+   * Whether to enhance punctuation in the transcription.
+   */
+  punctuationEnhanced: z.boolean().nullish(),
+});
+
+export type GladiaTranscriptionCallOptions = z.infer<
+  typeof gladiaProviderOptionsSchema
+>;
+
+interface GladiaTranscriptionModelConfig extends GladiaConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class GladiaTranscriptionModel implements TranscriptionModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: 'default',
+    private readonly config: GladiaTranscriptionModelConfig,
+  ) {}
+
+  private async getArgs({
+    providerOptions,
+  }: Parameters<TranscriptionModelV3['doGenerate']>[0]) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const gladiaOptions = await parseProviderOptions({
+      provider: 'gladia',
+      providerOptions,
+      schema: gladiaProviderOptionsSchema,
+    });
+
+    const body: Omit<GladiaTranscriptionInitiateAPITypes, 'audio_url'> = {};
+
+    // Add provider-specific options
+    if (gladiaOptions) {
+      body.context_prompt = gladiaOptions.contextPrompt ?? undefined;
+      body.custom_vocabulary = gladiaOptions.customVocabulary ?? undefined;
+      body.detect_language = gladiaOptions.detectLanguage ?? undefined;
+      body.enable_code_switching =
+        gladiaOptions.enableCodeSwitching ?? undefined;
+      body.language = gladiaOptions.language ?? undefined;
+      body.callback = gladiaOptions.callback ?? undefined;
+      body.subtitles = gladiaOptions.subtitles ?? undefined;
+      body.diarization = gladiaOptions.diarization ?? undefined;
+      body.translation = gladiaOptions.translation ?? undefined;
+      body.summarization = gladiaOptions.summarization ?? undefined;
+      body.moderation = gladiaOptions.moderation ?? undefined;
+      body.named_entity_recognition =
+        gladiaOptions.namedEntityRecognition ?? undefined;
+      body.chapterization = gladiaOptions.chapterization ?? undefined;
+      body.name_consistency = gladiaOptions.nameConsistency ?? undefined;
+      body.custom_spelling = gladiaOptions.customSpelling ?? undefined;
+      body.structured_data_extraction =
+        gladiaOptions.structuredDataExtraction ?? undefined;
+      body.structured_data_extraction_config =
+        gladiaOptions.structuredDataExtractionConfig ?? undefined;
+      body.sentiment_analysis = gladiaOptions.sentimentAnalysis ?? undefined;
+      body.audio_to_llm = gladiaOptions.audioToLlm ?? undefined;
+      body.audio_to_llm_config = gladiaOptions.audioToLlmConfig ?? undefined;
+      body.custom_metadata = gladiaOptions.customMetadata ?? undefined;
+      body.sentences = gladiaOptions.sentences ?? undefined;
+      body.display_mode = gladiaOptions.displayMode ?? undefined;
+      body.punctuation_enhanced =
+        gladiaOptions.punctuationEnhanced ?? undefined;
+
+      if (gladiaOptions.customVocabularyConfig) {
+        body.custom_vocabulary_config = {
+          vocabulary: gladiaOptions.customVocabularyConfig.vocabulary.map(
+            item => {
+              if (typeof item === 'string') return item;
+              return {
+                value: item.value,
+                intensity: item.intensity ?? undefined,
+                pronunciations: item.pronunciations ?? undefined,
+                language: item.language ?? undefined,
+              };
+            },
+          ),
+          default_intensity:
+            gladiaOptions.customVocabularyConfig.defaultIntensity ?? undefined,
+        };
+      }
+
+      // Handle code switching config
+      if (gladiaOptions.codeSwitchingConfig) {
+        body.code_switching_config = {
+          languages: gladiaOptions.codeSwitchingConfig.languages ?? undefined,
+        };
+      }
+
+      // Handle callback config
+      if (gladiaOptions.callbackConfig) {
+        body.callback_config = {
+          url: gladiaOptions.callbackConfig.url,
+          method: gladiaOptions.callbackConfig.method ?? undefined,
+        };
+      }
+
+      // Handle subtitles config
+      if (gladiaOptions.subtitlesConfig) {
+        body.subtitles_config = {
+          formats: gladiaOptions.subtitlesConfig.formats ?? undefined,
+          minimum_duration:
+            gladiaOptions.subtitlesConfig.minimumDuration ?? undefined,
+          maximum_duration:
+            gladiaOptions.subtitlesConfig.maximumDuration ?? undefined,
+          maximum_characters_per_row:
+            gladiaOptions.subtitlesConfig.maximumCharactersPerRow ?? undefined,
+          maximum_rows_per_caption:
+            gladiaOptions.subtitlesConfig.maximumRowsPerCaption ?? undefined,
+          style: gladiaOptions.subtitlesConfig.style ?? undefined,
+        };
+      }
+
+      // Handle diarization config
+      if (gladiaOptions.diarizationConfig) {
+        body.diarization_config = {
+          number_of_speakers:
+            gladiaOptions.diarizationConfig.numberOfSpeakers ?? undefined,
+          min_speakers:
+            gladiaOptions.diarizationConfig.minSpeakers ?? undefined,
+          max_speakers:
+            gladiaOptions.diarizationConfig.maxSpeakers ?? undefined,
+          enhanced: gladiaOptions.diarizationConfig.enhanced ?? undefined,
+        };
+      }
+
+      // Handle translation config
+      if (gladiaOptions.translationConfig) {
+        body.translation_config = {
+          target_languages: gladiaOptions.translationConfig.targetLanguages,
+          model: gladiaOptions.translationConfig.model ?? undefined,
+          match_original_utterances:
+            gladiaOptions.translationConfig.matchOriginalUtterances ??
+            undefined,
+        };
+      }
+
+      // Handle summarization config
+      if (gladiaOptions.summarizationConfig) {
+        body.summarization_config = {
+          type: gladiaOptions.summarizationConfig.type ?? undefined,
+        };
+      }
+
+      // Handle custom spelling config
+      if (gladiaOptions.customSpellingConfig) {
+        body.custom_spelling_config = {
+          spelling_dictionary:
+            gladiaOptions.customSpellingConfig.spellingDictionary,
+        };
+      }
+    }
+
+    return {
+      body,
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: Parameters<TranscriptionModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<TranscriptionModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+
+    // Create form data with base fields
+    const formData = new FormData();
+    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 postFormDataToApi({
+      url: this.config.url({
+        path: '/v2/upload',
+        modelId: 'default',
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      formData,
+      failedResponseHandler: gladiaFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        gladiaUploadResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    const { body, warnings } = await this.getArgs(options);
+
+    const { value: transcriptionInitResponse } = await postJsonToApi({
+      url: this.config.url({
+        path: '/v2/pre-recorded',
+        modelId: 'default',
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: {
+        ...body,
+        audio_url: uploadResponse.audio_url,
+      },
+      failedResponseHandler: gladiaFailedResponseHandler,
+      successfulResponseHandler: createJsonResponseHandler(
+        gladiaTranscriptionInitializeResponseSchema,
+      ),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    // Poll the result URL until the transcription is done or an error occurs
+    const resultUrl = transcriptionInitResponse.result_url;
+    let transcriptionResult;
+    let transcriptionResultHeaders;
+    const timeoutMs = 60 * 1000; // 60 seconds timeout
+    const startTime = Date.now();
+    const pollingInterval = 1000;
+
+    while (true) {
+      // Check if we've exceeded the timeout
+      if (Date.now() - startTime > timeoutMs) {
+        throw new AISDKError({
+          message: 'Transcription job polling timed out',
+          name: 'TranscriptionJobPollingTimedOut',
+          cause: transcriptionResult,
+        });
+      }
+
+      const response = await getFromApi({
+        url: resultUrl,
+        headers: combineHeaders(this.config.headers(), options.headers),
+        failedResponseHandler: gladiaFailedResponseHandler,
+        successfulResponseHandler: createJsonResponseHandler(
+          gladiaTranscriptionResultResponseSchema,
+        ),
+        abortSignal: options.abortSignal,
+        fetch: this.config.fetch,
+      });
+
+      transcriptionResult = response.value;
+      transcriptionResultHeaders = response.responseHeaders;
+
+      if (transcriptionResult.status === 'done') {
+        break;
+      }
+
+      if (transcriptionResult.status === 'error') {
+        throw new AISDKError({
+          message: 'Transcription job failed',
+          name: 'TranscriptionJobFailed',
+          cause: transcriptionResult,
+        });
+      }
+
+      // Wait for the configured polling interval before checking again
+      await delay(pollingInterval);
+    }
+
+    if (!transcriptionResult.result) {
+      throw new AISDKError({
+        message: 'Transcription result is empty',
+        name: 'TranscriptionResultEmpty',
+        cause: transcriptionResult,
+      });
+    }
+
+    // Process the successful result
+    return {
+      text: transcriptionResult.result.transcription.full_transcript,
+      durationInSeconds: transcriptionResult.result.metadata.audio_duration,
+      language: transcriptionResult.result.transcription.languages.at(0),
+      segments: transcriptionResult.result.transcription.utterances.map(
+        utterance => ({
+          text: utterance.text,
+          startSecond: utterance.start,
+          endSecond: utterance.end,
+        }),
+      ),
+      response: {
+        timestamp: currentDate,
+        modelId: 'default',
+        headers: transcriptionResultHeaders,
+      },
+      providerMetadata: {
+        gladia: transcriptionResult,
+      },
+      warnings,
+    };
+  }
+}
+
+const gladiaUploadResponseSchema = z.object({
+  audio_url: z.string(),
+});
+
+const gladiaTranscriptionInitializeResponseSchema = z.object({
+  result_url: z.string(),
+});
+
+const gladiaTranscriptionResultResponseSchema = z.object({
+  status: z.enum(['queued', 'processing', 'done', 'error']),
+  result: z
+    .object({
+      metadata: z.object({
+        audio_duration: z.number(),
+      }),
+      transcription: z.object({
+        full_transcript: z.string(),
+        languages: z.array(z.string()),
+        utterances: z.array(
+          z.object({
+            start: z.number(),
+            end: z.number(),
+            text: z.string(),
+          }),
+        ),
+      }),
+    })
+    .nullish(),
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createGladia, gladia } from './gladia-provider';
+export type { GladiaProvider, GladiaProviderSettings } from './gladia-provider';
+export { VERSION } from './version';

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';